gst/flv/gstflvmux.c

   1 /* GStreamer
   2  *
   3  * Copyright (c) 2008,2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-flvmux
  23  *
  24  * flvmux muxes different streams into an FLV file.
  25  *
  26  * <refsect2>
  27  * <title>Example launch line</title>
  28  * |[
  29  * gst-launch -v filesrc location=/path/to/audio ! decodebin2 ! queue ! flvmux name=m ! filesink location=file.flv   filesrc location=/path/to/video ! decodebin2 ! queue ! m.
  30  * ]| This pipeline muxes an audio and video file into a single FLV file.
  31  * </refsect2>
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include <math.h>
  39 #include <string.h>
  40
  41 #include "gstflvmux.h"
  42 #include "amfdefs.h"
  43
  44 GST_DEBUG_CATEGORY_STATIC (flvmux_debug);
  45 #define GST_CAT_DEFAULT flvmux_debug
  46
  47 enum
  48 {
  49   PROP_0,
  50   PROP_STREAMABLE
  51 };
  52
  53 #define DEFAULT_STREAMABLE FALSE
  54 #define MAX_INDEX_ENTRIES 128
  55
  56 static GstStaticPadTemplate src_templ = GST_STATIC_PAD_TEMPLATE ("src",
  57     GST_PAD_SRC,
  58     GST_PAD_ALWAYS,
  59     GST_STATIC_CAPS ("video/x-flv")
  60     );
  61
  62 static GstStaticPadTemplate videosink_templ = GST_STATIC_PAD_TEMPLATE ("video",
  63     GST_PAD_SINK,
  64     GST_PAD_REQUEST,
  65     GST_STATIC_CAPS ("video/x-flash-video; "
  66         "video/x-flash-screen; "
  67         "video/x-vp6-flash; " "video/x-vp6-alpha; "
  68         "video/x-h264, stream-format=avc;")
  69     );
  70
  71 static GstStaticPadTemplate audiosink_templ = GST_STATIC_PAD_TEMPLATE ("audio",
  72     GST_PAD_SINK,
  73     GST_PAD_REQUEST,
  74     GST_STATIC_CAPS
  75     ("audio/x-adpcm, layout = (string) swf, channels = (int) { 1, 2 }, rate = (int) { 5512, 11025, 22050, 44100 }; "
  76         "audio/mpeg, mpegversion = (int) 1, layer = (int) 3, channels = (int) { 1, 2 }, rate = (int) { 5512, 8000, 11025, 22050, 44100 }, parsed = (boolean) TRUE; "
  77         "audio/mpeg, mpegversion = (int) { 2, 4 }, framed = (boolean) TRUE; "
  78         "audio/x-nellymoser, channels = (int) { 1, 2 }, rate = (int) { 5512, 8000, 11025, 16000, 22050, 44100 }; "
  79         "audio/x-raw-int, endianness = (int) LITTLE_ENDIAN, channels = (int) { 1, 2 }, width = (int) 8, depth = (int) 8, rate = (int) { 5512, 11025, 22050, 44100 }, signed = (boolean) FALSE; "
  80         "audio/x-raw-int, endianness = (int) LITTLE_ENDIAN, channels = (int) { 1, 2 }, width = (int) 16, depth = (int) 16, rate = (int) { 5512, 11025, 22050, 44100 }, signed = (boolean) TRUE; "
  81         "audio/x-alaw, channels = (int) { 1, 2 }, rate = (int) { 5512, 11025, 22050, 44100 }; "
  82         "audio/x-mulaw, channels = (int) { 1, 2 }, rate = (int) { 5512, 11025, 22050, 44100 }; "
  83         "audio/x-speex, channels = (int) { 1, 2 }, rate = (int) { 5512, 11025, 22050, 44100 };")
  84     );
  85
  86 #define _do_init(type)                                                          \
  87   G_STMT_START{                                                                 \
  88     static const GInterfaceInfo tag_setter_info = {                             \
  89       NULL,                                                                     \
  90       NULL,                                                                     \
  91       NULL                                                                      \
  92     };                                                                          \
  93     g_type_add_interface_static (type, GST_TYPE_TAG_SETTER,                     \
  94                                  &tag_setter_info);                             \
  95   }G_STMT_END
  96
  97 GST_BOILERPLATE_FULL (GstFlvMux, gst_flv_mux, GstElement, GST_TYPE_ELEMENT,
  98     _do_init);
  99
 100 static void gst_flv_mux_finalize (GObject * object);
 101 static GstFlowReturn
 102 gst_flv_mux_handle_buffer (GstCollectPads2 * pads, GstCollectData2 * cdata,
 103     GstBuffer * buf, gpointer user_data);
 104 static gboolean
 105 gst_flv_mux_handle_sink_event (GstCollectPads2 * pads, GstCollectData2 * data,
 106     GstEvent * event, gpointer user_data);
 107
 108 static gboolean gst_flv_mux_handle_src_event (GstPad * pad, GstEvent * event);
 109 static GstPad *gst_flv_mux_request_new_pad (GstElement * element,
 110     GstPadTemplate * templ, const gchar * name);
 111 static void gst_flv_mux_release_pad (GstElement * element, GstPad * pad);
 112
 113 static void gst_flv_mux_get_property (GObject * object,
 114     guint prop_id, GValue * value, GParamSpec * pspec);
 115 static void gst_flv_mux_set_property (GObject * object,
 116     guint prop_id, const GValue * value, GParamSpec * pspec);
 117
 118 static GstStateChangeReturn
 119 gst_flv_mux_change_state (GstElement * element, GstStateChange transition);
 120
 121 static void gst_flv_mux_reset (GstElement * element);
 122 static void gst_flv_mux_reset_pad (GstFlvMux * mux, GstFlvPad * pad,
 123     gboolean video);
 124
 125 typedef struct
 126 {
 127   gdouble position;
 128   gdouble time;
 129 } GstFlvMuxIndexEntry;
 130
 131 static void
 132 gst_flv_mux_index_entry_free (GstFlvMuxIndexEntry * entry)
 133 {
 134   g_slice_free (GstFlvMuxIndexEntry, entry);
 135 }
 136
 137 static void
 138 gst_flv_mux_base_init (gpointer g_class)
 139 {
 140   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 141
 142   gst_element_class_add_static_pad_template (element_class,
 143       &videosink_templ);
 144   gst_element_class_add_static_pad_template (element_class,
 145       &audiosink_templ);
 146   gst_element_class_add_static_pad_template (element_class, &src_templ);
 147   gst_element_class_set_details_simple (element_class, "FLV muxer",
 148       "Codec/Muxer",
 149       "Muxes video/audio streams into a FLV stream",
 150       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 151
 152   GST_DEBUG_CATEGORY_INIT (flvmux_debug, "flvmux", 0, "FLV muxer");
 153 }
 154
 155 static void
 156 gst_flv_mux_class_init (GstFlvMuxClass * klass)
 157 {
 158   GObjectClass *gobject_class;
 159   GstElementClass *gstelement_class;
 160
 161   GST_DEBUG_CATEGORY_INIT (flvmux_debug, "flvmux", 0, "FLV muxer");
 162
 163   gobject_class = (GObjectClass *) klass;
 164   gstelement_class = (GstElementClass *) klass;
 165
 166   gobject_class->get_property = gst_flv_mux_get_property;
 167   gobject_class->set_property = gst_flv_mux_set_property;
 168   gobject_class->finalize = gst_flv_mux_finalize;
 169
 170   /* FIXME: ideally the right mode of operation should be detected
 171    * automatically using queries when parameter not specified. */
 172   /**
 173    * GstFlvMux:streamable
 174    *
 175    * If True, the output will be streaming friendly. (ie without indexes and
 176    * duration)
 177    *
 178    * Since: 0.10.24
 179    **/
 180   g_object_class_install_property (gobject_class, PROP_STREAMABLE,
 181       g_param_spec_boolean ("streamable", "streamable",
 182           "If set to true, the output should be as if it is to be streamed "
 183           "and hence no indexes written or duration written.",
 184           DEFAULT_STREAMABLE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 185
 186   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_flv_mux_change_state);
 187   gstelement_class->request_new_pad =
 188       GST_DEBUG_FUNCPTR (gst_flv_mux_request_new_pad);
 189   gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_flv_mux_release_pad);
 190 }
 191
 192 static void
 193 gst_flv_mux_init (GstFlvMux * mux, GstFlvMuxClass * g_class)
 194 {
 195   mux->srcpad = gst_pad_new_from_static_template (&src_templ, "src");
 196   gst_pad_set_event_function (mux->srcpad, gst_flv_mux_handle_src_event);
 197   gst_element_add_pad (GST_ELEMENT (mux), mux->srcpad);
 198
 199   /* property */
 200   mux->streamable = DEFAULT_STREAMABLE;
 201
 202   mux->new_tags = FALSE;
 203
 204   mux->collect = gst_collect_pads2_new ();
 205   gst_collect_pads2_set_buffer_function (mux->collect,
 206       GST_DEBUG_FUNCPTR (gst_flv_mux_handle_buffer), mux);
 207   gst_collect_pads2_set_event_function (mux->collect,
 208       GST_DEBUG_FUNCPTR (gst_flv_mux_handle_sink_event), mux);
 209   gst_collect_pads2_set_clip_function (mux->collect,
 210       GST_DEBUG_FUNCPTR (gst_collect_pads2_clip_running_time), mux);
 211
 212   gst_flv_mux_reset (GST_ELEMENT (mux));
 213 }
 214
 215 static void
 216 gst_flv_mux_finalize (GObject * object)
 217 {
 218   GstFlvMux *mux = GST_FLV_MUX (object);
 219
 220   gst_object_unref (mux->collect);
 221
 222   G_OBJECT_CLASS (parent_class)->finalize (object);
 223 }
 224
 225 static void
 226 gst_flv_mux_reset (GstElement * element)
 227 {
 228   GstFlvMux *mux = GST_FLV_MUX (element);
 229   GSList *sl;
 230
 231   for (sl = mux->collect->data; sl != NULL; sl = g_slist_next (sl)) {
 232     GstFlvPad *cpad = (GstFlvPad *) sl->data;
 233
 234     gst_flv_mux_reset_pad (mux, cpad, cpad->video);
 235   }
 236
 237   g_list_foreach (mux->index, (GFunc) gst_flv_mux_index_entry_free, NULL);
 238   g_list_free (mux->index);
 239   mux->index = NULL;
 240   mux->byte_count = 0;
 241
 242   mux->have_audio = mux->have_video = FALSE;
 243   mux->duration = GST_CLOCK_TIME_NONE;
 244   mux->new_tags = FALSE;
 245
 246   mux->state = GST_FLV_MUX_STATE_HEADER;
 247
 248   /* tags */
 249   gst_tag_setter_reset_tags (GST_TAG_SETTER (mux));
 250 }
 251
 252 static gboolean
 253 gst_flv_mux_handle_src_event (GstPad * pad, GstEvent * event)
 254 {
 255   GstEventType type;
 256
 257   type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
 258
 259   switch (type) {
 260     case GST_EVENT_SEEK:
 261       /* disable seeking for now */
 262       return FALSE;
 263     default:
 264       break;
 265   }
 266
 267   return gst_pad_event_default (pad, event);
 268 }
 269
 270 static gboolean
 271 gst_flv_mux_handle_sink_event (GstCollectPads2 * pads, GstCollectData2 * data,
 272     GstEvent * event, gpointer user_data)
 273 {
 274   GstFlvMux *mux = GST_FLV_MUX (user_data);
 275
 276   switch (GST_EVENT_TYPE (event)) {
 277     case GST_EVENT_TAG:{
 278       GstTagList *list;
 279       GstTagSetter *setter = GST_TAG_SETTER (mux);
 280       const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter);
 281
 282       gst_event_parse_tag (event, &list);
 283       gst_tag_setter_merge_tags (setter, list, mode);
 284       mux->new_tags = TRUE;
 285       break;
 286     }
 287     default:
 288       break;
 289   }
 290
 291   /* now GstCollectPads2 can take care of the rest, e.g. EOS */
 292   return FALSE;
 293 }
 294
 295 static gboolean
 296 gst_flv_mux_video_pad_setcaps (GstPad * pad, GstCaps * caps)
 297 {
 298   GstFlvMux *mux = GST_FLV_MUX (gst_pad_get_parent (pad));
 299   GstFlvPad *cpad = (GstFlvPad *) gst_pad_get_element_private (pad);
 300   gboolean ret = TRUE;
 301   GstStructure *s;
 302
 303   s = gst_caps_get_structure (caps, 0);
 304
 305   if (strcmp (gst_structure_get_name (s), "video/x-flash-video") == 0) {
 306     cpad->video_codec = 2;
 307   } else if (strcmp (gst_structure_get_name (s), "video/x-flash-screen") == 0) {
 308     cpad->video_codec = 3;
 309   } else if (strcmp (gst_structure_get_name (s), "video/x-vp6-flash") == 0) {
 310     cpad->video_codec = 4;
 311   } else if (strcmp (gst_structure_get_name (s), "video/x-vp6-alpha") == 0) {
 312     cpad->video_codec = 5;
 313   } else if (strcmp (gst_structure_get_name (s), "video/x-h264") == 0) {
 314     cpad->video_codec = 7;
 315   } else {
 316     ret = FALSE;
 317   }
 318
 319   if (ret && gst_structure_has_field (s, "codec_data")) {
 320     const GValue *val = gst_structure_get_value (s, "codec_data");
 321
 322     if (val)
 323       cpad->video_codec_data = gst_buffer_ref (gst_value_get_buffer (val));
 324   }
 325
 326   gst_object_unref (mux);
 327
 328   return ret;
 329 }
 330
 331 static gboolean
 332 gst_flv_mux_audio_pad_setcaps (GstPad * pad, GstCaps * caps)
 333 {
 334   GstFlvMux *mux = GST_FLV_MUX (gst_pad_get_parent (pad));
 335   GstFlvPad *cpad = (GstFlvPad *) gst_pad_get_element_private (pad);
 336   gboolean ret = TRUE;
 337   GstStructure *s;
 338
 339   s = gst_caps_get_structure (caps, 0);
 340
 341   if (strcmp (gst_structure_get_name (s), "audio/x-adpcm") == 0) {
 342     const gchar *layout = gst_structure_get_string (s, "layout");
 343     if (layout && strcmp (layout, "swf") == 0) {
 344       cpad->audio_codec = 1;
 345     } else {
 346       ret = FALSE;
 347     }
 348   } else if (strcmp (gst_structure_get_name (s), "audio/mpeg") == 0) {
 349     gint mpegversion;
 350
 351     if (gst_structure_get_int (s, "mpegversion", &mpegversion)) {
 352       if (mpegversion == 1) {
 353         gint layer;
 354
 355         if (gst_structure_get_int (s, "layer", &layer) && layer == 3) {
 356           gint rate;
 357
 358           if (gst_structure_get_int (s, "rate", &rate) && rate == 8000)
 359             cpad->audio_codec = 14;
 360           else
 361             cpad->audio_codec = 2;
 362         } else {
 363           ret = FALSE;
 364         }
 365       } else if (mpegversion == 4 || mpegversion == 2) {
 366         cpad->audio_codec = 10;
 367       } else {
 368         ret = FALSE;
 369       }
 370     } else {
 371       ret = FALSE;
 372     }
 373   } else if (strcmp (gst_structure_get_name (s), "audio/x-nellymoser") == 0) {
 374     gint rate, channels;
 375
 376     if (gst_structure_get_int (s, "rate", &rate)
 377         && gst_structure_get_int (s, "channels", &channels)) {
 378       if (channels == 1 && rate == 16000)
 379         cpad->audio_codec = 4;
 380       else if (channels == 1 && rate == 8000)
 381         cpad->audio_codec = 5;
 382       else
 383         cpad->audio_codec = 6;
 384     } else {
 385       cpad->audio_codec = 6;
 386     }
 387   } else if (strcmp (gst_structure_get_name (s), "audio/x-raw-int") == 0) {
 388     gint endianness;
 389
 390     if (gst_structure_get_int (s, "endianness", &endianness)
 391         && endianness == G_LITTLE_ENDIAN)
 392       cpad->audio_codec = 3;
 393     else
 394       ret = FALSE;
 395   } else if (strcmp (gst_structure_get_name (s), "audio/x-alaw") == 0) {
 396     cpad->audio_codec = 7;
 397   } else if (strcmp (gst_structure_get_name (s), "audio/x-mulaw") == 0) {
 398     cpad->audio_codec = 8;
 399   } else if (strcmp (gst_structure_get_name (s), "audio/x-speex") == 0) {
 400     cpad->audio_codec = 11;
 401   } else {
 402     ret = FALSE;
 403   }
 404
 405   if (ret) {
 406     gint rate, channels, width;
 407
 408     if (gst_structure_get_int (s, "rate", &rate)) {
 409       if (cpad->audio_codec == 10)
 410         cpad->rate = 3;
 411       else if (rate == 5512)
 412         cpad->rate = 0;
 413       else if (rate == 11025)
 414         cpad->rate = 1;
 415       else if (rate == 22050)
 416         cpad->rate = 2;
 417       else if (rate == 44100)
 418         cpad->rate = 3;
 419       else if (rate == 8000 && (cpad->audio_codec == 5
 420               || cpad->audio_codec == 14))
 421         cpad->rate = 0;
 422       else if (rate == 16000 && cpad->audio_codec == 4)
 423         cpad->rate = 0;
 424       else
 425         ret = FALSE;
 426     } else if (cpad->audio_codec == 10) {
 427       cpad->rate = 3;
 428     } else {
 429       ret = FALSE;
 430     }
 431
 432     if (gst_structure_get_int (s, "channels", &channels)) {
 433       if (cpad->audio_codec == 4 || cpad->audio_codec == 5
 434           || cpad->audio_codec == 6)
 435         cpad->channels = 0;
 436       else if (cpad->audio_codec == 10)
 437         cpad->channels = 1;
 438       else if (channels == 1)
 439         cpad->channels = 0;
 440       else if (channels == 2)
 441         cpad->channels = 1;
 442       else
 443         ret = FALSE;
 444     } else if (cpad->audio_codec == 4 || cpad->audio_codec == 5
 445         || cpad->audio_codec == 6) {
 446       cpad->channels = 0;
 447     } else if (cpad->audio_codec == 10) {
 448       cpad->channels = 1;
 449     } else {
 450       ret = FALSE;
 451     }
 452
 453     if (gst_structure_get_int (s, "width", &width)) {
 454       if (cpad->audio_codec != 3)
 455         cpad->width = 1;
 456       else if (width == 8)
 457         cpad->width = 0;
 458       else if (width == 16)
 459         cpad->width = 1;
 460       else
 461         ret = FALSE;
 462     } else if (cpad->audio_codec != 3) {
 463       cpad->width = 1;
 464     } else {
 465       ret = FALSE;
 466     }
 467   }
 468
 469   if (ret && gst_structure_has_field (s, "codec_data")) {
 470     const GValue *val = gst_structure_get_value (s, "codec_data");
 471
 472     if (val)
 473       cpad->audio_codec_data = gst_buffer_ref (gst_value_get_buffer (val));
 474   }
 475
 476   gst_object_unref (mux);
 477
 478   return ret;
 479 }
 480
 481 static void
 482 gst_flv_mux_reset_pad (GstFlvMux * mux, GstFlvPad * cpad, gboolean video)
 483 {
 484   cpad->video = video;
 485
 486   if (cpad->audio_codec_data)
 487     gst_buffer_unref (cpad->audio_codec_data);
 488   cpad->audio_codec_data = NULL;
 489   cpad->audio_codec = G_MAXUINT;
 490   cpad->rate = G_MAXUINT;
 491   cpad->width = G_MAXUINT;
 492   cpad->channels = G_MAXUINT;
 493
 494   if (cpad->video_codec_data)
 495     gst_buffer_unref (cpad->video_codec_data);
 496   cpad->video_codec_data = NULL;
 497   cpad->video_codec = G_MAXUINT;
 498   cpad->last_timestamp = 0;
 499 }
 500
 501 static GstPad *
 502 gst_flv_mux_request_new_pad (GstElement * element,
 503     GstPadTemplate * templ, const gchar * pad_name)
 504 {
 505   GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);
 506   GstFlvMux *mux = GST_FLV_MUX (element);
 507   GstFlvPad *cpad;
 508   GstPad *pad = NULL;
 509   const gchar *name = NULL;
 510   GstPadSetCapsFunction setcapsfunc = NULL;
 511   gboolean video;
 512
 513   if (mux->state != GST_FLV_MUX_STATE_HEADER) {
 514     GST_WARNING_OBJECT (mux, "Can't request pads after writing header");
 515     return NULL;
 516   }
 517
 518   if (templ == gst_element_class_get_pad_template (klass, "audio")) {
 519     if (mux->have_audio) {
 520       GST_WARNING_OBJECT (mux, "Already have an audio pad");
 521       return NULL;
 522     }
 523     mux->have_audio = TRUE;
 524     name = "audio";
 525     video = FALSE;
 526     setcapsfunc = GST_DEBUG_FUNCPTR (gst_flv_mux_audio_pad_setcaps);
 527   } else if (templ == gst_element_class_get_pad_template (klass, "video")) {
 528     if (mux->have_video) {
 529       GST_WARNING_OBJECT (mux, "Already have a video pad");
 530       return NULL;
 531     }
 532     mux->have_video = TRUE;
 533     name = "video";
 534     video = TRUE;
 535     setcapsfunc = GST_DEBUG_FUNCPTR (gst_flv_mux_video_pad_setcaps);
 536   } else {
 537     GST_WARNING_OBJECT (mux, "Invalid template");
 538     return NULL;
 539   }
 540
 541   pad = gst_pad_new_from_template (templ, name);
 542   cpad = (GstFlvPad *)
 543       gst_collect_pads2_add_pad (mux->collect, pad, sizeof (GstFlvPad));
 544
 545   cpad->audio_codec_data = NULL;
 546   cpad->video_codec_data = NULL;
 547   gst_flv_mux_reset_pad (mux, cpad, video);
 548
 549   gst_pad_set_setcaps_function (pad, setcapsfunc);
 550   gst_pad_set_active (pad, TRUE);
 551   gst_element_add_pad (element, pad);
 552
 553   return pad;
 554 }
 555
 556 static void
 557 gst_flv_mux_release_pad (GstElement * element, GstPad * pad)
 558 {
 559   GstFlvMux *mux = GST_FLV_MUX (GST_PAD_PARENT (pad));
 560   GstFlvPad *cpad = (GstFlvPad *) gst_pad_get_element_private (pad);
 561
 562   gst_flv_mux_reset_pad (mux, cpad, cpad->video);
 563   gst_collect_pads2_remove_pad (mux->collect, pad);
 564   gst_element_remove_pad (element, pad);
 565 }
 566
 567 static GstFlowReturn
 568 gst_flv_mux_push (GstFlvMux * mux, GstBuffer * buffer)
 569 {
 570   gst_buffer_set_caps (buffer, GST_PAD_CAPS (mux->srcpad));
 571   /* pushing the buffer that rewrites the header will make it no longer be the
 572    * total output size in bytes, but it doesn't matter at that point */
 573   mux->byte_count += GST_BUFFER_SIZE (buffer);
 574
 575   return gst_pad_push (mux->srcpad, buffer);
 576 }
 577
 578 static GstBuffer *
 579 gst_flv_mux_create_header (GstFlvMux * mux)
 580 {
 581   GstBuffer *header;
 582   guint8 *data;
 583
 584   header = gst_buffer_new_and_alloc (9 + 4);
 585   data = GST_BUFFER_DATA (header);
 586
 587   data[0] = 'F';
 588   data[1] = 'L';
 589   data[2] = 'V';
 590   data[3] = 0x01;               /* Version */
 591
 592   data[4] = (mux->have_audio << 2) | mux->have_video;   /* flags */
 593   GST_WRITE_UINT32_BE (data + 5, 9);    /* data offset */
 594   GST_WRITE_UINT32_BE (data + 9, 0);    /* previous tag size */
 595
 596   return header;
 597 }
 598
 599 static GstBuffer *
 600 gst_flv_mux_preallocate_index (GstFlvMux * mux)
 601 {
 602   GstBuffer *tmp;
 603   guint8 *data;
 604   gint preallocate_size;
 605
 606   /* preallocate index of size:
 607    *  - 'keyframes' ECMA array key: 2 + 9 = 11 bytes
 608    *  - nested ECMA array header, length and end marker: 8 bytes
 609    *  - 'times' and 'filepositions' keys: 22 bytes
 610    *  - two strict arrays headers and lengths: 10 bytes
 611    *  - each index entry: 18 bytes
 612    */
 613   preallocate_size = 11 + 8 + 22 + 10 + MAX_INDEX_ENTRIES * 18;
 614   GST_DEBUG_OBJECT (mux, "preallocating %d bytes for the index",
 615       preallocate_size);
 616
 617   tmp = gst_buffer_new_and_alloc (preallocate_size);
 618   data = GST_BUFFER_DATA (tmp);
 619
 620   /* prefill the space with a gstfiller: <spaces> script tag variable */
 621   GST_WRITE_UINT16_BE (data, 9);        /* 9 characters */
 622   memcpy (data + 2, "gstfiller", 9);
 623   GST_WRITE_UINT8 (data + 11, AMF0_STRING_MARKER);      /* a string value */
 624   GST_WRITE_UINT16_BE (data + 12, preallocate_size - 14);
 625   memset (data + 14, ' ', preallocate_size - 14);       /* the rest is spaces */
 626   return tmp;
 627 }
 628
 629 static GstBuffer *
 630 gst_flv_mux_create_number_script_value (const gchar * name, gdouble value)
 631 {
 632   GstBuffer *tmp = gst_buffer_new_and_alloc (2 + strlen (name) + 1 + 8);
 633   guint8 *data = GST_BUFFER_DATA (tmp);
 634   gsize len = strlen (name);
 635
 636   GST_WRITE_UINT16_BE (data, len);
 637   data += 2;                    /* name length */
 638   memcpy (data, name, len);
 639   data += len;
 640   *data++ = AMF0_NUMBER_MARKER; /* double type */
 641   GST_WRITE_DOUBLE_BE (data, value);
 642
 643   return tmp;
 644 }
 645
 646 static GstBuffer *
 647 gst_flv_mux_create_metadata (GstFlvMux * mux, gboolean full)
 648 {
 649   const GstTagList *tags;
 650   GstBuffer *script_tag, *tmp;
 651   guint8 *data;
 652   gint i, n_tags, tags_written = 0;
 653
 654   tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (mux));
 655
 656   GST_DEBUG_OBJECT (mux, "tags = %" GST_PTR_FORMAT, tags);
 657
 658   script_tag = gst_buffer_new_and_alloc (11);
 659   data = GST_BUFFER_DATA (script_tag);
 660
 661   data[0] = 18;
 662
 663   /* Data size, unknown for now */
 664   data[1] = 0;
 665   data[2] = 0;
 666   data[3] = 0;
 667
 668   /* Timestamp */
 669   data[4] = data[5] = data[6] = data[7] = 0;
 670
 671   /* Stream ID */
 672   data[8] = data[9] = data[10] = 0;
 673
 674   tmp = gst_buffer_new_and_alloc (13);
 675   data = GST_BUFFER_DATA (tmp);
 676   data[0] = AMF0_STRING_MARKER; /* string */
 677   data[1] = 0;
 678   data[2] = 10;                 /* length 10 */
 679   memcpy (&data[3], "onMetaData", 10);
 680
 681   script_tag = gst_buffer_join (script_tag, tmp);
 682
 683   n_tags = (tags) ? gst_structure_n_fields ((GstStructure *) tags) : 0;
 684   tmp = gst_buffer_new_and_alloc (5);
 685   data = GST_BUFFER_DATA (tmp);
 686   data[0] = 8;                  /* ECMA array */
 687   GST_WRITE_UINT32_BE (data + 1, n_tags);
 688   script_tag = gst_buffer_join (script_tag, tmp);
 689
 690   if (!full)
 691     goto tags;
 692
 693   /* Some players expect the 'duration' to be always set. Fill it out later,
 694      after querying the pads or after getting EOS */
 695   if (!mux->streamable) {
 696     tmp = gst_flv_mux_create_number_script_value ("duration", 86400);
 697     script_tag = gst_buffer_join (script_tag, tmp);
 698     tags_written++;
 699
 700     /* Sometimes the information about the total file size is useful for the
 701        player. It will be filled later, after getting EOS */
 702     tmp = gst_flv_mux_create_number_script_value ("filesize", 0);
 703     script_tag = gst_buffer_join (script_tag, tmp);
 704     tags_written++;
 705
 706     /* Preallocate space for the index to be written at EOS */
 707     tmp = gst_flv_mux_preallocate_index (mux);
 708     script_tag = gst_buffer_join (script_tag, tmp);
 709   } else {
 710     GST_DEBUG_OBJECT (mux, "not preallocating index, streamable mode");
 711   }
 712
 713 tags:
 714   for (i = 0; tags && i < n_tags; i++) {
 715     const gchar *tag_name =
 716         gst_structure_nth_field_name ((const GstStructure *) tags, i);
 717     if (!strcmp (tag_name, GST_TAG_DURATION)) {
 718       guint64 dur;
 719
 720       if (!gst_tag_list_get_uint64 (tags, GST_TAG_DURATION, &dur))
 721         continue;
 722       mux->duration = dur;
 723     } else if (!strcmp (tag_name, GST_TAG_ARTIST) ||
 724         !strcmp (tag_name, GST_TAG_TITLE)) {
 725       gchar *s;
 726       const gchar *t = NULL;
 727
 728       if (!strcmp (tag_name, GST_TAG_ARTIST))
 729         t = "creator";
 730       else if (!strcmp (tag_name, GST_TAG_TITLE))
 731         t = "title";
 732
 733       if (!gst_tag_list_get_string (tags, tag_name, &s))
 734         continue;
 735
 736       tmp = gst_buffer_new_and_alloc (2 + strlen (t) + 1 + 2 + strlen (s));
 737       data = GST_BUFFER_DATA (tmp);
 738       data[0] = 0;              /* tag name length */
 739       data[1] = strlen (t);
 740       memcpy (&data[2], t, strlen (t));
 741       data[2 + strlen (t)] = 2; /* string */
 742       data[3 + strlen (t)] = (strlen (s) >> 8) & 0xff;
 743       data[4 + strlen (t)] = (strlen (s)) & 0xff;
 744       memcpy (&data[5 + strlen (t)], s, strlen (s));
 745       script_tag = gst_buffer_join (script_tag, tmp);
 746
 747       g_free (s);
 748       tags_written++;
 749     }
 750   }
 751
 752   if (!full)
 753     goto end;
 754
 755   if (mux->duration == GST_CLOCK_TIME_NONE) {
 756     GSList *l;
 757
 758     GstFormat fmt = GST_FORMAT_TIME;
 759     guint64 dur;
 760
 761     for (l = mux->collect->data; l; l = l->next) {
 762       GstCollectData2 *cdata = l->data;
 763
 764       fmt = GST_FORMAT_TIME;
 765
 766       if (gst_pad_query_peer_duration (cdata->pad, &fmt, (gint64 *) & dur) &&
 767           fmt == GST_FORMAT_TIME && dur != GST_CLOCK_TIME_NONE) {
 768         if (mux->duration == GST_CLOCK_TIME_NONE)
 769           mux->duration = dur;
 770         else
 771           mux->duration = MAX (dur, mux->duration);
 772       }
 773     }
 774   }
 775
 776   if (!mux->streamable && mux->duration != GST_CLOCK_TIME_NONE) {
 777     gdouble d;
 778     d = gst_guint64_to_gdouble (mux->duration);
 779     d /= (gdouble) GST_SECOND;
 780
 781     GST_DEBUG_OBJECT (mux, "determined the duration to be %f", d);
 782     data = GST_BUFFER_DATA (script_tag);
 783     GST_WRITE_DOUBLE_BE (data + 29 + 2 + 8 + 1, d);
 784   }
 785
 786   if (mux->have_video) {
 787     GstPad *video_pad = NULL;
 788     GstFlvPad *cpad;
 789     GSList *l = mux->collect->data;
 790
 791     for (; l; l = l->next) {
 792       cpad = l->data;
 793       if (cpad && cpad->video) {
 794         video_pad = cpad->collect.pad;
 795         break;
 796       }
 797     }
 798
 799     if (video_pad && GST_PAD_CAPS (video_pad)) {
 800       GstStructure *s = gst_caps_get_structure (GST_PAD_CAPS (video_pad), 0);
 801       gint size;
 802       gint num, den;
 803
 804       GST_DEBUG_OBJECT (mux, "putting videocodecid %d in the metadata",
 805           cpad->video_codec);
 806
 807       tmp = gst_flv_mux_create_number_script_value ("videocodecid",
 808           cpad->video_codec);
 809       script_tag = gst_buffer_join (script_tag, tmp);
 810       tags_written++;
 811
 812       if (gst_structure_get_int (s, "width", &size)) {
 813         GST_DEBUG_OBJECT (mux, "putting width %d in the metadata", size);
 814
 815         tmp = gst_flv_mux_create_number_script_value ("width", size);
 816         script_tag = gst_buffer_join (script_tag, tmp);
 817         tags_written++;
 818       }
 819
 820       if (gst_structure_get_int (s, "height", &size)) {
 821         GST_DEBUG_OBJECT (mux, "putting height %d in the metadata", size);
 822
 823         tmp = gst_flv_mux_create_number_script_value ("height", size);
 824         script_tag = gst_buffer_join (script_tag, tmp);
 825         tags_written++;
 826       }
 827
 828       if (gst_structure_get_fraction (s, "pixel-aspect-ratio", &num, &den)) {
 829         gdouble d;
 830
 831         d = num;
 832         GST_DEBUG_OBJECT (mux, "putting AspectRatioX %f in the metadata", d);
 833
 834         tmp = gst_flv_mux_create_number_script_value ("AspectRatioX", d);
 835         script_tag = gst_buffer_join (script_tag, tmp);
 836         tags_written++;
 837
 838         d = den;
 839         GST_DEBUG_OBJECT (mux, "putting AspectRatioY %f in the metadata", d);
 840
 841         tmp = gst_flv_mux_create_number_script_value ("AspectRatioY", d);
 842         script_tag = gst_buffer_join (script_tag, tmp);
 843         tags_written++;
 844       }
 845
 846       if (gst_structure_get_fraction (s, "framerate", &num, &den)) {
 847         gdouble d;
 848
 849         gst_util_fraction_to_double (num, den, &d);
 850         GST_DEBUG_OBJECT (mux, "putting framerate %f in the metadata", d);
 851
 852         tmp = gst_flv_mux_create_number_script_value ("framerate", d);
 853         script_tag = gst_buffer_join (script_tag, tmp);
 854         tags_written++;
 855       }
 856     }
 857   }
 858
 859   if (mux->have_audio) {
 860     GstPad *audio_pad = NULL;
 861     GstFlvPad *cpad;
 862     GSList *l = mux->collect->data;
 863
 864     for (; l; l = l->next) {
 865       cpad = l->data;
 866       if (cpad && !cpad->video) {
 867         audio_pad = cpad->collect.pad;
 868         break;
 869       }
 870     }
 871
 872     if (audio_pad) {
 873       GST_DEBUG_OBJECT (mux, "putting audiocodecid %d in the metadata",
 874           cpad->audio_codec);
 875
 876       tmp = gst_flv_mux_create_number_script_value ("audiocodecid",
 877           cpad->audio_codec);
 878       script_tag = gst_buffer_join (script_tag, tmp);
 879       tags_written++;
 880     }
 881   }
 882
 883   {
 884     const gchar *s = "GStreamer FLV muxer";
 885
 886     tmp = gst_buffer_new_and_alloc (2 + 15 + 1 + 2 + strlen (s));
 887     data = GST_BUFFER_DATA (tmp);
 888     data[0] = 0;                /* 15 bytes name */
 889     data[1] = 15;
 890     memcpy (&data[2], "metadatacreator", 15);
 891     data[17] = 2;               /* string */
 892     data[18] = (strlen (s) >> 8) & 0xff;
 893     data[19] = (strlen (s)) & 0xff;
 894     memcpy (&data[20], s, strlen (s));
 895     script_tag = gst_buffer_join (script_tag, tmp);
 896
 897     tags_written++;
 898   }
 899
 900   {
 901     GTimeVal tv = { 0, };
 902     time_t secs;
 903     struct tm *tm;
 904     gchar *s;
 905     static const gchar *weekdays[] = {
 906       "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
 907     };
 908     static const gchar *months[] = {
 909       "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
 910       "Aug", "Sep", "Oct", "Nov", "Dec"
 911     };
 912
 913     g_get_current_time (&tv);
 914     secs = tv.tv_sec;
 915     tm = gmtime (&secs);
 916
 917     s = g_strdup_printf ("%s %s %d %d:%d:%d %d", weekdays[tm->tm_wday],
 918         months[tm->tm_mon], tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
 919         tm->tm_year + 1900);
 920
 921     tmp = gst_buffer_new_and_alloc (2 + 12 + 1 + 2 + strlen (s));
 922     data = GST_BUFFER_DATA (tmp);
 923     data[0] = 0;                /* 12 bytes name */
 924     data[1] = 12;
 925     memcpy (&data[2], "creationdate", 12);
 926     data[14] = 2;               /* string */
 927     data[15] = (strlen (s) >> 8) & 0xff;
 928     data[16] = (strlen (s)) & 0xff;
 929     memcpy (&data[17], s, strlen (s));
 930     script_tag = gst_buffer_join (script_tag, tmp);
 931
 932     g_free (s);
 933     tags_written++;
 934   }
 935
 936 end:
 937
 938   if (!tags_written) {
 939     gst_buffer_unref (script_tag);
 940     goto exit;
 941   }
 942
 943   tmp = gst_buffer_new_and_alloc (2 + 0 + 1);
 944   data = GST_BUFFER_DATA (tmp);
 945   data[0] = 0;                  /* 0 byte size */
 946   data[1] = 0;
 947   data[2] = 9;                  /* end marker */
 948   script_tag = gst_buffer_join (script_tag, tmp);
 949   tags_written++;
 950
 951   tmp = gst_buffer_new_and_alloc (4);
 952   data = GST_BUFFER_DATA (tmp);
 953   GST_WRITE_UINT32_BE (data, GST_BUFFER_SIZE (script_tag));
 954   script_tag = gst_buffer_join (script_tag, tmp);
 955
 956   data = GST_BUFFER_DATA (script_tag);
 957   data[1] = ((GST_BUFFER_SIZE (script_tag) - 11 - 4) >> 16) & 0xff;
 958   data[2] = ((GST_BUFFER_SIZE (script_tag) - 11 - 4) >> 8) & 0xff;
 959   data[3] = ((GST_BUFFER_SIZE (script_tag) - 11 - 4) >> 0) & 0xff;
 960
 961   GST_WRITE_UINT32_BE (data + 11 + 13 + 1, tags_written);
 962
 963 exit:
 964   return script_tag;
 965 }
 966
 967 static GstBuffer *
 968 gst_flv_mux_buffer_to_tag_internal (GstFlvMux * mux, GstBuffer * buffer,
 969     GstFlvPad * cpad, gboolean is_codec_data)
 970 {
 971   GstBuffer *tag;
 972   guint8 *data;
 973   guint size;
 974   guint32 timestamp =
 975       (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) ? GST_BUFFER_TIMESTAMP (buffer) /
 976       GST_MSECOND : cpad->last_timestamp / GST_MSECOND;
 977
 978   size = 11;
 979   if (cpad->video) {
 980     size += 1;
 981     if (cpad->video_codec == 7)
 982       size += 4 + GST_BUFFER_SIZE (buffer);
 983     else
 984       size += GST_BUFFER_SIZE (buffer);
 985   } else {
 986     size += 1;
 987     if (cpad->audio_codec == 10)
 988       size += 1 + GST_BUFFER_SIZE (buffer);
 989     else
 990       size += GST_BUFFER_SIZE (buffer);
 991   }
 992   size += 4;
 993
 994   tag = gst_buffer_new_and_alloc (size);
 995   GST_BUFFER_TIMESTAMP (tag) = timestamp * GST_MSECOND;
 996   data = GST_BUFFER_DATA (tag);
 997   memset (data, 0, size);
 998
 999   data[0] = (cpad->video) ? 9 : 8;
1000
1001   data[1] = ((size - 11 - 4) >> 16) & 0xff;
1002   data[2] = ((size - 11 - 4) >> 8) & 0xff;
1003   data[3] = ((size - 11 - 4) >> 0) & 0xff;
1004
1005   /* wrap the timestamp every G_MAXINT32 miliseconds */
1006   timestamp &= 0x7fffffff;
1007   data[4] = (timestamp >> 16) & 0xff;
1008   data[5] = (timestamp >> 8) & 0xff;
1009   data[6] = (timestamp >> 0) & 0xff;
1010   data[7] = (timestamp >> 24) & 0xff;
1011
1012   data[8] = data[9] = data[10] = 0;
1013
1014   if (cpad->video) {
1015     if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1016       data[11] |= 2 << 4;
1017     else
1018       data[11] |= 1 << 4;
1019
1020     data[11] |= cpad->video_codec & 0x0f;
1021
1022     if (cpad->video_codec == 7) {
1023       data[12] = is_codec_data ? 0 : 1;
1024
1025       /* FIXME: what to do about composition time */
1026       data[13] = data[14] = data[15] = 0;
1027
1028       memcpy (data + 11 + 1 + 4, GST_BUFFER_DATA (buffer),
1029           GST_BUFFER_SIZE (buffer));
1030     } else {
1031       memcpy (data + 11 + 1, GST_BUFFER_DATA (buffer),
1032           GST_BUFFER_SIZE (buffer));
1033     }
1034   } else {
1035     data[11] |= (cpad->audio_codec << 4) & 0xf0;
1036     data[11] |= (cpad->rate << 2) & 0x0c;
1037     data[11] |= (cpad->width << 1) & 0x02;
1038     data[11] |= (cpad->channels << 0) & 0x01;
1039
1040     if (cpad->audio_codec == 10) {
1041       data[12] = is_codec_data ? 0 : 1;
1042
1043       memcpy (data + 11 + 1 + 1, GST_BUFFER_DATA (buffer),
1044           GST_BUFFER_SIZE (buffer));
1045     } else {
1046       memcpy (data + 11 + 1, GST_BUFFER_DATA (buffer),
1047           GST_BUFFER_SIZE (buffer));
1048     }
1049   }
1050
1051   GST_WRITE_UINT32_BE (data + size - 4, size - 4);
1052
1053   gst_buffer_copy_metadata (tag, buffer, GST_BUFFER_COPY_TIMESTAMPS);
1054   /* mark the buffer if it's an audio buffer and there's also video being muxed
1055    * or it's a video interframe */
1056   if ((mux->have_video && !cpad->video) ||
1057       GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1058     GST_BUFFER_FLAG_SET (tag, GST_BUFFER_FLAG_DELTA_UNIT);
1059
1060   GST_BUFFER_OFFSET (tag) = GST_BUFFER_OFFSET_END (tag) =
1061       GST_BUFFER_OFFSET_NONE;
1062
1063   return tag;
1064 }
1065
1066 static inline GstBuffer *
1067 gst_flv_mux_buffer_to_tag (GstFlvMux * mux, GstBuffer * buffer,
1068     GstFlvPad * cpad)
1069 {
1070   return gst_flv_mux_buffer_to_tag_internal (mux, buffer, cpad, FALSE);
1071 }
1072
1073 static inline GstBuffer *
1074 gst_flv_mux_codec_data_buffer_to_tag (GstFlvMux * mux, GstBuffer * buffer,
1075     GstFlvPad * cpad)
1076 {
1077   return gst_flv_mux_buffer_to_tag_internal (mux, buffer, cpad, TRUE);
1078 }
1079
1080 static void
1081 gst_flv_mux_put_buffer_in_streamheader (GValue * streamheader,
1082     GstBuffer * buffer)
1083 {
1084   GValue value = { 0 };
1085   GstBuffer *buf;
1086
1087   g_value_init (&value, GST_TYPE_BUFFER);
1088   buf = gst_buffer_copy (buffer);
1089   gst_value_set_buffer (&value, buf);
1090   gst_buffer_unref (buf);
1091   gst_value_array_append_value (streamheader, &value);
1092   g_value_unset (&value);
1093 }
1094
1095 static GstFlowReturn
1096 gst_flv_mux_write_header (GstFlvMux * mux)
1097 {
1098   GstBuffer *header, *metadata;
1099   GstBuffer *video_codec_data, *audio_codec_data;
1100   GstCaps *caps;
1101   GstStructure *structure;
1102   GValue streamheader = { 0 };
1103   GSList *l;
1104   GstFlowReturn ret;
1105
1106   header = gst_flv_mux_create_header (mux);
1107   metadata = gst_flv_mux_create_metadata (mux, TRUE);
1108   video_codec_data = NULL;
1109   audio_codec_data = NULL;
1110
1111   for (l = mux->collect->data; l != NULL; l = l->next) {
1112     GstFlvPad *cpad = l->data;
1113
1114     /* Get H.264 and AAC codec data, if present */
1115     if (cpad && cpad->video && cpad->video_codec == 7) {
1116       if (cpad->video_codec_data == NULL)
1117         GST_WARNING_OBJECT (mux, "Codec data for video stream not found, "
1118             "output might not be playable");
1119       else
1120         video_codec_data =
1121             gst_flv_mux_codec_data_buffer_to_tag (mux, cpad->video_codec_data,
1122             cpad);
1123     } else if (cpad && !cpad->video && cpad->audio_codec == 10) {
1124       if (cpad->audio_codec_data == NULL)
1125         GST_WARNING_OBJECT (mux, "Codec data for audio stream not found, "
1126             "output might not be playable");
1127       else
1128         audio_codec_data =
1129             gst_flv_mux_codec_data_buffer_to_tag (mux, cpad->audio_codec_data,
1130             cpad);
1131     }
1132   }
1133
1134   /* mark buffers that will go in the streamheader */
1135   GST_BUFFER_FLAG_SET (header, GST_BUFFER_FLAG_IN_CAPS);
1136   GST_BUFFER_FLAG_SET (metadata, GST_BUFFER_FLAG_IN_CAPS);
1137   if (video_codec_data != NULL) {
1138     GST_BUFFER_FLAG_SET (video_codec_data, GST_BUFFER_FLAG_IN_CAPS);
1139     /* mark as a delta unit, so downstream will not try to synchronize on that
1140      * buffer - to actually start playback you need a real video keyframe */
1141     GST_BUFFER_FLAG_SET (video_codec_data, GST_BUFFER_FLAG_DELTA_UNIT);
1142   }
1143   if (audio_codec_data != NULL) {
1144     GST_BUFFER_FLAG_SET (audio_codec_data, GST_BUFFER_FLAG_IN_CAPS);
1145   }
1146
1147   /* put buffers in streamheader */
1148   g_value_init (&streamheader, GST_TYPE_ARRAY);
1149   gst_flv_mux_put_buffer_in_streamheader (&streamheader, header);
1150   gst_flv_mux_put_buffer_in_streamheader (&streamheader, metadata);
1151   if (video_codec_data != NULL)
1152     gst_flv_mux_put_buffer_in_streamheader (&streamheader, video_codec_data);
1153   if (audio_codec_data != NULL)
1154     gst_flv_mux_put_buffer_in_streamheader (&streamheader, audio_codec_data);
1155
1156   /* create the caps and put the streamheader in them */
1157   caps = gst_caps_new_simple ("video/x-flv", NULL);
1158   caps = gst_caps_make_writable (caps);
1159   structure = gst_caps_get_structure (caps, 0);
1160   gst_structure_set_value (structure, "streamheader", &streamheader);
1161   g_value_unset (&streamheader);
1162
1163   if (GST_PAD_CAPS (mux->srcpad) == NULL)
1164     gst_pad_set_caps (mux->srcpad, caps);
1165
1166   gst_caps_unref (caps);
1167
1168   /* push the header buffer, the metadata and the codec info, if any */
1169   ret = gst_flv_mux_push (mux, header);
1170   if (ret != GST_FLOW_OK)
1171     return ret;
1172   ret = gst_flv_mux_push (mux, metadata);
1173   if (ret != GST_FLOW_OK)
1174     return ret;
1175   if (video_codec_data != NULL) {
1176     ret = gst_flv_mux_push (mux, video_codec_data);
1177     if (ret != GST_FLOW_OK)
1178       return ret;
1179   }
1180   if (audio_codec_data != NULL) {
1181     ret = gst_flv_mux_push (mux, audio_codec_data);
1182     if (ret != GST_FLOW_OK)
1183       return ret;
1184   }
1185   return GST_FLOW_OK;
1186 }
1187
1188 static void
1189 gst_flv_mux_update_index (GstFlvMux * mux, GstBuffer * buffer, GstFlvPad * cpad)
1190 {
1191   /*
1192    * Add the tag byte offset and to the index if it's a valid seek point, which
1193    * means it's either a video keyframe or if there is no video pad (in that
1194    * case every FLV tag is a valid seek point)
1195    */
1196   if (mux->have_video &&
1197       (!cpad->video ||
1198           GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT)))
1199     return;
1200
1201   if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {
1202     GstFlvMuxIndexEntry *entry = g_slice_new (GstFlvMuxIndexEntry);
1203     entry->position = mux->byte_count;
1204     entry->time =
1205         gst_guint64_to_gdouble (GST_BUFFER_TIMESTAMP (buffer)) / GST_SECOND;
1206     mux->index = g_list_prepend (mux->index, entry);
1207   }
1208 }
1209
1210 static GstFlowReturn
1211 gst_flv_mux_write_buffer (GstFlvMux * mux, GstFlvPad * cpad, GstBuffer * buffer)
1212 {
1213   GstBuffer *tag;
1214   GstFlowReturn ret;
1215
1216   /* clipping function arranged for running_time */
1217
1218   if (!mux->streamable)
1219     gst_flv_mux_update_index (mux, buffer, cpad);
1220
1221   tag = gst_flv_mux_buffer_to_tag (mux, buffer, cpad);
1222
1223   gst_buffer_unref (buffer);
1224
1225   ret = gst_flv_mux_push (mux, tag);
1226
1227   if (ret == GST_FLOW_OK && GST_BUFFER_TIMESTAMP_IS_VALID (tag))
1228     cpad->last_timestamp = GST_BUFFER_TIMESTAMP (tag);
1229
1230   return ret;
1231 }
1232
1233 static guint64
1234 gst_flv_mux_determine_duration (GstFlvMux * mux)
1235 {
1236   GSList *l;
1237   GstClockTime duration = GST_CLOCK_TIME_NONE;
1238
1239   GST_DEBUG_OBJECT (mux, "trying to determine the duration "
1240       "from pad timestamps");
1241
1242   for (l = mux->collect->data; l != NULL; l = l->next) {
1243     GstFlvPad *cpad = l->data;
1244
1245     if (cpad && (cpad->last_timestamp != GST_CLOCK_TIME_NONE)) {
1246       if (duration == GST_CLOCK_TIME_NONE)
1247         duration = cpad->last_timestamp;
1248       else
1249         duration = MAX (duration, cpad->last_timestamp);
1250     }
1251   }
1252
1253   return duration;
1254 }
1255
1256 static GstFlowReturn
1257 gst_flv_mux_rewrite_header (GstFlvMux * mux)
1258 {
1259   GstBuffer *rewrite, *index, *tmp;
1260   GstEvent *event;
1261   guint8 *data;
1262   gdouble d;
1263   GList *l;
1264   guint32 index_len, allocate_size;
1265   guint32 i, index_skip;
1266   GstClockTime dur;
1267
1268   if (mux->streamable)
1269     return GST_FLOW_OK;
1270
1271   /* seek back to the preallocated index space */
1272   event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
1273       13 + 29, GST_CLOCK_TIME_NONE, 13 + 29);
1274   if (!gst_pad_push_event (mux->srcpad, event)) {
1275     GST_WARNING_OBJECT (mux, "Seek to rewrite header failed");
1276     return GST_FLOW_OK;
1277   }
1278
1279   /* determine duration now based on our own timestamping,
1280    * so that it is likely many times better and consistent
1281    * than whatever obtained by some query */
1282   dur = gst_flv_mux_determine_duration (mux);
1283   if (dur != GST_CLOCK_TIME_NONE)
1284     mux->duration = dur;
1285
1286   /* rewrite the duration tag */
1287   d = gst_guint64_to_gdouble (mux->duration);
1288   d /= (gdouble) GST_SECOND;
1289
1290   GST_DEBUG_OBJECT (mux, "determined the final duration to be %f", d);
1291
1292   rewrite = gst_flv_mux_create_number_script_value ("duration", d);
1293
1294   /* rewrite the filesize tag */
1295   d = gst_guint64_to_gdouble (mux->byte_count);
1296
1297   GST_DEBUG_OBJECT (mux, "putting total filesize %f in the metadata", d);
1298
1299   tmp = gst_flv_mux_create_number_script_value ("filesize", d);
1300   rewrite = gst_buffer_join (rewrite, tmp);
1301
1302   if (!mux->index) {
1303     /* no index, so push buffer and return */
1304     return gst_flv_mux_push (mux, rewrite);
1305   }
1306
1307   /* rewrite the index */
1308   mux->index = g_list_reverse (mux->index);
1309   index_len = g_list_length (mux->index);
1310
1311   /* We write at most MAX_INDEX_ENTRIES elements */
1312   if (index_len > MAX_INDEX_ENTRIES) {
1313     index_skip = 1 + index_len / MAX_INDEX_ENTRIES;
1314     index_len = (index_len + index_skip - 1) / index_skip;
1315   } else {
1316     index_skip = 1;
1317   }
1318
1319   GST_DEBUG_OBJECT (mux, "Index length is %d", index_len);
1320   /* see size calculation in gst_flv_mux_preallocate_index */
1321   allocate_size = 11 + 8 + 22 + 10 + index_len * 18;
1322   GST_DEBUG_OBJECT (mux, "Allocating %d bytes for index", allocate_size);
1323   index = gst_buffer_new_and_alloc (allocate_size);
1324   data = GST_BUFFER_DATA (index);
1325
1326   GST_WRITE_UINT16_BE (data, 9);        /* the 'keyframes' key */
1327   memcpy (data + 2, "keyframes", 9);
1328   GST_WRITE_UINT8 (data + 11, 8);       /* nested ECMA array */
1329   GST_WRITE_UINT32_BE (data + 12, 2);   /* two elements */
1330   GST_WRITE_UINT16_BE (data + 16, 5);   /* first string key: 'times' */
1331   memcpy (data + 18, "times", 5);
1332   GST_WRITE_UINT8 (data + 23, 10);      /* strict array */
1333   GST_WRITE_UINT32_BE (data + 24, index_len);
1334   data += 28;
1335
1336   /* the keyframes' times */
1337   for (i = 0, l = mux->index; l; l = l->next, i++) {
1338     GstFlvMuxIndexEntry *entry = l->data;
1339
1340     if (i % index_skip != 0)
1341       continue;
1342     GST_WRITE_UINT8 (data, 0);  /* numeric (aka double) */
1343     GST_WRITE_DOUBLE_BE (data + 1, entry->time);
1344     data += 9;
1345   }
1346
1347   GST_WRITE_UINT16_BE (data, 13);       /* second string key: 'filepositions' */
1348   memcpy (data + 2, "filepositions", 13);
1349   GST_WRITE_UINT8 (data + 15, 10);      /* strict array */
1350   GST_WRITE_UINT32_BE (data + 16, index_len);
1351   data += 20;
1352
1353   /* the keyframes' file positions */
1354   for (i = 0, l = mux->index; l; l = l->next, i++) {
1355     GstFlvMuxIndexEntry *entry = l->data;
1356
1357     if (i % index_skip != 0)
1358       continue;
1359     GST_WRITE_UINT8 (data, 0);
1360     GST_WRITE_DOUBLE_BE (data + 1, entry->position);
1361     data += 9;
1362   }
1363
1364   GST_WRITE_UINT24_BE (data, 9);        /* finish the ECMA array */
1365
1366   /* If there is space left in the prefilled area, reinsert the filler.
1367      There is at least 18  bytes free, so it will always fit. */
1368   if (index_len < MAX_INDEX_ENTRIES) {
1369     GstBuffer *tmp;
1370     guint8 *data;
1371     guint32 remaining_filler_size;
1372
1373     tmp = gst_buffer_new_and_alloc (14);
1374     data = GST_BUFFER_DATA (tmp);
1375     GST_WRITE_UINT16_BE (data, 9);
1376     memcpy (data + 2, "gstfiller", 9);
1377     GST_WRITE_UINT8 (data + 11, 2);     /* string */
1378
1379     /* There is 18 bytes per remaining index entry minus what is used for
1380      * the'gstfiller' key. The rest is already filled with spaces, so just need
1381      * to update length. */
1382     remaining_filler_size = (MAX_INDEX_ENTRIES - index_len) * 18 - 14;
1383     GST_DEBUG_OBJECT (mux, "Remaining filler size is %d bytes",
1384         remaining_filler_size);
1385     GST_WRITE_UINT16_BE (data + 12, remaining_filler_size);
1386     index = gst_buffer_join (index, tmp);
1387   }
1388
1389   rewrite = gst_buffer_join (rewrite, index);
1390
1391   gst_buffer_set_caps (rewrite, GST_PAD_CAPS (mux->srcpad));
1392   return gst_flv_mux_push (mux, rewrite);
1393 }
1394
1395 static GstFlowReturn
1396 gst_flv_mux_handle_buffer (GstCollectPads2 * pads, GstCollectData2 * cdata,
1397     GstBuffer * buffer, gpointer user_data)
1398 {
1399   GstFlvMux *mux = GST_FLV_MUX (user_data);
1400   GstFlvPad *best;
1401   GstClockTime best_time;
1402   GstFlowReturn ret;
1403
1404   if (mux->state == GST_FLV_MUX_STATE_HEADER) {
1405     if (mux->collect->data == NULL) {
1406       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1407           ("No input streams configured"));
1408       return GST_FLOW_ERROR;
1409     }
1410
1411     if (gst_pad_push_event (mux->srcpad,
1412             gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0)))
1413       ret = gst_flv_mux_write_header (mux);
1414     else
1415       ret = GST_FLOW_ERROR;
1416
1417     if (ret != GST_FLOW_OK)
1418       return ret;
1419     mux->state = GST_FLV_MUX_STATE_DATA;
1420   }
1421
1422   if (mux->new_tags) {
1423     GstBuffer *buf = gst_flv_mux_create_metadata (mux, FALSE);
1424     if (buf)
1425       gst_flv_mux_push (mux, buf);
1426     mux->new_tags = FALSE;
1427   }
1428
1429   best = (GstFlvPad *) cdata;
1430   if (best) {
1431     g_assert (buffer);
1432     best_time = GST_BUFFER_TIMESTAMP (buffer);
1433   } else {
1434     best_time = GST_CLOCK_TIME_NONE;
1435   }
1436
1437   /* The FLV timestamp is an int32 field. For non-live streams error out if a
1438      bigger timestamp is seen, for live the timestamp will get wrapped in
1439      gst_flv_mux_buffer_to_tag */
1440   if (!mux->streamable && GST_CLOCK_TIME_IS_VALID (best_time)
1441       && best_time / GST_MSECOND > G_MAXINT32) {
1442     GST_WARNING_OBJECT (mux, "Timestamp larger than FLV supports - EOS");
1443     gst_buffer_unref (buffer);
1444     buffer = NULL;
1445     best = NULL;
1446   }
1447
1448   if (best) {
1449     return gst_flv_mux_write_buffer (mux, best, buffer);
1450   } else {
1451     gst_flv_mux_rewrite_header (mux);
1452     gst_pad_push_event (mux->srcpad, gst_event_new_eos ());
1453     return GST_FLOW_UNEXPECTED;
1454   }
1455 }
1456
1457 static void
1458 gst_flv_mux_get_property (GObject * object,
1459     guint prop_id, GValue * value, GParamSpec * pspec)
1460 {
1461   GstFlvMux *mux = GST_FLV_MUX (object);
1462
1463   switch (prop_id) {
1464     case PROP_STREAMABLE:
1465       g_value_set_boolean (value, mux->streamable);
1466       break;
1467     default:
1468       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1469       break;
1470   }
1471 }
1472
1473 static void
1474 gst_flv_mux_set_property (GObject * object,
1475     guint prop_id, const GValue * value, GParamSpec * pspec)
1476 {
1477   GstFlvMux *mux = GST_FLV_MUX (object);
1478
1479   switch (prop_id) {
1480     case PROP_STREAMABLE:
1481       mux->streamable = g_value_get_boolean (value);
1482       if (mux->streamable)
1483         gst_tag_setter_set_tag_merge_mode (GST_TAG_SETTER (mux),
1484             GST_TAG_MERGE_REPLACE);
1485       else
1486         gst_tag_setter_set_tag_merge_mode (GST_TAG_SETTER (mux),
1487             GST_TAG_MERGE_KEEP);
1488       break;
1489     default:
1490       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1491       break;
1492   }
1493 }
1494
1495 static GstStateChangeReturn
1496 gst_flv_mux_change_state (GstElement * element, GstStateChange transition)
1497 {
1498   GstStateChangeReturn ret;
1499   GstFlvMux *mux = GST_FLV_MUX (element);
1500
1501   switch (transition) {
1502     case GST_STATE_CHANGE_NULL_TO_READY:
1503       break;
1504     case GST_STATE_CHANGE_READY_TO_PAUSED:
1505       gst_collect_pads2_start (mux->collect);
1506       break;
1507     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1508       break;
1509     case GST_STATE_CHANGE_PAUSED_TO_READY:
1510       gst_collect_pads2_stop (mux->collect);
1511       break;
1512     default:
1513       break;
1514   }
1515
1516   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1517
1518   switch (transition) {
1519     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1520       break;
1521     case GST_STATE_CHANGE_PAUSED_TO_READY:
1522       gst_flv_mux_reset (GST_ELEMENT (mux));
1523       break;
1524     case GST_STATE_CHANGE_READY_TO_NULL:
1525       break;
1526     default:
1527       break;
1528   }
1529
1530   return ret;
1531 }