plugins/elements/gstoutputselector.c

   1 /* GStreamer output selector
   2  * Copyright (C) 2008 Nokia Corporation. (contact <stefan.kost@nokia.com>)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:element-output-selector
  22  * @see_also: #GstOutputSelector, #GstInputSelector
  23  *
  24  * Direct input stream to one out of N output pads.
  25  *
  26  * Since: 0.10.32
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <string.h>
  34
  35 #include "gstoutputselector.h"
  36
  37 GST_DEBUG_CATEGORY_STATIC (output_selector_debug);
  38 #define GST_CAT_DEFAULT output_selector_debug
  39
  40 static GstStaticPadTemplate gst_output_selector_sink_factory =
  41 GST_STATIC_PAD_TEMPLATE ("sink",
  42     GST_PAD_SINK,
  43     GST_PAD_ALWAYS,
  44     GST_STATIC_CAPS_ANY);
  45
  46 static GstStaticPadTemplate gst_output_selector_src_factory =
  47 GST_STATIC_PAD_TEMPLATE ("src_%u",
  48     GST_PAD_SRC,
  49     GST_PAD_REQUEST,
  50     GST_STATIC_CAPS_ANY);
  51
  52 enum GstOutputSelectorPadNegotiationMode
  53 {
  54   GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE,
  55   GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL,
  56   GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ACTIVE
  57 };
  58 #define GST_TYPE_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE (gst_output_selector_pad_negotiation_mode_get_type())
  59 static GType
  60 gst_output_selector_pad_negotiation_mode_get_type (void)
  61 {
  62   static GType pad_negotiation_mode_type = 0;
  63   static GEnumValue pad_negotiation_modes[] = {
  64     {GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE, "None", "none"},
  65     {GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL, "All", "all"},
  66     {GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ACTIVE, "Active", "active"},
  67     {0, NULL, NULL}
  68   };
  69
  70   if (!pad_negotiation_mode_type) {
  71     pad_negotiation_mode_type =
  72         g_enum_register_static ("GstOutputSelectorPadNegotiationMode",
  73         pad_negotiation_modes);
  74   }
  75   return pad_negotiation_mode_type;
  76 }
  77
  78
  79 enum
  80 {
  81   PROP_0,
  82   PROP_ACTIVE_PAD,
  83   PROP_RESEND_LATEST,
  84   PROP_PAD_NEGOTIATION_MODE
  85 };
  86
  87 #define DEFAULT_PAD_NEGOTIATION_MODE GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL
  88
  89 #define _do_init \
  90 GST_DEBUG_CATEGORY_INIT (output_selector_debug, \
  91         "output-selector", 0, "Output stream selector");
  92 #define gst_output_selector_parent_class parent_class
  93 G_DEFINE_TYPE_WITH_CODE (GstOutputSelector, gst_output_selector,
  94     GST_TYPE_ELEMENT, _do_init);
  95
  96 static void gst_output_selector_dispose (GObject * object);
  97 static void gst_output_selector_set_property (GObject * object,
  98     guint prop_id, const GValue * value, GParamSpec * pspec);
  99 static void gst_output_selector_get_property (GObject * object,
 100     guint prop_id, GValue * value, GParamSpec * pspec);
 101 static GstPad *gst_output_selector_request_new_pad (GstElement * element,
 102     GstPadTemplate * templ, const gchar * unused, const GstCaps * caps);
 103 static void gst_output_selector_release_pad (GstElement * element,
 104     GstPad * pad);
 105 static GstFlowReturn gst_output_selector_chain (GstPad * pad, GstBuffer * buf);
 106 static GstStateChangeReturn gst_output_selector_change_state (GstElement *
 107     element, GstStateChange transition);
 108 static gboolean gst_output_selector_handle_sink_event (GstPad * pad,
 109     GstEvent * event);
 110 static void gst_output_selector_switch_pad_negotiation_mode (GstOutputSelector *
 111     sel, gint mode);
 112
 113 static void
 114 gst_output_selector_class_init (GstOutputSelectorClass * klass)
 115 {
 116   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 117   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
 118
 119   gobject_class->dispose = gst_output_selector_dispose;
 120
 121   gobject_class->set_property = gst_output_selector_set_property;
 122   gobject_class->get_property = gst_output_selector_get_property;
 123
 124   g_object_class_install_property (gobject_class, PROP_ACTIVE_PAD,
 125       g_param_spec_object ("active-pad", "Active pad",
 126           "Currently active src pad", GST_TYPE_PAD,
 127           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 128   g_object_class_install_property (gobject_class, PROP_RESEND_LATEST,
 129       g_param_spec_boolean ("resend-latest", "Resend latest buffer",
 130           "Resend latest buffer after a switch to a new pad", FALSE,
 131           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 132   g_object_class_install_property (gobject_class, PROP_PAD_NEGOTIATION_MODE,
 133       g_param_spec_enum ("pad-negotiation-mode", "Pad negotiation mode",
 134           "The mode to be used for pad negotiation",
 135           GST_TYPE_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE,
 136           DEFAULT_PAD_NEGOTIATION_MODE,
 137           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 138
 139   gst_element_class_set_details_simple (gstelement_class, "Output selector",
 140       "Generic", "1-to-N output stream selector",
 141       "Stefan Kost <stefan.kost@nokia.com>");
 142   gst_element_class_add_pad_template (gstelement_class,
 143       gst_static_pad_template_get (&gst_output_selector_sink_factory));
 144   gst_element_class_add_pad_template (gstelement_class,
 145       gst_static_pad_template_get (&gst_output_selector_src_factory));
 146
 147   gstelement_class->request_new_pad =
 148       GST_DEBUG_FUNCPTR (gst_output_selector_request_new_pad);
 149   gstelement_class->release_pad =
 150       GST_DEBUG_FUNCPTR (gst_output_selector_release_pad);
 151
 152   gstelement_class->change_state = gst_output_selector_change_state;
 153 }
 154
 155 static void
 156 gst_output_selector_init (GstOutputSelector * sel)
 157 {
 158   sel->sinkpad =
 159       gst_pad_new_from_static_template (&gst_output_selector_sink_factory,
 160       "sink");
 161   gst_pad_set_chain_function (sel->sinkpad,
 162       GST_DEBUG_FUNCPTR (gst_output_selector_chain));
 163   gst_pad_set_event_function (sel->sinkpad,
 164       GST_DEBUG_FUNCPTR (gst_output_selector_handle_sink_event));
 165
 166   gst_element_add_pad (GST_ELEMENT (sel), sel->sinkpad);
 167
 168   /* srcpad management */
 169   sel->active_srcpad = NULL;
 170   sel->nb_srcpads = 0;
 171   gst_segment_init (&sel->segment, GST_FORMAT_TIME);
 172   sel->pending_srcpad = NULL;
 173
 174   sel->resend_latest = FALSE;
 175   sel->latest_buffer = NULL;
 176   gst_output_selector_switch_pad_negotiation_mode (sel,
 177       DEFAULT_PAD_NEGOTIATION_MODE);
 178 }
 179
 180 static void
 181 gst_output_selector_reset (GstOutputSelector * osel)
 182 {
 183   if (osel->pending_srcpad != NULL) {
 184     gst_object_unref (osel->pending_srcpad);
 185     osel->pending_srcpad = NULL;
 186   }
 187   if (osel->latest_buffer != NULL) {
 188     gst_buffer_unref (osel->latest_buffer);
 189     osel->latest_buffer = NULL;
 190   }
 191   gst_segment_init (&osel->segment, GST_FORMAT_UNDEFINED);
 192 }
 193
 194 static void
 195 gst_output_selector_dispose (GObject * object)
 196 {
 197   GstOutputSelector *osel = GST_OUTPUT_SELECTOR (object);
 198
 199   gst_output_selector_reset (osel);
 200
 201   G_OBJECT_CLASS (parent_class)->dispose (object);
 202 }
 203
 204 static void
 205 gst_output_selector_set_property (GObject * object, guint prop_id,
 206     const GValue * value, GParamSpec * pspec)
 207 {
 208   GstOutputSelector *sel = GST_OUTPUT_SELECTOR (object);
 209
 210   switch (prop_id) {
 211     case PROP_ACTIVE_PAD:
 212     {
 213       GstPad *next_pad;
 214
 215       next_pad = g_value_get_object (value);
 216
 217       GST_INFO_OBJECT (sel, "Activating pad %s:%s",
 218           GST_DEBUG_PAD_NAME (next_pad));
 219
 220       GST_OBJECT_LOCK (object);
 221       if (next_pad != sel->active_srcpad) {
 222         /* switch to new srcpad in next chain run */
 223         if (sel->pending_srcpad != NULL) {
 224           GST_INFO ("replacing pending switch");
 225           gst_object_unref (sel->pending_srcpad);
 226         }
 227         if (next_pad)
 228           gst_object_ref (next_pad);
 229         sel->pending_srcpad = next_pad;
 230       } else {
 231         GST_INFO ("pad already active");
 232         if (sel->pending_srcpad != NULL) {
 233           gst_object_unref (sel->pending_srcpad);
 234           sel->pending_srcpad = NULL;
 235         }
 236       }
 237       GST_OBJECT_UNLOCK (object);
 238       break;
 239     }
 240     case PROP_RESEND_LATEST:{
 241       sel->resend_latest = g_value_get_boolean (value);
 242       break;
 243     }
 244     case PROP_PAD_NEGOTIATION_MODE:{
 245       gst_output_selector_switch_pad_negotiation_mode (sel,
 246           g_value_get_enum (value));
 247       break;
 248     }
 249     default:
 250       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 251       break;
 252   }
 253 }
 254
 255 static void
 256 gst_output_selector_get_property (GObject * object, guint prop_id,
 257     GValue * value, GParamSpec * pspec)
 258 {
 259   GstOutputSelector *sel = GST_OUTPUT_SELECTOR (object);
 260
 261   switch (prop_id) {
 262     case PROP_ACTIVE_PAD:
 263       GST_OBJECT_LOCK (object);
 264       g_value_set_object (value,
 265           sel->pending_srcpad ? sel->pending_srcpad : sel->active_srcpad);
 266       GST_OBJECT_UNLOCK (object);
 267       break;
 268     case PROP_RESEND_LATEST:{
 269       GST_OBJECT_LOCK (object);
 270       g_value_set_boolean (value, sel->resend_latest);
 271       GST_OBJECT_UNLOCK (object);
 272       break;
 273     }
 274     case PROP_PAD_NEGOTIATION_MODE:
 275       g_value_set_enum (value, sel->pad_negotiation_mode);
 276       break;
 277     default:
 278       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 279       break;
 280   }
 281 }
 282
 283 static GstCaps *
 284 gst_output_selector_sink_getcaps (GstPad * pad, GstCaps * filter)
 285 {
 286   GstOutputSelector *sel = GST_OUTPUT_SELECTOR (gst_pad_get_parent (pad));
 287   GstPad *active = NULL;
 288   GstCaps *caps = NULL;
 289
 290   if (G_UNLIKELY (sel == NULL))
 291     return (filter ? gst_caps_ref (filter) : gst_caps_new_any ());
 292
 293   GST_OBJECT_LOCK (sel);
 294   if (sel->pending_srcpad)
 295     active = gst_object_ref (sel->pending_srcpad);
 296   else if (sel->active_srcpad)
 297     active = gst_object_ref (sel->active_srcpad);
 298   GST_OBJECT_UNLOCK (sel);
 299
 300   if (active) {
 301     caps = gst_pad_peer_get_caps (active, filter);
 302     gst_object_unref (active);
 303   }
 304   if (caps == NULL) {
 305     caps = (filter ? gst_caps_ref (filter) : gst_caps_new_any ());
 306   }
 307
 308   gst_object_unref (sel);
 309   return caps;
 310 }
 311
 312 static void
 313 gst_output_selector_switch_pad_negotiation_mode (GstOutputSelector * sel,
 314     gint mode)
 315 {
 316   sel->pad_negotiation_mode = mode;
 317   if (mode == GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL) {
 318     gst_pad_set_getcaps_function (sel->sinkpad, gst_pad_proxy_getcaps);
 319   } else if (mode == GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE) {
 320     gst_pad_set_getcaps_function (sel->sinkpad, NULL);
 321   } else {                      /* active */
 322     gst_pad_set_getcaps_function (sel->sinkpad,
 323         gst_output_selector_sink_getcaps);
 324   }
 325 }
 326
 327 static GstFlowReturn
 328 forward_sticky_events (GstPad * pad, GstEvent * event, gpointer user_data)
 329 {
 330   GstPad *srcpad = GST_PAD_CAST (user_data);
 331
 332   gst_pad_push_event (srcpad, gst_event_ref (event));
 333
 334   return GST_FLOW_OK;
 335 }
 336
 337 static GstPad *
 338 gst_output_selector_request_new_pad (GstElement * element,
 339     GstPadTemplate * templ, const gchar * name, const GstCaps * caps)
 340 {
 341   gchar *padname;
 342   GstPad *srcpad;
 343   GstOutputSelector *osel;
 344
 345   osel = GST_OUTPUT_SELECTOR (element);
 346
 347   GST_DEBUG_OBJECT (osel, "requesting pad");
 348
 349   GST_OBJECT_LOCK (osel);
 350   padname = g_strdup_printf ("src_%u", osel->nb_srcpads++);
 351   srcpad = gst_pad_new_from_template (templ, padname);
 352   GST_OBJECT_UNLOCK (osel);
 353
 354   gst_pad_set_active (srcpad, TRUE);
 355
 356   /* Forward sticky events to the new srcpad */
 357   gst_pad_sticky_events_foreach (osel->sinkpad, forward_sticky_events, srcpad);
 358
 359   gst_element_add_pad (GST_ELEMENT (osel), srcpad);
 360
 361   /* Set the first requested src pad as active by default */
 362   if (osel->active_srcpad == NULL) {
 363     osel->active_srcpad = srcpad;
 364   }
 365   g_free (padname);
 366
 367   return srcpad;
 368 }
 369
 370 static void
 371 gst_output_selector_release_pad (GstElement * element, GstPad * pad)
 372 {
 373   GstOutputSelector *osel;
 374
 375   osel = GST_OUTPUT_SELECTOR (element);
 376
 377   GST_DEBUG_OBJECT (osel, "releasing pad");
 378
 379   gst_pad_set_active (pad, FALSE);
 380
 381   gst_element_remove_pad (GST_ELEMENT_CAST (osel), pad);
 382 }
 383
 384 static gboolean
 385 gst_output_selector_switch (GstOutputSelector * osel)
 386 {
 387   gboolean res = FALSE;
 388   GstEvent *ev = NULL;
 389   GstSegment *seg = NULL;
 390   gint64 start = 0, position = 0;
 391
 392   /* Switch */
 393   GST_OBJECT_LOCK (GST_OBJECT (osel));
 394   GST_INFO ("switching to pad %" GST_PTR_FORMAT, osel->pending_srcpad);
 395   if (gst_pad_is_linked (osel->pending_srcpad)) {
 396     osel->active_srcpad = osel->pending_srcpad;
 397     res = TRUE;
 398   }
 399   gst_object_unref (osel->pending_srcpad);
 400   osel->pending_srcpad = NULL;
 401   GST_OBJECT_UNLOCK (GST_OBJECT (osel));
 402
 403   /* Send SEGMENT event and latest buffer if switching succeeded */
 404   if (res) {
 405     /* Send SEGMENT to the pad we are going to switch to */
 406     seg = &osel->segment;
 407     /* If resending then mark segment start and position accordingly */
 408     if (osel->resend_latest && osel->latest_buffer &&
 409         GST_BUFFER_TIMESTAMP_IS_VALID (osel->latest_buffer)) {
 410       start = position = GST_BUFFER_TIMESTAMP (osel->latest_buffer);
 411     } else {
 412       start = position = seg->position;
 413     }
 414
 415     seg->start = start;
 416     seg->position = position;
 417     ev = gst_event_new_segment (seg);
 418
 419     if (!gst_pad_push_event (osel->active_srcpad, ev)) {
 420       GST_WARNING_OBJECT (osel,
 421           "newsegment handling failed in %" GST_PTR_FORMAT,
 422           osel->active_srcpad);
 423     }
 424
 425     /* Resend latest buffer to newly switched pad */
 426     if (osel->resend_latest && osel->latest_buffer) {
 427       GST_INFO ("resending latest buffer");
 428       gst_pad_push (osel->active_srcpad, gst_buffer_ref (osel->latest_buffer));
 429     }
 430   } else {
 431     GST_WARNING_OBJECT (osel, "switch failed, pad not linked");
 432   }
 433
 434   return res;
 435 }
 436
 437 static GstFlowReturn
 438 gst_output_selector_chain (GstPad * pad, GstBuffer * buf)
 439 {
 440   GstFlowReturn res;
 441   GstOutputSelector *osel;
 442   GstClockTime position, duration;
 443
 444   osel = GST_OUTPUT_SELECTOR (gst_pad_get_parent (pad));
 445
 446   /*
 447    * The _switch function might push a buffer if 'resend-latest' is true.
 448    *
 449    * Elements/Applications (e.g. camerabin) might use pad probes to
 450    * switch output-selector's active pad. If we simply switch and don't
 451    * recheck any pending pad switch the following codepath could end
 452    * up pushing a buffer on a non-active pad. This is bad.
 453    *
 454    * So we always should check the pending_srcpad before going further down
 455    * the chain and pushing the new buffer
 456    */
 457   while (osel->pending_srcpad) {
 458     /* Do the switch */
 459     gst_output_selector_switch (osel);
 460   }
 461
 462   if (osel->latest_buffer) {
 463     gst_buffer_unref (osel->latest_buffer);
 464     osel->latest_buffer = NULL;
 465   }
 466
 467   if (osel->resend_latest) {
 468     /* Keep reference to latest buffer to resend it after switch */
 469     osel->latest_buffer = gst_buffer_ref (buf);
 470   }
 471
 472   /* Keep track of last stop and use it in NEWSEGMENT start after
 473      switching to a new src pad */
 474   position = GST_BUFFER_TIMESTAMP (buf);
 475   if (GST_CLOCK_TIME_IS_VALID (position)) {
 476     duration = GST_BUFFER_DURATION (buf);
 477     if (GST_CLOCK_TIME_IS_VALID (duration)) {
 478       position += duration;
 479     }
 480     GST_LOG_OBJECT (osel, "setting last stop %" GST_TIME_FORMAT,
 481         GST_TIME_ARGS (position));
 482     osel->segment.position = position;
 483   }
 484
 485   GST_LOG_OBJECT (osel, "pushing buffer to %" GST_PTR_FORMAT,
 486       osel->active_srcpad);
 487   res = gst_pad_push (osel->active_srcpad, buf);
 488   gst_object_unref (osel);
 489
 490   return res;
 491 }
 492
 493 static GstStateChangeReturn
 494 gst_output_selector_change_state (GstElement * element,
 495     GstStateChange transition)
 496 {
 497   GstOutputSelector *sel;
 498   GstStateChangeReturn result;
 499
 500   sel = GST_OUTPUT_SELECTOR (element);
 501
 502   switch (transition) {
 503     case GST_STATE_CHANGE_READY_TO_PAUSED:
 504       break;
 505     default:
 506       break;
 507   }
 508
 509   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 510
 511   switch (transition) {
 512     case GST_STATE_CHANGE_PAUSED_TO_READY:
 513       gst_output_selector_reset (sel);
 514       break;
 515     default:
 516       break;
 517   }
 518
 519   return result;
 520 }
 521
 522 static gboolean
 523 gst_output_selector_handle_sink_event (GstPad * pad, GstEvent * event)
 524 {
 525   gboolean res = TRUE;
 526   GstOutputSelector *sel;
 527   GstPad *active = NULL;
 528
 529   sel = GST_OUTPUT_SELECTOR (gst_pad_get_parent (pad));
 530   if (G_UNLIKELY (sel == NULL)) {
 531     gst_event_unref (event);
 532     return FALSE;
 533   }
 534
 535   switch (GST_EVENT_TYPE (event)) {
 536     case GST_EVENT_CAPS:
 537     {
 538       switch (sel->pad_negotiation_mode) {
 539         case GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL:
 540           /* Send caps to all src pads */
 541           res = gst_pad_event_default (pad, event);
 542           break;
 543         case GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE:
 544           gst_event_unref (event);
 545           break;
 546         default:
 547           GST_OBJECT_LOCK (sel);
 548           if (sel->pending_srcpad)
 549             active = gst_object_ref (sel->pending_srcpad);
 550           else if (sel->active_srcpad)
 551             active = gst_object_ref (sel->active_srcpad);
 552           GST_OBJECT_UNLOCK (sel);
 553
 554           if (active) {
 555             res = gst_pad_push_event (active, event);
 556             gst_object_unref (active);
 557           } else {
 558             gst_event_unref (event);
 559           }
 560           break;
 561       }
 562       break;
 563     }
 564     case GST_EVENT_SEGMENT:
 565     {
 566       gst_event_copy_segment (event, &sel->segment);
 567
 568       GST_DEBUG_OBJECT (sel, "configured SEGMENT %" GST_SEGMENT_FORMAT,
 569           &sel->segment);
 570
 571       /* Send newsegment to all src pads */
 572       res = gst_pad_event_default (pad, event);
 573       break;
 574     }
 575     case GST_EVENT_EOS:
 576       /* Send eos to all src pads */
 577       res = gst_pad_event_default (pad, event);
 578       break;
 579     default:
 580     {
 581       GST_OBJECT_LOCK (sel);
 582       if (sel->pending_srcpad)
 583         active = gst_object_ref (sel->pending_srcpad);
 584       else if (sel->active_srcpad)
 585         active = gst_object_ref (sel->active_srcpad);
 586       GST_OBJECT_UNLOCK (sel);
 587
 588       /* Send other events to pending or active src pad */
 589       if (active) {
 590         res = gst_pad_push_event (active, event);
 591         gst_object_unref (active);
 592       } else {
 593         gst_event_unref (event);
 594       }
 595       break;
 596     }
 597   }
 598
 599   gst_object_unref (sel);
 600
 601   return res;
 602 }