gst-libs/gst/tag/gsttagmux.c

   1 /* GStreamer tag muxer base class
   2  * Copyright (C) 2006 Christophe Fergeau  <teuf@gnome.org>
   3  * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
   4  * Copyright (C) 2006 Sebastian Dröge <slomo@circular-chaos.org>
   5  * Copyright (C) 2009 Pioneers of the Inevitable <songbird@songbirdnest.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /**
  24  * SECTION:gsttagmux
  25  * @see_also: GstApeMux, GstId3Mux
  26  * @short_description: Base class for adding tags that are in one single chunk
  27  *                     directly at the beginning or at the end of a file
  28  *
  29  * <refsect2>
  30  * <para>
  31  * Provides a base class for adding tags at the beginning or end of a
  32  * stream.
  33  * </para>
  34  * <title>Deriving from GstTagMux</title>
  35  * <para>
  36  * Subclasses have to do the following things:
  37  * <itemizedlist>
  38  *  <listitem><para>
  39  *  In their base init function, they must add pad templates for the sink
  40  *  pad and the source pad to the element class, describing the media type
  41  *  they accept and output in the caps of the pad template.
  42  *  </para></listitem>
  43  *  <listitem><para>
  44  *  In their class init function, they must override the
  45  *  GST_TAG_MUX_CLASS(mux_klass)->render_start_tag and/or
  46  *  GST_TAG_MUX_CLASS(mux_klass)->render_end_tag vfuncs and set up a render
  47  *  function.
  48  *  </para></listitem>
  49  * </itemizedlist>
  50  * </para>
  51  * </refsect2>
  52  *
  53  * Since 0.10.36
  54  */
  55 #ifdef HAVE_CONFIG_H
  56 #include <config.h>
  57 #endif
  58
  59 #include <string.h>
  60 #include <gst/gsttagsetter.h>
  61 #include <gst/tag/tag.h>
  62
  63 #include "gsttagmux.h"
  64
  65 struct _GstTagMuxPrivate
  66 {
  67   GstPad *srcpad;
  68   GstPad *sinkpad;
  69   GstTagList *event_tags;       /* tags received from upstream elements */
  70   GstTagList *final_tags;       /* Final set of tags used for muxing */
  71   gsize start_tag_size;
  72   gsize end_tag_size;
  73   gboolean render_start_tag;
  74   gboolean render_end_tag;
  75
  76   gint64 current_offset;
  77   gint64 max_offset;
  78
  79   GstEvent *newsegment_ev;      /* cached newsegment event from upstream */
  80 };
  81
  82 GST_DEBUG_CATEGORY_STATIC (gst_tag_mux_debug);
  83 #define GST_CAT_DEFAULT gst_tag_mux_debug
  84
  85 static void
  86 gst_tag_mux_iface_init (GType tag_type)
  87 {
  88   static const GInterfaceInfo tag_setter_info = {
  89     NULL,
  90     NULL,
  91     NULL
  92   };
  93
  94   g_type_add_interface_static (tag_type, GST_TYPE_TAG_SETTER, &tag_setter_info);
  95 }
  96
  97 GST_BOILERPLATE_FULL (GstTagMux, gst_tag_mux,
  98     GstElement, GST_TYPE_ELEMENT, gst_tag_mux_iface_init);
  99
 100
 101 static GstStateChangeReturn
 102 gst_tag_mux_change_state (GstElement * element, GstStateChange transition);
 103 static GstFlowReturn gst_tag_mux_chain (GstPad * pad, GstBuffer * buffer);
 104 static gboolean gst_tag_mux_sink_event (GstPad * pad, GstEvent * event);
 105
 106 static void
 107 gst_tag_mux_finalize (GObject * obj)
 108 {
 109   GstTagMux *mux = GST_TAG_MUX (obj);
 110
 111   if (mux->priv->newsegment_ev) {
 112     gst_event_unref (mux->priv->newsegment_ev);
 113     mux->priv->newsegment_ev = NULL;
 114   }
 115
 116   if (mux->priv->event_tags) {
 117     gst_tag_list_free (mux->priv->event_tags);
 118     mux->priv->event_tags = NULL;
 119   }
 120
 121   if (mux->priv->final_tags) {
 122     gst_tag_list_free (mux->priv->final_tags);
 123     mux->priv->final_tags = NULL;
 124   }
 125
 126   G_OBJECT_CLASS (parent_class)->finalize (obj);
 127 }
 128
 129 static void
 130 gst_tag_mux_base_init (gpointer g_class)
 131 {
 132   GST_DEBUG_CATEGORY_INIT (gst_tag_mux_debug, "tagmux", 0,
 133       "tag muxer base class");
 134 }
 135
 136 static void
 137 gst_tag_mux_class_init (GstTagMuxClass * klass)
 138 {
 139   GObjectClass *gobject_class;
 140   GstElementClass *gstelement_class;
 141
 142   gobject_class = (GObjectClass *) klass;
 143   gstelement_class = (GstElementClass *) klass;
 144
 145   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_tag_mux_finalize);
 146   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_tag_mux_change_state);
 147
 148   g_type_class_add_private (klass, sizeof (GstTagMuxPrivate));
 149 }
 150
 151 static void
 152 gst_tag_mux_init (GstTagMux * mux, GstTagMuxClass * mux_class)
 153 {
 154   GstElementClass *element_klass = GST_ELEMENT_CLASS (mux_class);
 155   GstPadTemplate *tmpl;
 156
 157   mux->priv =
 158       G_TYPE_INSTANCE_GET_PRIVATE (mux, GST_TYPE_TAG_MUX, GstTagMuxPrivate);
 159
 160   /* pad through which data comes in to the element */
 161   tmpl = gst_element_class_get_pad_template (element_klass, "sink");
 162   if (tmpl) {
 163     mux->priv->sinkpad = gst_pad_new_from_template (tmpl, "sink");
 164   } else {
 165     g_warning ("GstTagMux subclass '%s' did not install a %s pad template!\n",
 166         G_OBJECT_CLASS_NAME (mux_class), "sink");
 167     mux->priv->sinkpad = gst_pad_new ("sink", GST_PAD_SINK);
 168   }
 169   gst_pad_set_chain_function (mux->priv->sinkpad,
 170       GST_DEBUG_FUNCPTR (gst_tag_mux_chain));
 171   gst_pad_set_event_function (mux->priv->sinkpad,
 172       GST_DEBUG_FUNCPTR (gst_tag_mux_sink_event));
 173   gst_element_add_pad (GST_ELEMENT (mux), mux->priv->sinkpad);
 174
 175   /* pad through which data goes out of the element */
 176   tmpl = gst_element_class_get_pad_template (element_klass, "src");
 177   if (tmpl) {
 178     GstCaps *tmpl_caps = gst_pad_template_get_caps (tmpl);
 179
 180     mux->priv->srcpad = gst_pad_new_from_template (tmpl, "src");
 181     gst_pad_use_fixed_caps (mux->priv->srcpad);
 182     if (tmpl_caps != NULL && gst_caps_is_fixed (tmpl_caps)) {
 183       gst_pad_set_caps (mux->priv->srcpad, tmpl_caps);
 184     }
 185   } else {
 186     g_warning ("GstTagMux subclass '%s' did not install a %s pad template!\n",
 187         G_OBJECT_CLASS_NAME (mux_class), "source");
 188     mux->priv->srcpad = gst_pad_new ("src", GST_PAD_SRC);
 189   }
 190   gst_element_add_pad (GST_ELEMENT (mux), mux->priv->srcpad);
 191
 192   mux->priv->render_start_tag = TRUE;
 193   mux->priv->render_end_tag = TRUE;
 194 }
 195
 196 static GstTagList *
 197 gst_tag_mux_get_tags (GstTagMux * mux)
 198 {
 199   GstTagSetter *tagsetter = GST_TAG_SETTER (mux);
 200   const GstTagList *tagsetter_tags;
 201   GstTagMergeMode merge_mode;
 202
 203   if (mux->priv->final_tags)
 204     return mux->priv->final_tags;
 205
 206   tagsetter_tags = gst_tag_setter_get_tag_list (tagsetter);
 207   merge_mode = gst_tag_setter_get_tag_merge_mode (tagsetter);
 208
 209   GST_LOG_OBJECT (mux, "merging tags, merge mode = %d", merge_mode);
 210   GST_LOG_OBJECT (mux, "event tags: %" GST_PTR_FORMAT, mux->priv->event_tags);
 211   GST_LOG_OBJECT (mux, "set   tags: %" GST_PTR_FORMAT, tagsetter_tags);
 212
 213   mux->priv->final_tags =
 214       gst_tag_list_merge (tagsetter_tags, mux->priv->event_tags, merge_mode);
 215
 216   GST_LOG_OBJECT (mux, "final tags: %" GST_PTR_FORMAT, mux->priv->final_tags);
 217
 218   return mux->priv->final_tags;
 219 }
 220
 221 static GstFlowReturn
 222 gst_tag_mux_render_start_tag (GstTagMux * mux)
 223 {
 224   GstTagMuxClass *klass;
 225   GstBuffer *buffer;
 226   GstTagList *taglist;
 227   GstEvent *event;
 228   GstFlowReturn ret;
 229
 230   taglist = gst_tag_mux_get_tags (mux);
 231
 232   klass = GST_TAG_MUX_CLASS (G_OBJECT_GET_CLASS (mux));
 233
 234   if (klass->render_start_tag == NULL)
 235     goto no_vfunc;
 236
 237   buffer = klass->render_start_tag (mux, taglist);
 238
 239   /* Null buffer is ok, just means we're not outputting anything */
 240   if (buffer == NULL) {
 241     GST_INFO_OBJECT (mux, "No start tag generated");
 242     mux->priv->start_tag_size = 0;
 243     return GST_FLOW_OK;
 244   }
 245
 246   if (GST_BUFFER_CAPS (buffer) == NULL) {
 247     buffer = gst_buffer_make_metadata_writable (buffer);
 248     gst_buffer_set_caps (buffer, GST_PAD_CAPS (mux->priv->srcpad));
 249   }
 250
 251   mux->priv->start_tag_size = GST_BUFFER_SIZE (buffer);
 252   GST_LOG_OBJECT (mux, "tag size = %" G_GSIZE_FORMAT " bytes",
 253       mux->priv->start_tag_size);
 254
 255   /* Send newsegment event from byte position 0, so the tag really gets
 256    * written to the start of the file, independent of the upstream segment */
 257   gst_pad_push_event (mux->priv->srcpad,
 258       gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0));
 259
 260   /* Send an event about the new tags to downstream elements */
 261   /* gst_event_new_tag takes ownership of the list, so use a copy */
 262   event = gst_event_new_tag (gst_tag_list_copy (taglist));
 263   gst_pad_push_event (mux->priv->srcpad, event);
 264
 265   GST_BUFFER_OFFSET (buffer) = 0;
 266   ret = gst_pad_push (mux->priv->srcpad, buffer);
 267
 268   mux->priv->current_offset = mux->priv->start_tag_size;
 269   mux->priv->max_offset =
 270       MAX (mux->priv->max_offset, mux->priv->current_offset);
 271
 272   return ret;
 273
 274 no_vfunc:
 275   {
 276     GST_ERROR_OBJECT (mux, "Subclass does not implement "
 277         "render_start_tag vfunc!");
 278     return GST_FLOW_ERROR;
 279   }
 280 }
 281
 282 static GstFlowReturn
 283 gst_tag_mux_render_end_tag (GstTagMux * mux)
 284 {
 285   GstTagMuxClass *klass;
 286   GstBuffer *buffer;
 287   GstTagList *taglist;
 288   GstFlowReturn ret;
 289
 290   taglist = gst_tag_mux_get_tags (mux);
 291
 292   klass = GST_TAG_MUX_CLASS (G_OBJECT_GET_CLASS (mux));
 293
 294   if (klass->render_end_tag == NULL)
 295     goto no_vfunc;
 296
 297   buffer = klass->render_end_tag (mux, taglist);
 298
 299   if (buffer == NULL) {
 300     GST_INFO_OBJECT (mux, "No end tag generated");
 301     mux->priv->end_tag_size = 0;
 302     return GST_FLOW_OK;
 303   }
 304
 305   if (GST_BUFFER_CAPS (buffer) == NULL) {
 306     buffer = gst_buffer_make_metadata_writable (buffer);
 307     gst_buffer_set_caps (buffer, GST_PAD_CAPS (mux->priv->srcpad));
 308   }
 309
 310   mux->priv->end_tag_size = GST_BUFFER_SIZE (buffer);
 311   GST_LOG_OBJECT (mux, "tag size = %" G_GSIZE_FORMAT " bytes",
 312       mux->priv->end_tag_size);
 313
 314   /* Send newsegment event from the end of the file, so it gets written there,
 315      independent of whatever new segment events upstream has sent us */
 316   gst_pad_push_event (mux->priv->srcpad,
 317       gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
 318           mux->priv->max_offset, -1, 0));
 319
 320   GST_BUFFER_OFFSET (buffer) = mux->priv->max_offset;
 321   ret = gst_pad_push (mux->priv->srcpad, buffer);
 322
 323   return ret;
 324
 325 no_vfunc:
 326   {
 327     GST_ERROR_OBJECT (mux, "Subclass does not implement "
 328         "render_end_tag vfunc!");
 329     return GST_FLOW_ERROR;
 330   }
 331 }
 332
 333 static GstEvent *
 334 gst_tag_mux_adjust_event_offsets (GstTagMux * mux,
 335     const GstEvent * newsegment_event)
 336 {
 337   GstFormat format;
 338   gint64 start, stop, cur;
 339
 340   gst_event_parse_new_segment ((GstEvent *) newsegment_event, NULL, NULL,
 341       &format, &start, &stop, &cur);
 342
 343   g_assert (format == GST_FORMAT_BYTES);
 344
 345   if (start != -1)
 346     start += mux->priv->start_tag_size;
 347   if (stop != -1)
 348     stop += mux->priv->start_tag_size;
 349   if (cur != -1)
 350     cur += mux->priv->start_tag_size;
 351
 352   GST_DEBUG_OBJECT (mux, "adjusting newsegment event offsets to start=%"
 353       G_GINT64_FORMAT ", stop=%" G_GINT64_FORMAT ", cur=%" G_GINT64_FORMAT
 354       " (delta = +%" G_GSIZE_FORMAT ")", start, stop, cur,
 355       mux->priv->start_tag_size);
 356
 357   return gst_event_new_new_segment (TRUE, 1.0, format, start, stop, cur);
 358 }
 359
 360 static GstFlowReturn
 361 gst_tag_mux_chain (GstPad * pad, GstBuffer * buffer)
 362 {
 363   GstTagMux *mux = GST_TAG_MUX (GST_OBJECT_PARENT (pad));
 364   GstFlowReturn ret;
 365   int length;
 366
 367   if (mux->priv->render_start_tag) {
 368
 369     GST_INFO_OBJECT (mux, "Adding tags to stream");
 370     ret = gst_tag_mux_render_start_tag (mux);
 371     if (ret != GST_FLOW_OK) {
 372       GST_DEBUG_OBJECT (mux, "flow: %s", gst_flow_get_name (ret));
 373       gst_buffer_unref (buffer);
 374       return ret;
 375     }
 376
 377     /* Now send the cached newsegment event that we got from upstream */
 378     if (mux->priv->newsegment_ev) {
 379       gint64 start;
 380       GstEvent *newseg;
 381
 382       GST_DEBUG_OBJECT (mux, "sending cached newsegment event");
 383       newseg = gst_tag_mux_adjust_event_offsets (mux, mux->priv->newsegment_ev);
 384       gst_event_unref (mux->priv->newsegment_ev);
 385       mux->priv->newsegment_ev = NULL;
 386
 387       gst_event_parse_new_segment (newseg, NULL, NULL, NULL, &start, NULL,
 388           NULL);
 389
 390       gst_pad_push_event (mux->priv->srcpad, newseg);
 391       mux->priv->current_offset = start;
 392       mux->priv->max_offset =
 393           MAX (mux->priv->max_offset, mux->priv->current_offset);
 394     } else {
 395       /* upstream sent no newsegment event or only one in a non-BYTE format */
 396     }
 397
 398     mux->priv->render_start_tag = FALSE;
 399   }
 400
 401   buffer = gst_buffer_make_metadata_writable (buffer);
 402
 403   if (GST_BUFFER_OFFSET (buffer) != GST_BUFFER_OFFSET_NONE) {
 404     GST_LOG_OBJECT (mux, "Adjusting buffer offset from %" G_GINT64_FORMAT
 405         " to %" G_GINT64_FORMAT, GST_BUFFER_OFFSET (buffer),
 406         GST_BUFFER_OFFSET (buffer) + mux->priv->start_tag_size);
 407     GST_BUFFER_OFFSET (buffer) += mux->priv->start_tag_size;
 408   }
 409
 410   length = GST_BUFFER_SIZE (buffer);
 411
 412   gst_buffer_set_caps (buffer, GST_PAD_CAPS (mux->priv->srcpad));
 413   ret = gst_pad_push (mux->priv->srcpad, buffer);
 414
 415   mux->priv->current_offset += length;
 416   mux->priv->max_offset =
 417       MAX (mux->priv->max_offset, mux->priv->current_offset);
 418
 419   return ret;
 420 }
 421
 422 static gboolean
 423 gst_tag_mux_sink_event (GstPad * pad, GstEvent * event)
 424 {
 425   GstTagMux *mux;
 426   gboolean result;
 427
 428   mux = GST_TAG_MUX (gst_pad_get_parent (pad));
 429   result = FALSE;
 430
 431   switch (GST_EVENT_TYPE (event)) {
 432     case GST_EVENT_TAG:{
 433       GstTagList *tags;
 434
 435       gst_event_parse_tag (event, &tags);
 436
 437       GST_INFO_OBJECT (mux, "Got tag event: %" GST_PTR_FORMAT, tags);
 438
 439       if (mux->priv->event_tags != NULL) {
 440         gst_tag_list_insert (mux->priv->event_tags, tags,
 441             GST_TAG_MERGE_REPLACE);
 442       } else {
 443         mux->priv->event_tags = gst_tag_list_copy (tags);
 444       }
 445
 446       GST_INFO_OBJECT (mux, "Event tags are now: %" GST_PTR_FORMAT,
 447           mux->priv->event_tags);
 448
 449       /* just drop the event, we'll push a new tag event in render_start_tag */
 450       gst_event_unref (event);
 451       result = TRUE;
 452       break;
 453     }
 454     case GST_EVENT_NEWSEGMENT:{
 455       GstFormat fmt;
 456       gint64 start;
 457
 458       gst_event_parse_new_segment (event, NULL, NULL, &fmt, &start, NULL, NULL);
 459
 460       if (fmt != GST_FORMAT_BYTES) {
 461         GST_WARNING_OBJECT (mux, "dropping newsegment event in %s format",
 462             gst_format_get_name (fmt));
 463         gst_event_unref (event);
 464         break;
 465       }
 466
 467       if (mux->priv->render_start_tag) {
 468         /* we have not rendered the tag yet, which means that we don't know
 469          * how large it is going to be yet, so we can't adjust the offsets
 470          * here at this point and need to cache the newsegment event for now
 471          * (also, there could be tag events coming after this newsegment event
 472          *  and before the first buffer). */
 473         if (mux->priv->newsegment_ev) {
 474           GST_WARNING_OBJECT (mux, "discarding old cached newsegment event");
 475           gst_event_unref (mux->priv->newsegment_ev);
 476         }
 477
 478         GST_LOG_OBJECT (mux, "caching newsegment event for later");
 479         mux->priv->newsegment_ev = event;
 480       } else {
 481         GST_DEBUG_OBJECT (mux, "got newsegment event, adjusting offsets");
 482         gst_pad_push_event (mux->priv->srcpad,
 483             gst_tag_mux_adjust_event_offsets (mux, event));
 484         gst_event_unref (event);
 485
 486         mux->priv->current_offset = start;
 487         mux->priv->max_offset =
 488             MAX (mux->priv->max_offset, mux->priv->current_offset);
 489       }
 490       event = NULL;
 491       result = TRUE;
 492       break;
 493     }
 494     case GST_EVENT_EOS:{
 495       if (mux->priv->render_end_tag) {
 496         GstFlowReturn ret;
 497
 498         GST_INFO_OBJECT (mux, "Adding tags to stream");
 499         ret = gst_tag_mux_render_end_tag (mux);
 500         if (ret != GST_FLOW_OK) {
 501           GST_DEBUG_OBJECT (mux, "flow: %s", gst_flow_get_name (ret));
 502           return ret;
 503         }
 504
 505         mux->priv->render_end_tag = FALSE;
 506       }
 507
 508       /* Now forward EOS */
 509       result = gst_pad_event_default (pad, event);
 510       break;
 511     }
 512     default:
 513       result = gst_pad_event_default (pad, event);
 514       break;
 515   }
 516
 517   gst_object_unref (mux);
 518
 519   return result;
 520 }
 521
 522
 523 static GstStateChangeReturn
 524 gst_tag_mux_change_state (GstElement * element, GstStateChange transition)
 525 {
 526   GstTagMux *mux;
 527   GstStateChangeReturn result;
 528
 529   mux = GST_TAG_MUX (element);
 530
 531   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 532   if (result != GST_STATE_CHANGE_SUCCESS) {
 533     return result;
 534   }
 535
 536   switch (transition) {
 537     case GST_STATE_CHANGE_PAUSED_TO_READY:{
 538       if (mux->priv->newsegment_ev) {
 539         gst_event_unref (mux->priv->newsegment_ev);
 540         mux->priv->newsegment_ev = NULL;
 541       }
 542       if (mux->priv->event_tags) {
 543         gst_tag_list_free (mux->priv->event_tags);
 544         mux->priv->event_tags = NULL;
 545       }
 546       mux->priv->start_tag_size = 0;
 547       mux->priv->end_tag_size = 0;
 548       mux->priv->render_start_tag = TRUE;
 549       mux->priv->render_end_tag = TRUE;
 550       mux->priv->current_offset = 0;
 551       mux->priv->max_offset = 0;
 552       break;
 553     }
 554     default:
 555       break;
 556   }
 557
 558   return result;
 559 }