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 #define gst_tag_mux_parent_class parent_class
  86 G_DEFINE_TYPE_WITH_CODE (GstTagMux, gst_tag_mux, GST_TYPE_ELEMENT,
  87     G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL));
  88
  89 static GstStateChangeReturn
  90 gst_tag_mux_change_state (GstElement * element, GstStateChange transition);
  91 static GstFlowReturn gst_tag_mux_chain (GstPad * pad, GstObject * parent,
  92     GstBuffer * buffer);
  93 static gboolean gst_tag_mux_sink_event (GstPad * pad, GstObject * parent,
  94     GstEvent * event);
  95
  96 static void
  97 gst_tag_mux_finalize (GObject * obj)
  98 {
  99   GstTagMux *mux = GST_TAG_MUX (obj);
 100
 101   if (mux->priv->newsegment_ev) {
 102     gst_event_unref (mux->priv->newsegment_ev);
 103     mux->priv->newsegment_ev = NULL;
 104   }
 105
 106   if (mux->priv->event_tags) {
 107     gst_tag_list_free (mux->priv->event_tags);
 108     mux->priv->event_tags = NULL;
 109   }
 110
 111   if (mux->priv->final_tags) {
 112     gst_tag_list_free (mux->priv->final_tags);
 113     mux->priv->final_tags = NULL;
 114   }
 115
 116   G_OBJECT_CLASS (parent_class)->finalize (obj);
 117 }
 118
 119 static void
 120 gst_tag_mux_class_init (GstTagMuxClass * klass)
 121 {
 122   GObjectClass *gobject_class;
 123   GstElementClass *gstelement_class;
 124
 125   gobject_class = (GObjectClass *) klass;
 126   gstelement_class = (GstElementClass *) klass;
 127
 128   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_tag_mux_finalize);
 129   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_tag_mux_change_state);
 130
 131   g_type_class_add_private (klass, sizeof (GstTagMuxPrivate));
 132
 133   GST_DEBUG_CATEGORY_INIT (gst_tag_mux_debug, "tagmux", 0,
 134       "tag muxer base class");
 135 }
 136
 137 static void
 138 gst_tag_mux_init (GstTagMux * mux)
 139 {
 140   GstElementClass *element_klass = GST_ELEMENT_GET_CLASS (mux);
 141   GstPadTemplate *tmpl;
 142
 143   mux->priv =
 144       G_TYPE_INSTANCE_GET_PRIVATE (mux, GST_TYPE_TAG_MUX, GstTagMuxPrivate);
 145
 146   /* pad through which data comes in to the element */
 147   tmpl = gst_element_class_get_pad_template (element_klass, "sink");
 148   if (tmpl) {
 149     mux->priv->sinkpad = gst_pad_new_from_template (tmpl, "sink");
 150   } else {
 151     g_warning ("GstTagMux subclass '%s' did not install a %s pad template!\n",
 152         G_OBJECT_CLASS_NAME (element_klass), "sink");
 153     mux->priv->sinkpad = gst_pad_new ("sink", GST_PAD_SINK);
 154   }
 155   gst_pad_set_chain_function (mux->priv->sinkpad,
 156       GST_DEBUG_FUNCPTR (gst_tag_mux_chain));
 157   gst_pad_set_event_function (mux->priv->sinkpad,
 158       GST_DEBUG_FUNCPTR (gst_tag_mux_sink_event));
 159   gst_element_add_pad (GST_ELEMENT (mux), mux->priv->sinkpad);
 160
 161   /* pad through which data goes out of the element */
 162   tmpl = gst_element_class_get_pad_template (element_klass, "src");
 163   if (tmpl) {
 164     GstCaps *tmpl_caps = gst_pad_template_get_caps (tmpl);
 165
 166     mux->priv->srcpad = gst_pad_new_from_template (tmpl, "src");
 167     gst_pad_use_fixed_caps (mux->priv->srcpad);
 168     if (tmpl_caps != NULL && gst_caps_is_fixed (tmpl_caps)) {
 169       gst_pad_set_caps (mux->priv->srcpad, tmpl_caps);
 170     }
 171   } else {
 172     g_warning ("GstTagMux subclass '%s' did not install a %s pad template!\n",
 173         G_OBJECT_CLASS_NAME (element_klass), "source");
 174     mux->priv->srcpad = gst_pad_new ("src", GST_PAD_SRC);
 175   }
 176   gst_element_add_pad (GST_ELEMENT (mux), mux->priv->srcpad);
 177
 178   mux->priv->render_start_tag = TRUE;
 179   mux->priv->render_end_tag = TRUE;
 180 }
 181
 182 static GstTagList *
 183 gst_tag_mux_get_tags (GstTagMux * mux)
 184 {
 185   GstTagSetter *tagsetter = GST_TAG_SETTER (mux);
 186   const GstTagList *tagsetter_tags;
 187   GstTagMergeMode merge_mode;
 188
 189   if (mux->priv->final_tags)
 190     return mux->priv->final_tags;
 191
 192   tagsetter_tags = gst_tag_setter_get_tag_list (tagsetter);
 193   merge_mode = gst_tag_setter_get_tag_merge_mode (tagsetter);
 194
 195   GST_LOG_OBJECT (mux, "merging tags, merge mode = %d", merge_mode);
 196   GST_LOG_OBJECT (mux, "event tags: %" GST_PTR_FORMAT, mux->priv->event_tags);
 197   GST_LOG_OBJECT (mux, "set   tags: %" GST_PTR_FORMAT, tagsetter_tags);
 198
 199   mux->priv->final_tags =
 200       gst_tag_list_merge (tagsetter_tags, mux->priv->event_tags, merge_mode);
 201
 202   GST_LOG_OBJECT (mux, "final tags: %" GST_PTR_FORMAT, mux->priv->final_tags);
 203
 204   return mux->priv->final_tags;
 205 }
 206
 207 static GstFlowReturn
 208 gst_tag_mux_render_start_tag (GstTagMux * mux)
 209 {
 210   GstTagMuxClass *klass;
 211   GstBuffer *buffer;
 212   GstTagList *taglist;
 213   GstEvent *event;
 214   GstFlowReturn ret;
 215   GstSegment segment;
 216
 217   taglist = gst_tag_mux_get_tags (mux);
 218
 219   klass = GST_TAG_MUX_CLASS (G_OBJECT_GET_CLASS (mux));
 220
 221   if (klass->render_start_tag == NULL)
 222     goto no_vfunc;
 223
 224   buffer = klass->render_start_tag (mux, taglist);
 225
 226   /* Null buffer is ok, just means we're not outputting anything */
 227   if (buffer == NULL) {
 228     GST_INFO_OBJECT (mux, "No start tag generated");
 229     mux->priv->start_tag_size = 0;
 230     return GST_FLOW_OK;
 231   }
 232
 233   mux->priv->start_tag_size = gst_buffer_get_size (buffer);
 234   GST_LOG_OBJECT (mux, "tag size = %" G_GSIZE_FORMAT " bytes",
 235       mux->priv->start_tag_size);
 236
 237   /* Send newsegment event from byte position 0, so the tag really gets
 238    * written to the start of the file, independent of the upstream segment */
 239   gst_segment_init (&segment, GST_FORMAT_BYTES);
 240   gst_pad_push_event (mux->priv->srcpad, gst_event_new_segment (&segment));
 241
 242   /* Send an event about the new tags to downstream elements */
 243   /* gst_event_new_tag takes ownership of the list, so use a copy */
 244   event = gst_event_new_tag (gst_tag_list_copy (taglist));
 245   gst_pad_push_event (mux->priv->srcpad, event);
 246
 247   GST_BUFFER_OFFSET (buffer) = 0;
 248   ret = gst_pad_push (mux->priv->srcpad, buffer);
 249
 250   mux->priv->current_offset = mux->priv->start_tag_size;
 251   mux->priv->max_offset =
 252       MAX (mux->priv->max_offset, mux->priv->current_offset);
 253
 254   return ret;
 255
 256 no_vfunc:
 257   {
 258     GST_ERROR_OBJECT (mux, "Subclass does not implement "
 259         "render_start_tag vfunc!");
 260     return GST_FLOW_ERROR;
 261   }
 262 }
 263
 264 static GstFlowReturn
 265 gst_tag_mux_render_end_tag (GstTagMux * mux)
 266 {
 267   GstTagMuxClass *klass;
 268   GstBuffer *buffer;
 269   GstTagList *taglist;
 270   GstFlowReturn ret;
 271   GstSegment segment;
 272
 273   taglist = gst_tag_mux_get_tags (mux);
 274
 275   klass = GST_TAG_MUX_CLASS (G_OBJECT_GET_CLASS (mux));
 276
 277   if (klass->render_end_tag == NULL)
 278     goto no_vfunc;
 279
 280   buffer = klass->render_end_tag (mux, taglist);
 281
 282   if (buffer == NULL) {
 283     GST_INFO_OBJECT (mux, "No end tag generated");
 284     mux->priv->end_tag_size = 0;
 285     return GST_FLOW_OK;
 286   }
 287
 288   mux->priv->end_tag_size = gst_buffer_get_size (buffer);
 289   GST_LOG_OBJECT (mux, "tag size = %" G_GSIZE_FORMAT " bytes",
 290       mux->priv->end_tag_size);
 291
 292   /* Send newsegment event from the end of the file, so it gets written there,
 293      independent of whatever new segment events upstream has sent us */
 294   gst_segment_init (&segment, GST_FORMAT_BYTES);
 295   segment.start = mux->priv->max_offset;
 296   gst_pad_push_event (mux->priv->srcpad, gst_event_new_segment (&segment));
 297
 298   GST_BUFFER_OFFSET (buffer) = mux->priv->max_offset;
 299   ret = gst_pad_push (mux->priv->srcpad, buffer);
 300
 301   return ret;
 302
 303 no_vfunc:
 304   {
 305     GST_ERROR_OBJECT (mux, "Subclass does not implement "
 306         "render_end_tag vfunc!");
 307     return GST_FLOW_ERROR;
 308   }
 309 }
 310
 311 static GstEvent *
 312 gst_tag_mux_adjust_event_offsets (GstTagMux * mux,
 313     const GstEvent * newsegment_event)
 314 {
 315   GstSegment segment;
 316
 317   gst_event_copy_segment ((GstEvent *) newsegment_event, &segment);
 318
 319   g_assert (segment.format == GST_FORMAT_BYTES);
 320
 321   if (segment.start != -1)
 322     segment.start += mux->priv->start_tag_size;
 323   if (segment.stop != -1)
 324     segment.stop += mux->priv->start_tag_size;
 325   if (segment.time != -1)
 326     segment.time += mux->priv->start_tag_size;
 327
 328   GST_DEBUG_OBJECT (mux, "adjusting newsegment event offsets to start=%"
 329       G_GINT64_FORMAT ", stop=%" G_GINT64_FORMAT ", cur=%" G_GINT64_FORMAT
 330       " (delta = +%" G_GSIZE_FORMAT ")", segment.start, segment.stop,
 331       segment.time, mux->priv->start_tag_size);
 332
 333   return gst_event_new_segment (&segment);
 334 }
 335
 336 static GstFlowReturn
 337 gst_tag_mux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
 338 {
 339   GstTagMux *mux = GST_TAG_MUX (parent);
 340   GstFlowReturn ret;
 341   int length;
 342
 343   if (mux->priv->render_start_tag) {
 344
 345     GST_INFO_OBJECT (mux, "Adding tags to stream");
 346     ret = gst_tag_mux_render_start_tag (mux);
 347     if (ret != GST_FLOW_OK) {
 348       GST_DEBUG_OBJECT (mux, "flow: %s", gst_flow_get_name (ret));
 349       gst_buffer_unref (buffer);
 350       return ret;
 351     }
 352
 353     /* Now send the cached newsegment event that we got from upstream */
 354     if (mux->priv->newsegment_ev) {
 355       GstEvent *newseg;
 356       GstSegment segment;
 357
 358       GST_DEBUG_OBJECT (mux, "sending cached newsegment event");
 359       newseg = gst_tag_mux_adjust_event_offsets (mux, mux->priv->newsegment_ev);
 360       gst_event_unref (mux->priv->newsegment_ev);
 361       mux->priv->newsegment_ev = NULL;
 362
 363       gst_event_copy_segment (newseg, &segment);
 364
 365       gst_pad_push_event (mux->priv->srcpad, newseg);
 366       mux->priv->current_offset = segment.start;
 367       mux->priv->max_offset =
 368           MAX (mux->priv->max_offset, mux->priv->current_offset);
 369     } else {
 370       /* upstream sent no newsegment event or only one in a non-BYTE format */
 371     }
 372
 373     mux->priv->render_start_tag = FALSE;
 374   }
 375
 376   buffer = gst_buffer_make_writable (buffer);
 377
 378   if (GST_BUFFER_OFFSET (buffer) != GST_BUFFER_OFFSET_NONE) {
 379     GST_LOG_OBJECT (mux, "Adjusting buffer offset from %" G_GINT64_FORMAT
 380         " to %" G_GINT64_FORMAT, GST_BUFFER_OFFSET (buffer),
 381         GST_BUFFER_OFFSET (buffer) + mux->priv->start_tag_size);
 382     GST_BUFFER_OFFSET (buffer) += mux->priv->start_tag_size;
 383   }
 384
 385   length = gst_buffer_get_size (buffer);
 386
 387   ret = gst_pad_push (mux->priv->srcpad, buffer);
 388
 389   mux->priv->current_offset += length;
 390   mux->priv->max_offset =
 391       MAX (mux->priv->max_offset, mux->priv->current_offset);
 392
 393   return ret;
 394 }
 395
 396 static gboolean
 397 gst_tag_mux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
 398 {
 399   GstTagMux *mux;
 400   gboolean result;
 401
 402   mux = GST_TAG_MUX (parent);
 403   result = FALSE;
 404
 405   switch (GST_EVENT_TYPE (event)) {
 406     case GST_EVENT_TAG:{
 407       GstTagList *tags;
 408
 409       gst_event_parse_tag (event, &tags);
 410
 411       GST_INFO_OBJECT (mux, "Got tag event: %" GST_PTR_FORMAT, tags);
 412
 413       if (mux->priv->event_tags != NULL) {
 414         gst_tag_list_insert (mux->priv->event_tags, tags,
 415             GST_TAG_MERGE_REPLACE);
 416       } else {
 417         mux->priv->event_tags = gst_tag_list_copy (tags);
 418       }
 419
 420       GST_INFO_OBJECT (mux, "Event tags are now: %" GST_PTR_FORMAT,
 421           mux->priv->event_tags);
 422
 423       /* just drop the event, we'll push a new tag event in render_start_tag */
 424       gst_event_unref (event);
 425       result = TRUE;
 426       break;
 427     }
 428     case GST_EVENT_SEGMENT:
 429     {
 430       GstSegment segment;
 431
 432       gst_event_copy_segment (event, &segment);
 433
 434       if (segment.format != GST_FORMAT_BYTES) {
 435         GST_WARNING_OBJECT (mux, "dropping newsegment event in %s format",
 436             gst_format_get_name (segment.format));
 437         gst_event_unref (event);
 438         break;
 439       }
 440
 441       if (mux->priv->render_start_tag) {
 442         /* we have not rendered the tag yet, which means that we don't know
 443          * how large it is going to be yet, so we can't adjust the offsets
 444          * here at this point and need to cache the newsegment event for now
 445          * (also, there could be tag events coming after this newsegment event
 446          *  and before the first buffer). */
 447         if (mux->priv->newsegment_ev) {
 448           GST_WARNING_OBJECT (mux, "discarding old cached newsegment event");
 449           gst_event_unref (mux->priv->newsegment_ev);
 450         }
 451
 452         GST_LOG_OBJECT (mux, "caching newsegment event for later");
 453         mux->priv->newsegment_ev = event;
 454       } else {
 455         GST_DEBUG_OBJECT (mux, "got newsegment event, adjusting offsets");
 456         gst_pad_push_event (mux->priv->srcpad,
 457             gst_tag_mux_adjust_event_offsets (mux, event));
 458         gst_event_unref (event);
 459
 460         mux->priv->current_offset = segment.start;
 461         mux->priv->max_offset =
 462             MAX (mux->priv->max_offset, mux->priv->current_offset);
 463       }
 464       event = NULL;
 465       result = TRUE;
 466       break;
 467     }
 468     case GST_EVENT_EOS:{
 469       if (mux->priv->render_end_tag) {
 470         GstFlowReturn ret;
 471
 472         GST_INFO_OBJECT (mux, "Adding tags to stream");
 473         ret = gst_tag_mux_render_end_tag (mux);
 474         if (ret != GST_FLOW_OK) {
 475           GST_DEBUG_OBJECT (mux, "flow: %s", gst_flow_get_name (ret));
 476           return ret;
 477         }
 478
 479         mux->priv->render_end_tag = FALSE;
 480       }
 481
 482       /* Now forward EOS */
 483       result = gst_pad_event_default (pad, parent, event);
 484       break;
 485     }
 486     default:
 487       result = gst_pad_event_default (pad, parent, event);
 488       break;
 489   }
 490
 491   return result;
 492 }
 493
 494
 495 static GstStateChangeReturn
 496 gst_tag_mux_change_state (GstElement * element, GstStateChange transition)
 497 {
 498   GstTagMux *mux;
 499   GstStateChangeReturn result;
 500
 501   mux = GST_TAG_MUX (element);
 502
 503   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 504   if (result != GST_STATE_CHANGE_SUCCESS) {
 505     return result;
 506   }
 507
 508   switch (transition) {
 509     case GST_STATE_CHANGE_PAUSED_TO_READY:{
 510       if (mux->priv->newsegment_ev) {
 511         gst_event_unref (mux->priv->newsegment_ev);
 512         mux->priv->newsegment_ev = NULL;
 513       }
 514       if (mux->priv->event_tags) {
 515         gst_tag_list_free (mux->priv->event_tags);
 516         mux->priv->event_tags = NULL;
 517       }
 518       mux->priv->start_tag_size = 0;
 519       mux->priv->end_tag_size = 0;
 520       mux->priv->render_start_tag = TRUE;
 521       mux->priv->render_end_tag = TRUE;
 522       mux->priv->current_offset = 0;
 523       mux->priv->max_offset = 0;
 524       break;
 525     }
 526     default:
 527       break;
 528   }
 529
 530   return result;
 531 }