wearable/gst/playback/gstsubtitleoverlay.c

   1 /*
   2  * Copyright (C) 2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   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-subtitleoverlay
  22  *
  23  * #GstBin that auto-magically overlays a video stream with subtitles by
  24  * autoplugging the required elements.
  25  *
  26  * It supports raw, timestamped text, different textual subtitle formats and
  27  * DVD subpicture subtitles.
  28  *
  29  * <refsect2>
  30  * <title>Examples</title>
  31  * |[
  32  * gst-launch -v filesrc location=test.mkv ! matroskademux name=demux ! "video/x-h264" ! queue2 ! decodebin2 ! subtitleoverlay name=overlay ! ffmpegcolorspace ! autovideosink  demux. ! "video/x-dvd-subpicture" ! queue2 ! overlay.
  33  * ]| This will play back the given Matroska file with h264 video and subpicture subtitles.
  34  * </refsect2>
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include "gstsubtitleoverlay.h"
  42
  43 #include <gst/gstfilter.h>
  44 #include <gst/pbutils/missing-plugins.h>
  45 #include <gst/video/video.h>
  46 #include <string.h>
  47
  48 #include "gst/glib-compat-private.h"
  49
  50 GST_DEBUG_CATEGORY_STATIC (subtitle_overlay_debug);
  51 #define GST_CAT_DEFAULT subtitle_overlay_debug
  52
  53 #define IS_SUBTITLE_CHAIN_IGNORE_ERROR(flow) \
  54   G_UNLIKELY (flow == GST_FLOW_ERROR || flow == GST_FLOW_NOT_NEGOTIATED)
  55
  56 #define IS_VIDEO_CHAIN_IGNORE_ERROR(flow) \
  57   G_UNLIKELY (flow == GST_FLOW_ERROR)
  58
  59 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
  60     GST_PAD_SRC,
  61     GST_PAD_ALWAYS,
  62     GST_STATIC_CAPS_ANY);
  63
  64 static GstStaticPadTemplate video_sinktemplate =
  65 GST_STATIC_PAD_TEMPLATE ("video_sink",
  66     GST_PAD_SINK,
  67     GST_PAD_ALWAYS,
  68     GST_STATIC_CAPS_ANY);
  69
  70 static GstStaticPadTemplate subtitle_sinktemplate =
  71 GST_STATIC_PAD_TEMPLATE ("subtitle_sink",
  72     GST_PAD_SINK,
  73     GST_PAD_ALWAYS,
  74     GST_STATIC_CAPS_ANY);
  75
  76 enum
  77 {
  78   PROP_0,
  79   PROP_SILENT,
  80   PROP_FONT_DESC,
  81   PROP_SUBTITLE_ENCODING
  82 };
  83
  84 GST_BOILERPLATE (GstSubtitleOverlay, gst_subtitle_overlay, GstBin,
  85     GST_TYPE_BIN);
  86
  87 static void _pad_blocked_cb (GstPad * pad, gboolean blocked,
  88     gpointer user_data);
  89
  90 static GQuark _subtitle_overlay_event_marker_id = 0;
  91
  92 static void
  93 do_async_start (GstSubtitleOverlay * self)
  94 {
  95   if (!self->do_async) {
  96     GstMessage *msg =
  97         gst_message_new_async_start (GST_OBJECT_CAST (self), FALSE);
  98
  99     GST_DEBUG_OBJECT (self, "Posting async-start");
 100     parent_class->handle_message (GST_BIN_CAST (self), msg);
 101     self->do_async = TRUE;
 102   }
 103 }
 104
 105 static void
 106 do_async_done (GstSubtitleOverlay * self)
 107 {
 108   if (self->do_async) {
 109     GstMessage *msg = gst_message_new_async_done (GST_OBJECT_CAST (self));
 110
 111     GST_DEBUG_OBJECT (self, "Posting async-done");
 112     parent_class->handle_message (GST_BIN_CAST (self), msg);
 113     self->do_async = FALSE;
 114   }
 115 }
 116
 117 static void
 118 gst_subtitle_overlay_finalize (GObject * object)
 119 {
 120   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (object);
 121
 122   if (self->lock) {
 123     g_mutex_free (self->lock);
 124     self->lock = NULL;
 125   }
 126
 127   if (self->factories_lock) {
 128     g_mutex_free (self->factories_lock);
 129     self->factories_lock = NULL;
 130   }
 131
 132   if (self->factories)
 133     gst_plugin_feature_list_free (self->factories);
 134   self->factories = NULL;
 135   gst_caps_replace (&self->factory_caps, NULL);
 136
 137   if (self->font_desc) {
 138     g_free (self->font_desc);
 139     self->font_desc = NULL;
 140   }
 141
 142   if (self->encoding) {
 143     g_free (self->encoding);
 144     self->encoding = NULL;
 145   }
 146
 147   G_OBJECT_CLASS (parent_class)->finalize (object);
 148 }
 149
 150 static gboolean
 151 _is_renderer (GstElementFactory * factory)
 152 {
 153   const gchar *klass, *name;
 154
 155   klass = gst_element_factory_get_klass (factory);
 156   name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE_CAST (factory));
 157
 158   if (strstr (klass, "Overlay/Subtitle") != NULL ||
 159       strstr (klass, "Overlay/SubPicture") != NULL)
 160     return TRUE;
 161   if (strcmp (name, "textoverlay") == 0)
 162     return TRUE;
 163   return FALSE;
 164 }
 165
 166 static gboolean
 167 _is_parser (GstElementFactory * factory)
 168 {
 169   const gchar *klass;
 170
 171   klass = gst_element_factory_get_klass (factory);
 172
 173   if (strstr (klass, "Parser/Subtitle") != NULL)
 174     return TRUE;
 175   return FALSE;
 176 }
 177
 178 static const gchar *_sub_pad_names[] = { "subpicture", "subpicture_sink",
 179   "text", "text_sink",
 180   "subtitle_sink", "subtitle"
 181 };
 182
 183 static inline gboolean
 184 _is_raw_video (GstStructure * s)
 185 {
 186   const gchar *name;
 187
 188   name = gst_structure_get_name (s);
 189
 190   if (g_str_has_prefix (name, "video/x-raw-"))
 191     return TRUE;
 192   return FALSE;
 193 }
 194
 195 static gboolean
 196 _is_video_pad (GstPad * pad, gboolean * hw_accelerated)
 197 {
 198   GstPad *peer = gst_pad_get_peer (pad);
 199   GstCaps *caps;
 200   gboolean ret;
 201   const gchar *name;
 202
 203   if (peer) {
 204     caps = gst_pad_get_negotiated_caps (peer);
 205     if (!caps) {
 206       caps = gst_pad_get_caps_reffed (peer);
 207     }
 208     gst_object_unref (peer);
 209   } else {
 210     caps = gst_pad_get_caps_reffed (pad);
 211   }
 212
 213
 214   name = gst_structure_get_name (gst_caps_get_structure (caps, 0));
 215   if (g_str_has_prefix (name, "video/x-raw-")) {
 216     ret = TRUE;
 217     if (hw_accelerated)
 218       *hw_accelerated = FALSE;
 219
 220   } else if (g_str_has_prefix (name, "video/x-surface")) {
 221     ret = TRUE;
 222     if (hw_accelerated)
 223       *hw_accelerated = TRUE;
 224   } else {
 225
 226     ret = FALSE;
 227     if (hw_accelerated)
 228       *hw_accelerated = FALSE;
 229   }
 230
 231   gst_caps_unref (caps);
 232
 233   return ret;
 234 }
 235
 236 static GstCaps *
 237 _get_sub_caps (GstElementFactory * factory)
 238 {
 239   const GList *templates;
 240   GList *walk;
 241   gboolean is_parser = _is_parser (factory);
 242
 243   templates = gst_element_factory_get_static_pad_templates (factory);
 244   for (walk = (GList *) templates; walk; walk = g_list_next (walk)) {
 245     GstStaticPadTemplate *templ = walk->data;
 246
 247     if (templ->direction == GST_PAD_SINK && templ->presence == GST_PAD_ALWAYS) {
 248       gboolean found = FALSE;
 249
 250       if (is_parser) {
 251         found = TRUE;
 252       } else {
 253         guint i;
 254
 255         for (i = 0; i < G_N_ELEMENTS (_sub_pad_names); i++) {
 256           if (strcmp (templ->name_template, _sub_pad_names[i]) == 0) {
 257             found = TRUE;
 258             break;
 259           }
 260         }
 261       }
 262       if (found)
 263         return gst_static_caps_get (&templ->static_caps);
 264     }
 265   }
 266   return NULL;
 267 }
 268
 269 static gboolean
 270 _factory_filter (GstPluginFeature * feature, GstCaps ** subcaps)
 271 {
 272   GstElementFactory *factory;
 273   guint rank;
 274   const gchar *name;
 275   const GList *templates;
 276   GList *walk;
 277   gboolean is_renderer;
 278   GstCaps *templ_caps = NULL;
 279   gboolean have_video_sink = FALSE;
 280
 281   /* we only care about element factories */
 282   if (!GST_IS_ELEMENT_FACTORY (feature))
 283     return FALSE;
 284
 285   factory = GST_ELEMENT_FACTORY_CAST (feature);
 286
 287   /* only select elements with autoplugging rank or textoverlay */
 288   name = gst_plugin_feature_get_name (feature);
 289   rank = gst_plugin_feature_get_rank (feature);
 290   if (strcmp ("textoverlay", name) != 0 && rank < GST_RANK_MARGINAL)
 291     return FALSE;
 292
 293   /* Check if it's a renderer or a parser */
 294   if (_is_renderer (factory)) {
 295     is_renderer = TRUE;
 296   } else if (_is_parser (factory)) {
 297     is_renderer = FALSE;
 298   } else {
 299     return FALSE;
 300   }
 301
 302   /* Check if there's a video sink in case of a renderer */
 303   if (is_renderer) {
 304     templates = gst_element_factory_get_static_pad_templates (factory);
 305     for (walk = (GList *) templates; walk; walk = g_list_next (walk)) {
 306       GstStaticPadTemplate *templ = walk->data;
 307
 308       /* we only care about the always-sink templates */
 309       if (templ->direction == GST_PAD_SINK && templ->presence == GST_PAD_ALWAYS) {
 310         if (strcmp (templ->name_template, "video") == 0 ||
 311             strcmp (templ->name_template, "video_sink") == 0) {
 312           have_video_sink = TRUE;
 313         }
 314       }
 315     }
 316   }
 317   templ_caps = _get_sub_caps (factory);
 318
 319   if (is_renderer && have_video_sink && templ_caps) {
 320     GST_DEBUG ("Found renderer element %s (%s) with caps %" GST_PTR_FORMAT,
 321         gst_element_factory_get_longname (factory),
 322         gst_plugin_feature_get_name (feature), templ_caps);
 323     gst_caps_merge (*subcaps, templ_caps);
 324     return TRUE;
 325   } else if (!is_renderer && !have_video_sink && templ_caps) {
 326     GST_DEBUG ("Found parser element %s (%s) with caps %" GST_PTR_FORMAT,
 327         gst_element_factory_get_longname (factory),
 328         gst_plugin_feature_get_name (feature), templ_caps);
 329     gst_caps_merge (*subcaps, templ_caps);
 330     return TRUE;
 331   } else {
 332     if (templ_caps)
 333       gst_caps_unref (templ_caps);
 334     return FALSE;
 335   }
 336 }
 337
 338 /* Call with factories_lock! */
 339 static gboolean
 340 gst_subtitle_overlay_update_factory_list (GstSubtitleOverlay * self)
 341 {
 342   if (!self->factories
 343       || self->factories_cookie !=
 344       gst_default_registry_get_feature_list_cookie ()) {
 345     GstCaps *subcaps;
 346     GList *factories;
 347
 348     subcaps = gst_caps_new_empty ();
 349
 350     factories = gst_default_registry_feature_filter (
 351         (GstPluginFeatureFilter) _factory_filter, FALSE, &subcaps);
 352     GST_DEBUG_OBJECT (self, "Created factory caps: %" GST_PTR_FORMAT, subcaps);
 353     gst_caps_replace (&self->factory_caps, subcaps);
 354     gst_caps_unref (subcaps);
 355     if (self->factories)
 356       gst_plugin_feature_list_free (self->factories);
 357     self->factories = factories;
 358     self->factories_cookie = gst_default_registry_get_feature_list_cookie ();
 359   }
 360
 361   return (self->factories != NULL);
 362 }
 363
 364 G_LOCK_DEFINE_STATIC (_factory_caps);
 365 static GstCaps *_factory_caps = NULL;
 366 static guint32 _factory_caps_cookie = 0;
 367
 368 GstCaps *
 369 gst_subtitle_overlay_create_factory_caps (void)
 370 {
 371   GList *factories;
 372   GstCaps *subcaps = NULL;
 373
 374   G_LOCK (_factory_caps);
 375   if (!_factory_caps
 376       || _factory_caps_cookie !=
 377       gst_default_registry_get_feature_list_cookie ()) {
 378     if (_factory_caps)
 379       gst_caps_unref (_factory_caps);
 380     _factory_caps = gst_caps_new_empty ();
 381
 382     factories = gst_default_registry_feature_filter (
 383         (GstPluginFeatureFilter) _factory_filter, FALSE, &_factory_caps);
 384     GST_DEBUG ("Created factory caps: %" GST_PTR_FORMAT, _factory_caps);
 385     gst_plugin_feature_list_free (factories);
 386     _factory_caps_cookie = gst_default_registry_get_feature_list_cookie ();
 387   }
 388   subcaps = gst_caps_ref (_factory_caps);
 389   G_UNLOCK (_factory_caps);
 390
 391   return subcaps;
 392 }
 393
 394 static gboolean
 395 check_factory_for_caps (GstElementFactory * factory, const GstCaps * caps)
 396 {
 397   GstCaps *fcaps = _get_sub_caps (factory);
 398   gboolean ret = (fcaps) ? gst_caps_can_intersect (fcaps, caps) : FALSE;
 399
 400   if (fcaps)
 401     gst_caps_unref (fcaps);
 402
 403   if (ret)
 404     gst_object_ref (factory);
 405   return ret;
 406 }
 407
 408 static GList *
 409 gst_subtitle_overlay_get_factories_for_caps (const GList * list,
 410     const GstCaps * caps)
 411 {
 412   const GList *walk = list;
 413   GList *result = NULL;
 414
 415   while (walk) {
 416     GstElementFactory *factory = walk->data;
 417
 418     walk = g_list_next (walk);
 419
 420     if (check_factory_for_caps (factory, caps)) {
 421       result = g_list_prepend (result, factory);
 422     }
 423   }
 424
 425   return result;
 426 }
 427
 428 static gint
 429 _sort_by_ranks (GstPluginFeature * f1, GstPluginFeature * f2)
 430 {
 431   gint diff;
 432   const gchar *rname1, *rname2;
 433
 434   diff = gst_plugin_feature_get_rank (f2) - gst_plugin_feature_get_rank (f1);
 435   if (diff != 0)
 436     return diff;
 437
 438   /* If the ranks are the same sort by name to get deterministic results */
 439   rname1 = gst_plugin_feature_get_name (f1);
 440   rname2 = gst_plugin_feature_get_name (f2);
 441
 442   diff = strcmp (rname1, rname2);
 443
 444   return diff;
 445 }
 446
 447 static GstPad *
 448 _get_sub_pad (GstElement * element)
 449 {
 450   GstPad *pad;
 451   guint i;
 452
 453   for (i = 0; i < G_N_ELEMENTS (_sub_pad_names); i++) {
 454     pad = gst_element_get_static_pad (element, _sub_pad_names[i]);
 455     if (pad)
 456       return pad;
 457   }
 458   return NULL;
 459 }
 460
 461 static GstPad *
 462 _get_video_pad (GstElement * element)
 463 {
 464   static const gchar *pad_names[] = { "video", "video_sink" };
 465   GstPad *pad;
 466   guint i;
 467
 468   for (i = 0; i < G_N_ELEMENTS (pad_names); i++) {
 469     pad = gst_element_get_static_pad (element, pad_names[i]);
 470     if (pad)
 471       return pad;
 472   }
 473   return NULL;
 474 }
 475
 476 static gboolean
 477 _create_element (GstSubtitleOverlay * self, GstElement ** element,
 478     const gchar * factory_name, GstElementFactory * factory,
 479     const gchar * element_name, gboolean mandatory)
 480 {
 481   GstElement *elt;
 482
 483   g_assert (!factory || !factory_name);
 484
 485   if (factory_name) {
 486     elt = gst_element_factory_make (factory_name, element_name);
 487   } else {
 488     factory_name =
 489         gst_plugin_feature_get_name (GST_PLUGIN_FEATURE_CAST (factory));
 490     elt = gst_element_factory_create (factory, element_name);
 491   }
 492
 493   if (G_UNLIKELY (!elt)) {
 494     if (!factory) {
 495       GstMessage *msg;
 496
 497       msg =
 498           gst_missing_element_message_new (GST_ELEMENT_CAST (self),
 499           factory_name);
 500       gst_element_post_message (GST_ELEMENT_CAST (self), msg);
 501
 502       if (mandatory)
 503         GST_ELEMENT_ERROR (self, CORE, MISSING_PLUGIN, (NULL),
 504             ("no '%s' plugin found", factory_name));
 505       else
 506         GST_ELEMENT_WARNING (self, CORE, MISSING_PLUGIN, (NULL),
 507             ("no '%s' plugin found", factory_name));
 508     } else {
 509       if (mandatory) {
 510         GST_ELEMENT_ERROR (self, CORE, FAILED, (NULL),
 511             ("can't instantiate '%s'", factory_name));
 512       } else {
 513         GST_ELEMENT_WARNING (self, CORE, FAILED, (NULL),
 514             ("can't instantiate '%s'", factory_name));
 515       }
 516     }
 517
 518     return FALSE;
 519   }
 520
 521   if (G_UNLIKELY (gst_element_set_state (elt,
 522               GST_STATE_READY) != GST_STATE_CHANGE_SUCCESS)) {
 523     gst_object_unref (elt);
 524     if (mandatory) {
 525       GST_ELEMENT_ERROR (self, CORE, STATE_CHANGE, (NULL),
 526           ("failed to set '%s' to READY", factory_name));
 527     } else {
 528       GST_WARNING_OBJECT (self, "Failed to set '%s' to READY", factory_name);
 529     }
 530     return FALSE;
 531   }
 532
 533   if (G_UNLIKELY (!gst_bin_add (GST_BIN_CAST (self), gst_object_ref (elt)))) {
 534     gst_element_set_state (elt, GST_STATE_NULL);
 535     gst_object_unref (elt);
 536     if (mandatory) {
 537       GST_ELEMENT_ERROR (self, CORE, FAILED, (NULL),
 538           ("failed to add '%s' to subtitleoverlay", factory_name));
 539     } else {
 540       GST_WARNING_OBJECT (self, "Failed to add '%s' to subtitleoverlay",
 541           factory_name);
 542     }
 543     return FALSE;
 544   }
 545
 546   gst_element_sync_state_with_parent (elt);
 547   *element = elt;
 548   return TRUE;
 549 }
 550
 551 static void
 552 _remove_element (GstSubtitleOverlay * self, GstElement ** element)
 553 {
 554   if (*element) {
 555     gst_bin_remove (GST_BIN_CAST (self), *element);
 556     gst_element_set_state (*element, GST_STATE_NULL);
 557     gst_object_unref (*element);
 558     *element = NULL;
 559   }
 560 }
 561
 562 static void
 563 _generate_update_newsegment_event (GstSegment * segment, GstEvent ** event1,
 564     GstEvent ** event2)
 565 {
 566   GstEvent *event;
 567
 568   *event1 = NULL;
 569   *event2 = NULL;
 570
 571   event = gst_event_new_new_segment_full (FALSE, segment->rate,
 572       segment->applied_rate, segment->format, 0, segment->accum, 0);
 573   gst_structure_id_set (event->structure, _subtitle_overlay_event_marker_id,
 574       G_TYPE_BOOLEAN, TRUE, NULL);
 575   *event1 = event;
 576
 577   event = gst_event_new_new_segment_full (FALSE, segment->rate,
 578       segment->applied_rate, segment->format,
 579       segment->start, segment->stop, segment->time);
 580   gst_structure_id_set (event->structure, _subtitle_overlay_event_marker_id,
 581       G_TYPE_BOOLEAN, TRUE, NULL);
 582   *event2 = event;
 583 }
 584
 585 static gboolean
 586 _setup_passthrough (GstSubtitleOverlay * self)
 587 {
 588   GstPad *src, *sink;
 589   GstElement *identity;
 590
 591   GST_DEBUG_OBJECT (self, "Doing video passthrough");
 592
 593   if (self->passthrough_identity) {
 594     GST_DEBUG_OBJECT (self, "Already in passthrough mode");
 595     goto out;
 596   }
 597
 598   /* Unlink & destroy everything */
 599   gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->srcpad), NULL);
 600   gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->video_sinkpad), NULL);
 601   gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->subtitle_sinkpad), NULL);
 602   self->silent_property = NULL;
 603   _remove_element (self, &self->post_colorspace);
 604   _remove_element (self, &self->overlay);
 605   _remove_element (self, &self->parser);
 606   _remove_element (self, &self->renderer);
 607   _remove_element (self, &self->pre_colorspace);
 608   _remove_element (self, &self->passthrough_identity);
 609
 610   if (G_UNLIKELY (!_create_element (self, &self->passthrough_identity,
 611               "identity", NULL, "passthrough-identity", TRUE))) {
 612     return FALSE;
 613   }
 614
 615   identity = self->passthrough_identity;
 616   g_object_set (G_OBJECT (identity), "silent", TRUE, "signal-handoffs", FALSE,
 617       NULL);
 618
 619   /* Set src ghostpad target */
 620   src = gst_element_get_static_pad (self->passthrough_identity, "src");
 621   if (G_UNLIKELY (!src)) {
 622     GST_ELEMENT_ERROR (self, CORE, PAD, (NULL),
 623         ("Failed to get srcpad from identity"));
 624     return FALSE;
 625   }
 626
 627   if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->srcpad),
 628               src))) {
 629     GST_ELEMENT_ERROR (self, CORE, PAD, (NULL),
 630         ("Failed to set srcpad target"));
 631     gst_object_unref (src);
 632     return FALSE;
 633   }
 634   gst_object_unref (src);
 635
 636   sink = gst_element_get_static_pad (self->passthrough_identity, "sink");
 637   if (G_UNLIKELY (!sink)) {
 638     GST_ELEMENT_ERROR (self, CORE, PAD, (NULL),
 639         ("Failed to get sinkpad from identity"));
 640     return FALSE;
 641   }
 642
 643   /* Send segment to the identity. This is dropped because identity
 644    * is not linked downstream yet */
 645   if (self->video_segment.format != GST_FORMAT_UNDEFINED) {
 646     GstEvent *event1, *event2;
 647
 648     _generate_update_newsegment_event (&self->video_segment, &event1, &event2);
 649     GST_DEBUG_OBJECT (self,
 650         "Pushing video accumulate newsegment event: %" GST_PTR_FORMAT,
 651         event1->structure);
 652     GST_DEBUG_OBJECT (self,
 653         "Pushing video update newsegment event: %" GST_PTR_FORMAT,
 654         event2->structure);
 655     gst_pad_send_event (sink, event1);
 656     gst_pad_send_event (sink, event2);
 657   }
 658
 659   /* Link sink ghostpads to identity */
 660   if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
 661               (self->video_sinkpad), sink))) {
 662     GST_ELEMENT_ERROR (self, CORE, PAD, (NULL),
 663         ("Failed to set video sinkpad target"));
 664     gst_object_unref (sink);
 665     return FALSE;
 666   }
 667   gst_object_unref (sink);
 668
 669   GST_DEBUG_OBJECT (self, "Video passthrough setup successfully");
 670
 671 out:
 672   /* Unblock pads */
 673   gst_pad_set_blocked_async_full (self->video_block_pad, FALSE,
 674       _pad_blocked_cb, self, NULL);
 675
 676   if (self->subtitle_sink_blocked)
 677     gst_pad_set_blocked_async_full (self->subtitle_block_pad, FALSE,
 678         _pad_blocked_cb, self, NULL);
 679
 680   return TRUE;
 681 }
 682
 683 /* Must be called with subtitleoverlay lock! */
 684 static void
 685 gst_subtitle_overlay_set_fps (GstSubtitleOverlay * self)
 686 {
 687   GObjectClass *gobject_class;
 688   GParamSpec *pspec;
 689
 690   if (!self->parser || self->fps_d == 0)
 691     return;
 692
 693   gobject_class = G_OBJECT_GET_CLASS (self->parser);
 694   pspec = g_object_class_find_property (gobject_class, "video-fps");
 695   if (!pspec || pspec->value_type != GST_TYPE_FRACTION)
 696     return;
 697
 698   GST_DEBUG_OBJECT (self, "Updating video-fps property in parser");
 699   g_object_set (self->parser, "video-fps", self->fps_n, self->fps_d, NULL);
 700 }
 701
 702 static const gchar *
 703 _get_silent_property (GstElement * element, gboolean * invert)
 704 {
 705   static const struct
 706   {
 707     const gchar *name;
 708     gboolean invert;
 709   } properties[] = { {
 710   "silent", FALSE}, {
 711   "enable", TRUE}};
 712   GObjectClass *gobject_class;
 713   GParamSpec *pspec;
 714   guint i;
 715
 716   gobject_class = G_OBJECT_GET_CLASS (element);
 717
 718   for (i = 0; i < G_N_ELEMENTS (properties); i++) {
 719     pspec = g_object_class_find_property (gobject_class, properties[i].name);
 720     if (pspec && pspec->value_type == G_TYPE_BOOLEAN) {
 721       *invert = properties[i].invert;
 722       return properties[i].name;
 723     }
 724   }
 725   return NULL;
 726 }
 727
 728 static gboolean
 729 _has_subtitle_encoding_property (GstElement * element)
 730 {
 731   GParamSpec *pspec;
 732
 733   pspec =
 734       g_object_class_find_property (G_OBJECT_GET_CLASS (element),
 735       "subtitle-encoding");
 736   return (pspec && pspec->value_type == G_TYPE_STRING);
 737 }
 738
 739 static gboolean
 740 _has_font_desc_property (GstElement * element)
 741 {
 742   GParamSpec *pspec;
 743
 744   pspec =
 745       g_object_class_find_property (G_OBJECT_GET_CLASS (element), "font-desc");
 746   return (pspec && pspec->value_type == G_TYPE_STRING);
 747 }
 748
 749 static void
 750 _pad_blocked_cb (GstPad * pad, gboolean blocked, gpointer user_data)
 751 {
 752   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY_CAST (user_data);
 753   GstCaps *subcaps;
 754   GList *l, *factories = NULL;
 755
 756   GST_DEBUG_OBJECT (pad, "Pad blocked: %d", blocked);
 757
 758   GST_SUBTITLE_OVERLAY_LOCK (self);
 759   if (pad == self->video_block_pad)
 760     self->video_sink_blocked = blocked;
 761   else if (pad == self->subtitle_block_pad)
 762     self->subtitle_sink_blocked = blocked;
 763
 764   if (!blocked) {
 765     GST_SUBTITLE_OVERLAY_UNLOCK (self);
 766     return;
 767   }
 768
 769   /* Now either both or the video sink are blocked */
 770
 771   /* Get current subtitle caps */
 772   subcaps = self->subcaps;
 773   if (!subcaps) {
 774     GstPad *peer;
 775
 776     peer = gst_pad_get_peer (self->subtitle_sinkpad);
 777     if (peer) {
 778       subcaps = gst_pad_get_negotiated_caps (peer);
 779       if (!subcaps) {
 780         subcaps = gst_pad_get_caps_reffed (peer);
 781         if (!gst_caps_is_fixed (subcaps)) {
 782           gst_caps_unref (subcaps);
 783           subcaps = NULL;
 784         }
 785       }
 786       gst_object_unref (peer);
 787     }
 788     gst_caps_replace (&self->subcaps, subcaps);
 789     if (subcaps)
 790       gst_caps_unref (subcaps);
 791   }
 792   GST_DEBUG_OBJECT (self, "Current subtitle caps: %" GST_PTR_FORMAT, subcaps);
 793
 794   /* If there are no subcaps but the subtitle sink is blocked upstream
 795    * must behave wrong as there are no fixed caps set for the first
 796    * buffer or in-order event */
 797   if (G_UNLIKELY (!subcaps && self->subtitle_sink_blocked)) {
 798     GST_ELEMENT_WARNING (self, CORE, NEGOTIATION, (NULL),
 799         ("Subtitle sink is blocked but we have no subtitle caps"));
 800     subcaps = NULL;
 801   }
 802
 803   if (self->subtitle_error || (self->silent && !self->silent_property)) {
 804     _setup_passthrough (self);
 805     do_async_done (self);
 806     goto out;
 807   }
 808
 809   /* Now do something with the caps */
 810   if (subcaps && !self->subtitle_flush) {
 811     GstPad *target =
 812         gst_ghost_pad_get_target (GST_GHOST_PAD_CAST (self->subtitle_sinkpad));
 813
 814     if (target && gst_pad_accept_caps (target, subcaps)) {
 815       GST_DEBUG_OBJECT (pad, "Target accepts caps");
 816
 817       gst_object_unref (target);
 818
 819       /* Unblock pads */
 820       gst_pad_set_blocked_async_full (self->video_block_pad, FALSE,
 821           _pad_blocked_cb, self, NULL);
 822
 823       if (self->subtitle_sink_blocked)
 824         gst_pad_set_blocked_async_full (self->subtitle_block_pad, FALSE,
 825             _pad_blocked_cb, self, NULL);
 826       goto out;
 827     } else if (target) {
 828       gst_object_unref (target);
 829     }
 830   }
 831
 832   if (self->subtitle_sink_blocked && !self->video_sink_blocked) {
 833     GST_DEBUG_OBJECT (self, "Subtitle sink blocked but video not blocked");
 834     gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
 835         _pad_blocked_cb, self, NULL);
 836     goto out;
 837   }
 838
 839   self->subtitle_flush = FALSE;
 840
 841   /* Find our factories */
 842   g_mutex_lock (self->factories_lock);
 843   gst_subtitle_overlay_update_factory_list (self);
 844   if (subcaps) {
 845     factories =
 846         gst_subtitle_overlay_get_factories_for_caps (self->factories, subcaps);
 847     if (!factories) {
 848       GstMessage *msg;
 849
 850       msg = gst_missing_decoder_message_new (GST_ELEMENT_CAST (self), subcaps);
 851       gst_element_post_message (GST_ELEMENT_CAST (self), msg);
 852       GST_ELEMENT_WARNING (self, CORE, MISSING_PLUGIN, (NULL),
 853           ("no suitable subtitle plugin found"));
 854       subcaps = NULL;
 855       self->subtitle_error = TRUE;
 856     }
 857   }
 858   g_mutex_unlock (self->factories_lock);
 859
 860   if (!subcaps) {
 861     _setup_passthrough (self);
 862     do_async_done (self);
 863     goto out;
 864   }
 865
 866   /* Now the interesting parts are done: subtitle overlaying! */
 867
 868   /* Sort the factories by rank */
 869   factories = g_list_sort (factories, (GCompareFunc) _sort_by_ranks);
 870
 871   for (l = factories; l; l = l->next) {
 872     GstElementFactory *factory = l->data;
 873     gboolean is_video, is_hw, is_renderer = _is_renderer (factory);
 874     GstElement *element;
 875     GstPad *sink, *src;
 876
 877     /* Unlink & destroy everything */
 878
 879     gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->srcpad), NULL);
 880     gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->video_sinkpad), NULL);
 881     gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->subtitle_sinkpad),
 882         NULL);
 883     self->silent_property = NULL;
 884     _remove_element (self, &self->post_colorspace);
 885     _remove_element (self, &self->overlay);
 886     _remove_element (self, &self->parser);
 887     _remove_element (self, &self->renderer);
 888     _remove_element (self, &self->pre_colorspace);
 889     _remove_element (self, &self->passthrough_identity);
 890
 891     GST_DEBUG_OBJECT (self, "Trying factory '%s'",
 892         GST_STR_NULL (gst_plugin_feature_get_name (GST_PLUGIN_FEATURE_CAST
 893                 (factory))));
 894
 895     if (G_UNLIKELY ((is_renderer
 896                 && !_create_element (self, &self->renderer, NULL, factory,
 897                     "renderer", FALSE)) || (!is_renderer
 898                 && !_create_element (self, &self->parser, NULL, factory,
 899                     "parser", FALSE))))
 900       continue;
 901
 902     element = is_renderer ? self->renderer : self->parser;
 903
 904     is_video = _is_video_pad (self->video_sinkpad, &is_hw);
 905     /* If this is a parser, create textoverlay and link video and the parser to it
 906      * Else link the renderer to the output colorspace */
 907     if (!is_renderer) {
 908       GstElement *overlay;
 909       GstPad *video_peer;
 910
 911       /* Try to get the latest video framerate */
 912       video_peer = gst_pad_get_peer (self->video_sinkpad);
 913       if (video_peer) {
 914         GstCaps *video_caps;
 915         gint fps_n, fps_d;
 916
 917         video_caps = gst_pad_get_negotiated_caps (video_peer);
 918         if (!video_caps) {
 919           video_caps = gst_pad_get_caps_reffed (video_peer);
 920           if (!gst_caps_is_fixed (video_caps)) {
 921             gst_caps_unref (video_caps);
 922             video_caps = NULL;
 923           }
 924         }
 925
 926         if (video_caps
 927             && gst_video_parse_caps_framerate (video_caps, &fps_n, &fps_d)) {
 928           if (self->fps_n != fps_n || self->fps_d != fps_d) {
 929             GST_DEBUG_OBJECT (self, "New video fps: %d/%d", fps_n, fps_d);
 930             self->fps_n = fps_n;
 931             self->fps_d = fps_d;
 932           }
 933         }
 934
 935         if (video_caps)
 936           gst_caps_unref (video_caps);
 937         gst_object_unref (video_peer);
 938       }
 939
 940       if (_has_subtitle_encoding_property (self->parser))
 941         g_object_set (self->parser, "subtitle-encoding", self->encoding, NULL);
 942
 943       /* Try to set video fps on the parser */
 944       gst_subtitle_overlay_set_fps (self);
 945
 946       /* First link everything internally */
 947       if (G_UNLIKELY (!_create_element (self, &self->overlay, "textoverlay",
 948                   NULL, "overlay", FALSE))) {
 949         continue;
 950       }
 951       overlay = self->overlay;
 952       self->silent_property = "silent";
 953       self->silent_property_invert = FALSE;
 954
 955       /* Set some properties */
 956       g_object_set (G_OBJECT (overlay),
 957           "halign", "center", "valign", "bottom", "wait-text", FALSE, NULL);
 958       if (self->font_desc)
 959         g_object_set (G_OBJECT (overlay), "font-desc", self->font_desc, NULL);
 960
 961       src = gst_element_get_static_pad (element, "src");
 962       if (G_UNLIKELY (!src)) {
 963         continue;
 964       }
 965
 966       sink = gst_element_get_static_pad (overlay, "text_sink");
 967       if (G_UNLIKELY (!sink)) {
 968         GST_WARNING_OBJECT (self, "Can't get text sink from textoverlay");
 969         gst_object_unref (src);
 970         continue;
 971       }
 972
 973       if (G_UNLIKELY (gst_pad_link (src, sink) != GST_PAD_LINK_OK)) {
 974         GST_WARNING_OBJECT (self, "Can't link parser to textoverlay");
 975         gst_object_unref (sink);
 976         gst_object_unref (src);
 977         continue;
 978       }
 979       gst_object_unref (sink);
 980       gst_object_unref (src);
 981
 982       /* If we are working with video/x-surface, we do not add
 983        * colorspace conversion elements */
 984       if (is_video && !is_hw) {
 985         if (G_UNLIKELY (!_create_element (self, &self->post_colorspace,
 986                     COLORSPACE, NULL, "post-colorspace", FALSE))) {
 987           continue;
 988         }
 989
 990         src = gst_element_get_static_pad (overlay, "src");
 991         if (G_UNLIKELY (!src)) {
 992           GST_WARNING_OBJECT (self, "Can't get src pad from overlay");
 993           continue;
 994         }
 995
 996         sink = gst_element_get_static_pad (self->post_colorspace, "sink");
 997         if (G_UNLIKELY (!sink)) {
 998           GST_WARNING_OBJECT (self, "Can't get sink pad from " COLORSPACE);
 999           gst_object_unref (src);
1000           continue;
1001         }
1002
1003         if (G_UNLIKELY (gst_pad_link (src, sink) != GST_PAD_LINK_OK)) {
1004           GST_WARNING_OBJECT (self, "Can't link overlay with " COLORSPACE);
1005           gst_object_unref (src);
1006           gst_object_unref (sink);
1007           continue;
1008         }
1009         gst_object_unref (src);
1010         gst_object_unref (sink);
1011
1012         if (G_UNLIKELY (!_create_element (self, &self->pre_colorspace,
1013                     "identity", NULL, "pre-colorspace", FALSE))) {
1014           continue;
1015         }
1016
1017         sink = gst_element_get_static_pad (overlay, "video_sink");
1018         if (G_UNLIKELY (!sink)) {
1019           GST_WARNING_OBJECT (self, "Can't get video sink from textoverlay");
1020           continue;
1021         }
1022
1023         src = gst_element_get_static_pad (self->pre_colorspace, "src");
1024         if (G_UNLIKELY (!src)) {
1025           GST_WARNING_OBJECT (self, "Can't get srcpad from " COLORSPACE);
1026           gst_object_unref (sink);
1027           continue;
1028         }
1029
1030         if (G_UNLIKELY (gst_pad_link (src, sink) != GST_PAD_LINK_OK)) {
1031           GST_WARNING_OBJECT (self, "Can't link " COLORSPACE " to textoverlay");
1032           gst_object_unref (src);
1033           gst_object_unref (sink);
1034           continue;
1035         }
1036         gst_object_unref (src);
1037         gst_object_unref (sink);
1038
1039         /* Set src ghostpad target */
1040         src = gst_element_get_static_pad (self->post_colorspace, "src");
1041         if (G_UNLIKELY (!src)) {
1042           GST_WARNING_OBJECT (self, "Can't get src pad from " COLORSPACE);
1043           continue;
1044         }
1045
1046         if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
1047                     (self->srcpad), src))) {
1048           GST_WARNING_OBJECT (self, "Can't set srcpad target");
1049           gst_object_unref (src);
1050           continue;
1051         }
1052         gst_object_unref (src);
1053       } else if (is_hw) {
1054         GST_DEBUG_OBJECT (self,
1055             "Is Hardware, not adding colorspace converters, ");
1056         /* Set src ghostpad target */
1057         src = gst_element_get_static_pad (self->overlay, "src");
1058         if (G_UNLIKELY (!src)) {
1059           GST_WARNING_OBJECT (self, "Can't get src pad from textoverlay");
1060           continue;
1061         }
1062
1063         if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
1064                     (self->srcpad), src))) {
1065           GST_WARNING_OBJECT (self, "Can't set srcpad target");
1066           gst_object_unref (src);
1067           continue;
1068         }
1069         gst_object_unref (src);
1070       }
1071
1072       /* Send segments to the parser/overlay if necessary. These are not sent
1073        * outside this element because of the proxy pad event function */
1074       if (self->video_segment.format != GST_FORMAT_UNDEFINED) {
1075         GstEvent *event1, *event2;
1076
1077         if (is_video) {
1078           sink = gst_element_get_static_pad (self->pre_colorspace, "sink");
1079           if (G_UNLIKELY (!sink)) {
1080             GST_WARNING_OBJECT (self, "Can't get sink pad from " COLORSPACE);
1081             continue;
1082           }
1083         } else {
1084           sink = gst_element_get_static_pad (self->overlay, "video_sink");
1085           if (G_UNLIKELY (!sink)) {
1086             GST_WARNING_OBJECT (self, "Can't get sink pad from textoverlay");
1087             continue;
1088           }
1089         }
1090
1091         _generate_update_newsegment_event (&self->video_segment, &event1,
1092             &event2);
1093         GST_DEBUG_OBJECT (self,
1094             "Pushing video accumulate newsegment event: %" GST_PTR_FORMAT,
1095             event1->structure);
1096         GST_DEBUG_OBJECT (self,
1097             "Pushing video update newsegment event: %" GST_PTR_FORMAT,
1098             event2->structure);
1099         gst_pad_send_event (sink, event1);
1100         gst_pad_send_event (sink, event2);
1101
1102         gst_object_unref (sink);
1103       }
1104
1105       if (self->subtitle_segment.format != GST_FORMAT_UNDEFINED) {
1106         GstEvent *event1, *event2;
1107
1108         sink = gst_element_get_static_pad (element, "sink");
1109         if (G_UNLIKELY (!sink)) {
1110           GST_WARNING_OBJECT (self, "Failed to get subpad");
1111           continue;
1112         }
1113
1114         _generate_update_newsegment_event (&self->subtitle_segment, &event1,
1115             &event2);
1116         GST_DEBUG_OBJECT (self,
1117             "Pushing subtitle accumulate newsegment event: %" GST_PTR_FORMAT,
1118             event1->structure);
1119         GST_DEBUG_OBJECT (self,
1120             "Pushing subtitle update newsegment event: %" GST_PTR_FORMAT,
1121             event2->structure);
1122         gst_pad_send_event (sink, event1);
1123         gst_pad_send_event (sink, event2);
1124
1125         gst_object_unref (sink);
1126       }
1127
1128       /* Set the sink ghostpad targets */
1129       if (is_video && !is_hw) {
1130         sink = gst_element_get_static_pad (self->pre_colorspace, "sink");
1131         if (G_UNLIKELY (!sink)) {
1132           GST_WARNING_OBJECT (self, "Can't get sink pad from " COLORSPACE);
1133           continue;
1134         }
1135       } else if (is_video && is_hw) {
1136         GST_DEBUG_OBJECT (self, "Setting ghostpad to overlay video sink");
1137         sink = gst_element_get_static_pad (self->overlay, "video_sink");
1138         if (G_UNLIKELY (!sink)) {
1139           GST_WARNING_OBJECT (self, "Can't get sink pad from overlay");
1140           continue;
1141         }
1142       }
1143
1144       if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
1145                   (self->video_sinkpad), sink))) {
1146         GST_WARNING_OBJECT (self, "Can't set video sinkpad target");
1147         gst_object_unref (sink);
1148         continue;
1149       }
1150       gst_object_unref (sink);
1151
1152       /* Link subtitle identity to subtitle pad of our element */
1153       sink = gst_element_get_static_pad (element, "sink");
1154       if (G_UNLIKELY (!sink)) {
1155         GST_WARNING_OBJECT (self, "Failed to get subpad");
1156         continue;
1157       }
1158
1159       if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
1160                   (self->subtitle_sinkpad), sink))) {
1161         GST_WARNING_OBJECT (self, "Failed to set subtitle sink target");
1162         gst_object_unref (sink);
1163         continue;
1164       }
1165       gst_object_unref (sink);
1166     } else {
1167       const gchar *name =
1168           gst_plugin_feature_get_name (GST_PLUGIN_FEATURE_CAST (factory));
1169
1170       if (strcmp (name, "textoverlay") == 0) {
1171         /* Set some textoverlay specific properties */
1172         g_object_set (G_OBJECT (element),
1173             "halign", "center", "valign", "bottom", "wait-text", FALSE, NULL);
1174         if (self->font_desc)
1175           g_object_set (G_OBJECT (element), "font-desc", self->font_desc, NULL);
1176         self->silent_property = "silent";
1177         self->silent_property_invert = FALSE;
1178       } else {
1179         self->silent_property =
1180             _get_silent_property (element, &self->silent_property_invert);
1181         if (_has_subtitle_encoding_property (self->renderer))
1182           g_object_set (self->renderer, "subtitle-encoding", self->encoding,
1183               NULL);
1184         if (_has_font_desc_property (self->renderer))
1185           g_object_set (self->renderer, "font-desc", self->font_desc, NULL);
1186       }
1187
1188       if (is_video) {
1189         gboolean render_is_hw;
1190
1191         /* First check that renderer also supports the video format */
1192         sink = _get_video_pad (element);
1193         if (G_UNLIKELY (!sink)) {
1194           GST_WARNING_OBJECT (self, "Can't get video sink from renderer");
1195           continue;
1196         }
1197
1198         if (is_video != _is_video_pad (sink, &render_is_hw) ||
1199             is_hw != render_is_hw) {
1200           GST_DEBUG_OBJECT (self, "Renderer doesn't support %s video",
1201               is_hw ? "surface" : "raw");
1202           gst_object_unref (sink);
1203           continue;
1204         }
1205         gst_object_unref (sink);
1206
1207         if (!is_hw) {
1208           /* First link everything internally */
1209           if (G_UNLIKELY (!_create_element (self, &self->post_colorspace,
1210                       COLORSPACE, NULL, "post-colorspace", FALSE))) {
1211             continue;
1212           }
1213           src = gst_element_get_static_pad (element, "src");
1214           if (G_UNLIKELY (!src)) {
1215             GST_WARNING_OBJECT (self, "Can't get src pad from renderer");
1216             continue;
1217           }
1218
1219           sink = gst_element_get_static_pad (self->post_colorspace, "sink");
1220           if (G_UNLIKELY (!sink)) {
1221             GST_WARNING_OBJECT (self, "Can't get sink pad from " COLORSPACE);
1222             gst_object_unref (src);
1223             continue;
1224           }
1225
1226           if (G_UNLIKELY (gst_pad_link (src, sink) != GST_PAD_LINK_OK)) {
1227             GST_WARNING_OBJECT (self, "Can't link renderer with " COLORSPACE);
1228             gst_object_unref (src);
1229             gst_object_unref (sink);
1230             continue;
1231           }
1232           gst_object_unref (src);
1233           gst_object_unref (sink);
1234
1235           if (G_UNLIKELY (!_create_element (self, &self->pre_colorspace,
1236                       COLORSPACE, NULL, "pre-colorspace", FALSE))) {
1237             continue;
1238           }
1239
1240           sink = _get_video_pad (element);
1241           if (G_UNLIKELY (!sink)) {
1242             GST_WARNING_OBJECT (self, "Can't get video sink from renderer");
1243             continue;
1244           }
1245
1246           src = gst_element_get_static_pad (self->pre_colorspace, "src");
1247           if (G_UNLIKELY (!src)) {
1248             GST_WARNING_OBJECT (self, "Can't get srcpad from " COLORSPACE);
1249             gst_object_unref (sink);
1250             continue;
1251           }
1252
1253           if (G_UNLIKELY (gst_pad_link (src, sink) != GST_PAD_LINK_OK)) {
1254             GST_WARNING_OBJECT (self, "Can't link " COLORSPACE " to renderer");
1255             gst_object_unref (src);
1256             gst_object_unref (sink);
1257             continue;
1258           }
1259           gst_object_unref (src);
1260           gst_object_unref (sink);
1261
1262           /* Set src ghostpad target */
1263           src = gst_element_get_static_pad (self->post_colorspace, "src");
1264           if (G_UNLIKELY (!src)) {
1265             GST_WARNING_OBJECT (self, "Can't get src pad from " COLORSPACE);
1266             continue;
1267           }
1268         } else {
1269           /* Set src ghostpad target in the harware accelerated case */
1270
1271           src = gst_element_get_static_pad (self->renderer, "src");
1272           if (G_UNLIKELY (!src)) {
1273             GST_WARNING_OBJECT (self, "Can't get src pad from renderer");
1274             continue;
1275           }
1276         }
1277       } else {                  /* No video pad */
1278         GstCaps *allowed_caps, *video_caps = NULL;
1279         GstPad *video_peer;
1280         gboolean can_intersect = FALSE;
1281
1282         video_peer = gst_pad_get_peer (self->video_sinkpad);
1283         if (video_peer) {
1284           video_caps = gst_pad_get_negotiated_caps (video_peer);
1285           if (!video_caps) {
1286             video_caps = gst_pad_get_caps_reffed (video_peer);
1287           }
1288           gst_object_unref (video_peer);
1289         }
1290
1291         sink = _get_video_pad (element);
1292         if (G_UNLIKELY (!sink)) {
1293           GST_WARNING_OBJECT (self, "Can't get video sink from renderer");
1294           continue;
1295         }
1296         allowed_caps = gst_pad_get_caps_reffed (sink);
1297         gst_object_unref (sink);
1298
1299         if (allowed_caps && video_caps)
1300           can_intersect = gst_caps_can_intersect (allowed_caps, video_caps);
1301
1302         if (allowed_caps)
1303           gst_caps_unref (allowed_caps);
1304
1305         if (video_caps)
1306           gst_caps_unref (video_caps);
1307
1308         if (G_UNLIKELY (!can_intersect)) {
1309           GST_WARNING_OBJECT (self, "Renderer with custom caps is not "
1310               "compatible with video stream");
1311           continue;
1312         }
1313
1314         src = gst_element_get_static_pad (element, "src");
1315         if (G_UNLIKELY (!src)) {
1316           GST_WARNING_OBJECT (self, "Can't get src pad from renderer");
1317           continue;
1318         }
1319       }
1320
1321       if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
1322                   (self->srcpad), src))) {
1323         GST_WARNING_OBJECT (self, "Can't set srcpad target");
1324         gst_object_unref (src);
1325         continue;
1326       }
1327       gst_object_unref (src);
1328
1329       /* Send segments to the renderer if necessary. These are not sent
1330        * outside this element because of the proxy pad event handler */
1331       if (self->video_segment.format != GST_FORMAT_UNDEFINED) {
1332         GstEvent *event1, *event2;
1333
1334         sink = gst_element_get_static_pad (self->pre_colorspace, "sink");
1335         if (G_UNLIKELY (!sink)) {
1336           GST_WARNING_OBJECT (self, "Can't get sink pad from " COLORSPACE);
1337           continue;
1338         }
1339
1340         _generate_update_newsegment_event (&self->video_segment, &event1,
1341             &event2);
1342         GST_DEBUG_OBJECT (self,
1343             "Pushing video accumulate newsegment event: %" GST_PTR_FORMAT,
1344             event1->structure);
1345         GST_DEBUG_OBJECT (self,
1346             "Pushing video update newsegment event: %" GST_PTR_FORMAT,
1347             event2->structure);
1348         gst_pad_send_event (sink, event1);
1349         gst_pad_send_event (sink, event2);
1350         gst_object_unref (sink);
1351       }
1352
1353       if (self->subtitle_segment.format != GST_FORMAT_UNDEFINED) {
1354         GstEvent *event1, *event2;
1355
1356         sink = _get_sub_pad (element);
1357         if (G_UNLIKELY (!sink)) {
1358           GST_WARNING_OBJECT (self, "Failed to get subpad");
1359           continue;
1360         }
1361
1362         _generate_update_newsegment_event (&self->subtitle_segment, &event1,
1363             &event2);
1364         GST_DEBUG_OBJECT (self,
1365             "Pushing subtitle accumulate newsegment event: %" GST_PTR_FORMAT,
1366             event1->structure);
1367         GST_DEBUG_OBJECT (self,
1368             "Pushing subtitle update newsegment event: %" GST_PTR_FORMAT,
1369             event2->structure);
1370         gst_pad_send_event (sink, event1);
1371         gst_pad_send_event (sink, event2);
1372         gst_object_unref (sink);
1373       }
1374
1375       /* Set the sink ghostpad targets */
1376       if (self->pre_colorspace) {
1377         sink = gst_element_get_static_pad (self->pre_colorspace, "sink");
1378         if (G_UNLIKELY (!sink)) {
1379           GST_WARNING_OBJECT (self, "Can't get sink pad from " COLORSPACE);
1380           continue;
1381         }
1382       } else {
1383         sink = _get_video_pad (element);
1384         if (G_UNLIKELY (!sink)) {
1385           GST_WARNING_OBJECT (self, "Can't get sink pad from %" GST_PTR_FORMAT,
1386               element);
1387           continue;
1388         }
1389       }
1390
1391       if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
1392                   (self->video_sinkpad), sink))) {
1393         GST_WARNING_OBJECT (self, "Can't set video sinkpad target");
1394         gst_object_unref (sink);
1395         continue;
1396       }
1397       gst_object_unref (sink);
1398
1399       sink = _get_sub_pad (element);
1400       if (G_UNLIKELY (!sink)) {
1401         GST_WARNING_OBJECT (self, "Failed to get subpad");
1402         continue;
1403       }
1404
1405       if (G_UNLIKELY (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST
1406                   (self->subtitle_sinkpad), sink))) {
1407         GST_WARNING_OBJECT (self, "Failed to set subtitle sink target");
1408         gst_object_unref (sink);
1409         continue;
1410       }
1411       gst_object_unref (sink);
1412     }
1413
1414     break;
1415   }
1416
1417   if (G_UNLIKELY (l == NULL)) {
1418     GST_ELEMENT_WARNING (self, CORE, FAILED, (NULL),
1419         ("Failed to find any usable factories"));
1420     self->subtitle_error = TRUE;
1421     _setup_passthrough (self);
1422     do_async_done (self);
1423   } else {
1424     GST_DEBUG_OBJECT (self, "Everything worked, unblocking pads");
1425     gst_pad_set_blocked_async_full (self->video_block_pad, FALSE,
1426         _pad_blocked_cb, self, NULL);
1427     gst_pad_set_blocked_async_full (self->subtitle_block_pad, FALSE,
1428         _pad_blocked_cb, self, NULL);
1429     do_async_done (self);
1430   }
1431
1432 out:
1433   if (factories)
1434     gst_plugin_feature_list_free (factories);
1435   GST_SUBTITLE_OVERLAY_UNLOCK (self);
1436 }
1437
1438 static GstStateChangeReturn
1439 gst_subtitle_overlay_change_state (GstElement * element,
1440     GstStateChange transition)
1441 {
1442   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (element);
1443   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1444
1445   switch (transition) {
1446     case GST_STATE_CHANGE_NULL_TO_READY:
1447       GST_DEBUG_OBJECT (self, "State change NULL->READY");
1448       g_mutex_lock (self->factories_lock);
1449       if (G_UNLIKELY (!gst_subtitle_overlay_update_factory_list (self))) {
1450         g_mutex_unlock (self->factories_lock);
1451         return GST_STATE_CHANGE_FAILURE;
1452       }
1453       g_mutex_unlock (self->factories_lock);
1454
1455       GST_SUBTITLE_OVERLAY_LOCK (self);
1456       /* Set the internal pads to blocking */
1457       gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
1458           _pad_blocked_cb, self, NULL);
1459       gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
1460           _pad_blocked_cb, self, NULL);
1461       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1462       break;
1463     case GST_STATE_CHANGE_READY_TO_PAUSED:
1464       GST_DEBUG_OBJECT (self, "State change READY->PAUSED");
1465       gst_segment_init (&self->video_segment, GST_FORMAT_UNDEFINED);
1466       gst_segment_init (&self->subtitle_segment, GST_FORMAT_UNDEFINED);
1467
1468       self->fps_n = self->fps_d = 0;
1469
1470       self->subtitle_flush = FALSE;
1471       self->subtitle_error = FALSE;
1472
1473       self->downstream_chain_error = FALSE;
1474
1475       do_async_start (self);
1476       ret = GST_STATE_CHANGE_ASYNC;
1477
1478       break;
1479     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1480       GST_DEBUG_OBJECT (self, "State change PAUSED->PLAYING");
1481     default:
1482       break;
1483   }
1484
1485   {
1486     GstStateChangeReturn bret;
1487
1488     bret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1489     GST_DEBUG_OBJECT (self, "Base class state changed returned: %d", bret);
1490     if (G_UNLIKELY (bret == GST_STATE_CHANGE_FAILURE))
1491       return ret;
1492     else if (bret == GST_STATE_CHANGE_ASYNC)
1493       ret = bret;
1494     else if (G_UNLIKELY (bret == GST_STATE_CHANGE_NO_PREROLL)) {
1495       do_async_done (self);
1496       ret = bret;
1497     }
1498   }
1499
1500   switch (transition) {
1501     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1502       GST_DEBUG_OBJECT (self, "State change PLAYING->PAUSED");
1503       break;
1504     case GST_STATE_CHANGE_PAUSED_TO_READY:
1505       GST_DEBUG_OBJECT (self, "State change PAUSED->READY");
1506
1507       /* Set the pads back to blocking state */
1508       GST_SUBTITLE_OVERLAY_LOCK (self);
1509       gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
1510           _pad_blocked_cb, self, NULL);
1511       gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
1512           _pad_blocked_cb, self, NULL);
1513       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1514
1515       do_async_done (self);
1516
1517       break;
1518     case GST_STATE_CHANGE_READY_TO_NULL:{
1519       GstPad *pad;
1520
1521       GST_DEBUG_OBJECT (self, "State change READY->NULL");
1522
1523       GST_SUBTITLE_OVERLAY_LOCK (self);
1524       gst_caps_replace (&self->subcaps, NULL);
1525
1526       /* Unlink ghost pads */
1527       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->srcpad), NULL);
1528       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->video_sinkpad), NULL);
1529       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->subtitle_sinkpad),
1530           NULL);
1531
1532       /* Unblock pads */
1533       if (self->video_block_pad) {
1534         pad = self->video_block_pad;
1535         gst_pad_set_blocked_async_full (pad, FALSE, _pad_blocked_cb,
1536             self, NULL);
1537       }
1538
1539       if (self->subtitle_block_pad) {
1540         pad = self->subtitle_block_pad;
1541         gst_pad_set_blocked_async_full (pad, FALSE, _pad_blocked_cb,
1542             self, NULL);
1543       }
1544
1545       /* Remove elements */
1546       self->silent_property = NULL;
1547       _remove_element (self, &self->post_colorspace);
1548       _remove_element (self, &self->overlay);
1549       _remove_element (self, &self->parser);
1550       _remove_element (self, &self->renderer);
1551       _remove_element (self, &self->pre_colorspace);
1552       _remove_element (self, &self->passthrough_identity);
1553       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1554
1555       break;
1556     }
1557     default:
1558       break;
1559   }
1560
1561   return ret;
1562 }
1563
1564 static void
1565 gst_subtitle_overlay_handle_message (GstBin * bin, GstMessage * message)
1566 {
1567   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY_CAST (bin);
1568
1569   if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) {
1570     GstObject *src = GST_MESSAGE_SRC (message);
1571
1572     /* Convert error messages from the subtitle pipeline to
1573      * warnings and switch to passthrough mode */
1574     if (src && (
1575             (self->overlay
1576                 && gst_object_has_ancestor (src,
1577                     GST_OBJECT_CAST (self->overlay))) || (self->parser
1578                 && gst_object_has_ancestor (src,
1579                     GST_OBJECT_CAST (self->parser))) || (self->renderer
1580                 && gst_object_has_ancestor (src,
1581                     GST_OBJECT_CAST (self->renderer))))) {
1582       GError *err = NULL;
1583       gchar *debug = NULL;
1584       GstMessage *wmsg;
1585
1586       gst_message_parse_error (message, &err, &debug);
1587       GST_DEBUG_OBJECT (self,
1588           "Got error message from subtitle element %s: %s (%s)",
1589           GST_MESSAGE_SRC_NAME (message), GST_STR_NULL (err->message),
1590           GST_STR_NULL (debug));
1591
1592       wmsg = gst_message_new_warning (src, err, debug);
1593       gst_message_unref (message);
1594       g_error_free (err);
1595       g_free (debug);
1596       message = wmsg;
1597
1598       GST_SUBTITLE_OVERLAY_LOCK (self);
1599       self->subtitle_error = TRUE;
1600
1601       gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
1602           _pad_blocked_cb, self, NULL);
1603
1604       gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
1605           _pad_blocked_cb, self, NULL);
1606       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1607     }
1608   }
1609
1610   GST_BIN_CLASS (parent_class)->handle_message (bin, message);
1611 }
1612
1613 static void
1614 gst_subtitle_overlay_get_property (GObject * object, guint prop_id,
1615     GValue * value, GParamSpec * pspec)
1616 {
1617   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY_CAST (object);
1618
1619   switch (prop_id) {
1620     case PROP_SILENT:
1621       g_value_set_boolean (value, self->silent);
1622       break;
1623     case PROP_FONT_DESC:
1624       GST_SUBTITLE_OVERLAY_LOCK (self);
1625       g_value_set_string (value, self->font_desc);
1626       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1627       break;
1628     case PROP_SUBTITLE_ENCODING:
1629       GST_SUBTITLE_OVERLAY_LOCK (self);
1630       g_value_set_string (value, self->encoding);
1631       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1632       break;
1633     default:
1634       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1635       break;
1636   }
1637 }
1638
1639 static void
1640 gst_subtitle_overlay_set_property (GObject * object, guint prop_id,
1641     const GValue * value, GParamSpec * pspec)
1642 {
1643   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY_CAST (object);
1644
1645   switch (prop_id) {
1646     case PROP_SILENT:
1647       GST_SUBTITLE_OVERLAY_LOCK (self);
1648       self->silent = g_value_get_boolean (value);
1649       if (self->silent_property) {
1650         gboolean silent = self->silent;
1651
1652         if (self->silent_property_invert)
1653           silent = !silent;
1654
1655         if (self->overlay)
1656           g_object_set (self->overlay, self->silent_property, silent, NULL);
1657         else if (self->renderer)
1658           g_object_set (self->renderer, self->silent_property, silent, NULL);
1659       } else {
1660         gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
1661             _pad_blocked_cb, self, NULL);
1662
1663         gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
1664             _pad_blocked_cb, self, NULL);
1665       }
1666       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1667       break;
1668     case PROP_FONT_DESC:
1669       GST_SUBTITLE_OVERLAY_LOCK (self);
1670       g_free (self->font_desc);
1671       self->font_desc = g_value_dup_string (value);
1672       if (self->overlay)
1673         g_object_set (self->overlay, "font-desc", self->font_desc, NULL);
1674       else if (self->renderer && _has_font_desc_property (self->renderer))
1675         g_object_set (self->renderer, "font-desc", self->font_desc, NULL);
1676       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1677       break;
1678     case PROP_SUBTITLE_ENCODING:
1679       GST_SUBTITLE_OVERLAY_LOCK (self);
1680       g_free (self->encoding);
1681       self->encoding = g_value_dup_string (value);
1682       if (self->renderer && _has_subtitle_encoding_property (self->renderer))
1683         g_object_set (self->renderer, "subtitle-encoding", self->encoding,
1684             NULL);
1685       if (self->parser && _has_subtitle_encoding_property (self->parser))
1686         g_object_set (self->parser, "subtitle-encoding", self->encoding, NULL);
1687       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1688       break;
1689     default:
1690       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1691       break;
1692   }
1693 }
1694
1695 static void
1696 gst_subtitle_overlay_base_init (gpointer g_class)
1697 {
1698   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
1699
1700   gst_element_class_add_static_pad_template (gstelement_class, &srctemplate);
1701
1702   gst_element_class_add_static_pad_template (gstelement_class,
1703       &video_sinktemplate);
1704   gst_element_class_add_static_pad_template (gstelement_class,
1705       &subtitle_sinktemplate);
1706
1707   gst_element_class_set_details_simple (gstelement_class, "Subtitle Overlay",
1708       "Video/Overlay/Subtitle",
1709       "Overlays a video stream with subtitles",
1710       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
1711 }
1712
1713 static void
1714 gst_subtitle_overlay_class_init (GstSubtitleOverlayClass * klass)
1715 {
1716   GObjectClass *gobject_class = (GObjectClass *) klass;
1717   GstElementClass *element_class = (GstElementClass *) klass;
1718   GstBinClass *bin_class = (GstBinClass *) klass;
1719
1720   gobject_class->finalize = gst_subtitle_overlay_finalize;
1721   gobject_class->set_property = gst_subtitle_overlay_set_property;
1722   gobject_class->get_property = gst_subtitle_overlay_get_property;
1723
1724   g_object_class_install_property (gobject_class, PROP_SILENT,
1725       g_param_spec_boolean ("silent",
1726           "Silent",
1727           "Whether to show subtitles", FALSE,
1728           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1729
1730   g_object_class_install_property (gobject_class, PROP_FONT_DESC,
1731       g_param_spec_string ("font-desc",
1732           "Subtitle font description",
1733           "Pango font description of font "
1734           "to be used for subtitle rendering", NULL,
1735           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1736
1737   g_object_class_install_property (gobject_class, PROP_SUBTITLE_ENCODING,
1738       g_param_spec_string ("subtitle-encoding", "subtitle encoding",
1739           "Encoding to assume if input subtitles are not in UTF-8 encoding. "
1740           "If not set, the GST_SUBTITLE_ENCODING environment variable will "
1741           "be checked for an encoding to use. If that is not set either, "
1742           "ISO-8859-15 will be assumed.", NULL,
1743           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1744
1745   element_class->change_state =
1746       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_change_state);
1747
1748   bin_class->handle_message =
1749       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_handle_message);
1750 }
1751
1752 static GstFlowReturn
1753 gst_subtitle_overlay_src_proxy_chain (GstPad * proxypad, GstBuffer * buffer)
1754 {
1755   GstPad *ghostpad;
1756   GstSubtitleOverlay *self;
1757   GstFlowReturn ret;
1758
1759   ghostpad = GST_PAD_CAST (gst_pad_get_parent (proxypad));
1760   if (G_UNLIKELY (!ghostpad)) {
1761     gst_buffer_unref (buffer);
1762     return GST_FLOW_ERROR;
1763   }
1764   self = GST_SUBTITLE_OVERLAY_CAST (gst_pad_get_parent (ghostpad));
1765   if (G_UNLIKELY (!self || self->srcpad != ghostpad)) {
1766     gst_buffer_unref (buffer);
1767     gst_object_unref (ghostpad);
1768     return GST_FLOW_ERROR;
1769   }
1770
1771   ret = gst_proxy_pad_chain_default (proxypad, buffer);
1772
1773   if (IS_VIDEO_CHAIN_IGNORE_ERROR (ret)) {
1774     GST_ERROR_OBJECT (self, "Downstream chain error: %s",
1775         gst_flow_get_name (ret));
1776     self->downstream_chain_error = TRUE;
1777   }
1778
1779   gst_object_unref (self);
1780   gst_object_unref (ghostpad);
1781
1782   return ret;
1783 }
1784
1785 static gboolean
1786 gst_subtitle_overlay_src_proxy_event (GstPad * proxypad, GstEvent * event)
1787 {
1788   GstPad *ghostpad = NULL;
1789   GstSubtitleOverlay *self = NULL;
1790   gboolean ret = FALSE;
1791   const GstStructure *s;
1792
1793   ghostpad = GST_PAD_CAST (gst_pad_get_parent (proxypad));
1794   if (G_UNLIKELY (!ghostpad))
1795     goto out;
1796   self = GST_SUBTITLE_OVERLAY_CAST (gst_pad_get_parent (ghostpad));
1797   if (G_UNLIKELY (!self || self->srcpad != ghostpad))
1798     goto out;
1799
1800   s = gst_event_get_structure (event);
1801   if (s && gst_structure_id_has_field (s, _subtitle_overlay_event_marker_id)) {
1802     GST_DEBUG_OBJECT (ghostpad, "Dropping event with marker: %" GST_PTR_FORMAT,
1803         event->structure);
1804     gst_event_unref (event);
1805     event = NULL;
1806     ret = TRUE;
1807   } else {
1808     ret = gst_proxy_pad_event_default (proxypad, event);
1809     event = NULL;
1810   }
1811
1812 out:
1813   if (event)
1814     gst_event_unref (event);
1815   if (self)
1816     gst_object_unref (self);
1817   if (ghostpad)
1818     gst_object_unref (ghostpad);
1819   return ret;
1820 }
1821
1822 static gboolean
1823 gst_subtitle_overlay_video_sink_setcaps (GstPad * pad, GstCaps * caps)
1824 {
1825   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (gst_pad_get_parent (pad));
1826   GstPad *target;
1827   gboolean ret = TRUE;
1828   gint fps_n, fps_d;
1829
1830   GST_DEBUG_OBJECT (pad, "Setting caps: %" GST_PTR_FORMAT, caps);
1831
1832   target = gst_ghost_pad_get_target (GST_GHOST_PAD_CAST (self->video_sinkpad));
1833
1834   GST_SUBTITLE_OVERLAY_LOCK (self);
1835
1836   if (!target || !gst_pad_accept_caps (target, caps)) {
1837     GST_DEBUG_OBJECT (pad, "Target did not accept caps -- reconfiguring");
1838
1839     gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
1840         _pad_blocked_cb, self, NULL);
1841
1842     gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
1843         _pad_blocked_cb, self, NULL);
1844   }
1845
1846   if (!gst_video_parse_caps_framerate (caps, &fps_n, &fps_d)) {
1847     GST_ERROR_OBJECT (pad, "Failed to parse framerate from caps");
1848     ret = FALSE;
1849     GST_SUBTITLE_OVERLAY_UNLOCK (self);
1850     goto out;
1851   }
1852
1853   if (self->fps_n != fps_n || self->fps_d != fps_d) {
1854     GST_DEBUG_OBJECT (self, "New video fps: %d/%d", fps_n, fps_d);
1855     self->fps_n = fps_n;
1856     self->fps_d = fps_d;
1857     gst_subtitle_overlay_set_fps (self);
1858   }
1859   GST_SUBTITLE_OVERLAY_UNLOCK (self);
1860
1861   ret = gst_ghost_pad_setcaps_default (pad, caps);
1862
1863 out:
1864   if (target)
1865     gst_object_unref (target);
1866   gst_object_unref (self);
1867   return ret;
1868 }
1869
1870 static gboolean
1871 gst_subtitle_overlay_video_sink_event (GstPad * pad, GstEvent * event)
1872 {
1873   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (gst_pad_get_parent (pad));
1874   gboolean ret;
1875
1876   if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
1877     GST_DEBUG_OBJECT (pad,
1878         "Resetting video segment because of flush-stop event");
1879     gst_segment_init (&self->video_segment, GST_FORMAT_UNDEFINED);
1880     self->fps_n = self->fps_d = 0;
1881   }
1882
1883   ret = gst_proxy_pad_event_default (pad, gst_event_ref (event));
1884
1885   if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT) {
1886     gboolean update;
1887     gdouble rate, applied_rate;
1888     GstFormat format;
1889     gint64 start, stop, position;
1890
1891     GST_DEBUG_OBJECT (pad, "Newsegment event: %" GST_PTR_FORMAT,
1892         event->structure);
1893     gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,
1894         &format, &start, &stop, &position);
1895
1896     if (format != GST_FORMAT_TIME) {
1897       GST_ERROR_OBJECT (pad, "Newsegment event in non-time format: %s",
1898           gst_format_get_name (format));
1899       gst_event_unref (event);
1900       gst_object_unref (self);
1901       return FALSE;
1902     }
1903
1904     GST_DEBUG_OBJECT (pad, "Old video segment: %" GST_SEGMENT_FORMAT,
1905         &self->video_segment);
1906     gst_segment_set_newsegment_full (&self->video_segment, update, rate,
1907         applied_rate, format, start, stop, position);
1908     GST_DEBUG_OBJECT (pad, "New video segment: %" GST_SEGMENT_FORMAT,
1909         &self->video_segment);
1910   }
1911
1912   gst_event_unref (event);
1913   gst_object_unref (self);
1914   return ret;
1915 }
1916
1917 static GstFlowReturn
1918 gst_subtitle_overlay_video_sink_chain (GstPad * pad, GstBuffer * buffer)
1919 {
1920   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (GST_PAD_PARENT (pad));
1921   GstFlowReturn ret = gst_proxy_pad_chain_default (pad, buffer);
1922
1923   if (G_UNLIKELY (self->downstream_chain_error) || self->passthrough_identity) {
1924     return ret;
1925   } else if (IS_VIDEO_CHAIN_IGNORE_ERROR (ret)) {
1926     GST_DEBUG_OBJECT (self, "Subtitle renderer produced chain error: %s",
1927         gst_flow_get_name (ret));
1928     GST_SUBTITLE_OVERLAY_LOCK (self);
1929     self->subtitle_error = TRUE;
1930     gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
1931         _pad_blocked_cb, self, NULL);
1932
1933     gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
1934         _pad_blocked_cb, self, NULL);
1935     GST_SUBTITLE_OVERLAY_UNLOCK (self);
1936
1937     return GST_FLOW_OK;
1938   }
1939
1940   return ret;
1941 }
1942
1943 static GstFlowReturn
1944 gst_subtitle_overlay_subtitle_sink_chain (GstPad * pad, GstBuffer * buffer)
1945 {
1946   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (GST_PAD_PARENT (pad));
1947
1948   if (self->subtitle_error) {
1949     gst_buffer_unref (buffer);
1950     return GST_FLOW_OK;
1951   } else {
1952     GstFlowReturn ret = gst_proxy_pad_chain_default (pad, buffer);
1953
1954     if (IS_SUBTITLE_CHAIN_IGNORE_ERROR (ret)) {
1955       GST_DEBUG_OBJECT (self, "Subtitle chain error: %s",
1956           gst_flow_get_name (ret));
1957       GST_SUBTITLE_OVERLAY_LOCK (self);
1958       self->subtitle_error = TRUE;
1959       gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
1960           _pad_blocked_cb, self, NULL);
1961
1962       gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
1963           _pad_blocked_cb, self, NULL);
1964       GST_SUBTITLE_OVERLAY_UNLOCK (self);
1965
1966       return GST_FLOW_OK;
1967     }
1968
1969     return ret;
1970   }
1971 }
1972
1973 static GstCaps *
1974 gst_subtitle_overlay_subtitle_sink_getcaps (GstPad * pad)
1975 {
1976   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (gst_pad_get_parent (pad));
1977   GstCaps *ret;
1978
1979   g_mutex_lock (self->factories_lock);
1980   if (G_UNLIKELY (!gst_subtitle_overlay_update_factory_list (self)))
1981     ret = GST_CAPS_NONE;
1982   else
1983     ret = gst_caps_ref (self->factory_caps);
1984   g_mutex_unlock (self->factories_lock);
1985
1986   GST_DEBUG_OBJECT (pad, "Returning subtitle caps %" GST_PTR_FORMAT, ret);
1987
1988   gst_object_unref (self);
1989
1990   return ret;
1991 }
1992
1993 static gboolean
1994 gst_subtitle_overlay_subtitle_sink_acceptcaps (GstPad * pad, GstCaps * caps)
1995 {
1996   GstCaps *othercaps = gst_subtitle_overlay_subtitle_sink_getcaps (pad);
1997   gboolean ret = gst_caps_is_subset (caps, othercaps);
1998
1999   gst_caps_unref (othercaps);
2000
2001   return ret;
2002 }
2003
2004 static gboolean
2005 gst_subtitle_overlay_subtitle_sink_setcaps (GstPad * pad, GstCaps * caps)
2006 {
2007   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (gst_pad_get_parent (pad));
2008   gboolean ret = TRUE;
2009   GstPad *target = NULL;;
2010
2011   GST_DEBUG_OBJECT (pad, "Setting caps: %" GST_PTR_FORMAT, caps);
2012
2013   target =
2014       gst_ghost_pad_get_target (GST_GHOST_PAD_CAST (self->subtitle_sinkpad));
2015
2016   GST_SUBTITLE_OVERLAY_LOCK (self);
2017   gst_caps_replace (&self->subcaps, caps);
2018
2019   if (target && gst_pad_accept_caps (target, caps)) {
2020     GST_DEBUG_OBJECT (pad, "Target accepts caps");
2021     ret = gst_ghost_pad_setcaps_default (pad, caps);
2022     GST_SUBTITLE_OVERLAY_UNLOCK (self);
2023     goto out;
2024   }
2025
2026   GST_DEBUG_OBJECT (pad, "Target did not accept caps");
2027
2028   self->subtitle_error = FALSE;
2029
2030   gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
2031       _pad_blocked_cb, self, NULL);
2032
2033   gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
2034       _pad_blocked_cb, self, NULL);
2035   GST_SUBTITLE_OVERLAY_UNLOCK (self);
2036
2037 out:
2038   if (target)
2039     gst_object_unref (target);
2040   gst_object_unref (self);
2041   return ret;
2042 }
2043
2044 static GstPadLinkReturn
2045 gst_subtitle_overlay_subtitle_sink_link (GstPad * pad, GstPad * peer)
2046 {
2047   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (gst_pad_get_parent (pad));
2048   GstPadLinkReturn ret;
2049   GstCaps *caps;
2050
2051   GST_DEBUG_OBJECT (pad, "Linking pad to peer %" GST_PTR_FORMAT, peer);
2052
2053   caps = gst_pad_get_negotiated_caps (peer);
2054   if (!caps) {
2055     caps = gst_pad_get_caps_reffed (peer);
2056     if (!gst_caps_is_fixed (caps)) {
2057       gst_caps_unref (caps);
2058       caps = NULL;
2059     }
2060   }
2061
2062   if (caps) {
2063     GST_SUBTITLE_OVERLAY_LOCK (self);
2064     GST_DEBUG_OBJECT (pad, "Have fixed peer caps: %" GST_PTR_FORMAT, caps);
2065     gst_caps_replace (&self->subcaps, caps);
2066
2067     self->subtitle_error = FALSE;
2068
2069     gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
2070         _pad_blocked_cb, self, NULL);
2071
2072     gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
2073         _pad_blocked_cb, self, NULL);
2074     GST_SUBTITLE_OVERLAY_UNLOCK (self);
2075     gst_caps_unref (caps);
2076   }
2077
2078   ret = gst_ghost_pad_link_default (pad, peer);
2079
2080   gst_object_unref (self);
2081   return ret;
2082 }
2083
2084 static void
2085 gst_subtitle_overlay_subtitle_sink_unlink (GstPad * pad)
2086 {
2087   GstSubtitleOverlay *self =
2088       GST_SUBTITLE_OVERLAY (gst_object_ref (GST_PAD_PARENT (pad)));
2089
2090   /* FIXME: Can't use gst_pad_get_parent() here because this is called with
2091    * the object lock from state changes
2092    */
2093
2094   GST_DEBUG_OBJECT (pad, "Pad unlinking");
2095   gst_caps_replace (&self->subcaps, NULL);
2096
2097   gst_ghost_pad_unlink_default (pad);
2098
2099   GST_SUBTITLE_OVERLAY_LOCK (self);
2100   self->subtitle_error = FALSE;
2101
2102   if (self->subtitle_block_pad)
2103     gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
2104         _pad_blocked_cb, self, NULL);
2105
2106   if (self->video_block_pad)
2107     gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
2108         _pad_blocked_cb, self, NULL);
2109   GST_SUBTITLE_OVERLAY_UNLOCK (self);
2110
2111   gst_object_unref (self);
2112 }
2113
2114 static gboolean
2115 gst_subtitle_overlay_subtitle_sink_event (GstPad * pad, GstEvent * event)
2116 {
2117   GstSubtitleOverlay *self = GST_SUBTITLE_OVERLAY (gst_pad_get_parent (pad));
2118   gboolean ret;
2119   GstFormat format;
2120
2121   if (GST_EVENT_TYPE (event) == GST_EVENT_CUSTOM_DOWNSTREAM_OOB &&
2122       event->structure
2123       && strcmp (gst_structure_get_name (event->structure),
2124           "subtitleoverlay-flush-subtitle") == 0) {
2125     GST_DEBUG_OBJECT (pad, "Custom subtitle flush event");
2126     GST_SUBTITLE_OVERLAY_LOCK (self);
2127     self->subtitle_flush = TRUE;
2128     self->subtitle_error = FALSE;
2129     if (self->subtitle_block_pad)
2130       gst_pad_set_blocked_async_full (self->subtitle_block_pad, TRUE,
2131           _pad_blocked_cb, self, NULL);
2132     if (self->video_block_pad)
2133       gst_pad_set_blocked_async_full (self->video_block_pad, TRUE,
2134           _pad_blocked_cb, self, NULL);
2135     GST_SUBTITLE_OVERLAY_UNLOCK (self);
2136
2137     gst_event_unref (event);
2138     event = NULL;
2139     ret = TRUE;
2140     goto out;
2141   } else if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT) {
2142     gst_event_parse_new_segment_full (event, NULL, NULL, NULL,
2143         &format, NULL, NULL, NULL);
2144     if (self->subtitle_segment.format != GST_FORMAT_UNDEFINED &&
2145         self->subtitle_segment.format != format) {
2146       GST_DEBUG_OBJECT (pad, "Subtitle segment format changed: %s -> %s",
2147           gst_format_get_name (self->subtitle_segment.format),
2148           gst_format_get_name (format));
2149       gst_segment_init (&self->subtitle_segment, GST_FORMAT_UNDEFINED);
2150     }
2151   }
2152
2153   switch (GST_EVENT_TYPE (event)) {
2154     case GST_EVENT_FLUSH_STOP:
2155       GST_DEBUG_OBJECT (pad,
2156           "Resetting subtitle segment because of flush-stop");
2157       gst_segment_init (&self->subtitle_segment, GST_FORMAT_UNDEFINED);
2158       /* fall through */
2159     case GST_EVENT_FLUSH_START:
2160     case GST_EVENT_NEWSEGMENT:
2161     case GST_EVENT_EOS:
2162       /* Add our event marker to make sure no events from here go ever outside
2163        * the element, they're only interesting for our internal elements */
2164       event =
2165           GST_EVENT_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST
2166               (event)));
2167       if (!event->structure) {
2168         event->structure =
2169             gst_structure_id_empty_new (_subtitle_overlay_event_marker_id);
2170         gst_structure_set_parent_refcount (event->structure,
2171             &event->mini_object.refcount);
2172       }
2173       gst_structure_id_set (event->structure, _subtitle_overlay_event_marker_id,
2174           G_TYPE_BOOLEAN, TRUE, NULL);
2175       break;
2176     default:
2177       break;
2178   }
2179
2180   ret = gst_proxy_pad_event_default (pad, gst_event_ref (event));
2181
2182   if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT) {
2183     gboolean update;
2184     gdouble rate, applied_rate;
2185     gint64 start, stop, position;
2186
2187     GST_DEBUG_OBJECT (pad, "Newsegment event: %" GST_PTR_FORMAT,
2188         event->structure);
2189     gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,
2190         &format, &start, &stop, &position);
2191
2192     GST_DEBUG_OBJECT (pad, "Old subtitle segment: %" GST_SEGMENT_FORMAT,
2193         &self->subtitle_segment);
2194     if (self->subtitle_segment.format != format) {
2195       GST_DEBUG_OBJECT (pad, "Subtitle segment format changed: %s -> %s",
2196           gst_format_get_name (self->subtitle_segment.format),
2197           gst_format_get_name (format));
2198       gst_segment_init (&self->subtitle_segment, format);
2199     }
2200
2201     gst_segment_set_newsegment_full (&self->subtitle_segment, update, rate,
2202         applied_rate, format, start, stop, position);
2203     GST_DEBUG_OBJECT (pad, "New subtitle segment: %" GST_SEGMENT_FORMAT,
2204         &self->subtitle_segment);
2205   }
2206   gst_event_unref (event);
2207
2208 out:
2209   gst_object_unref (self);
2210   return ret;
2211 }
2212
2213 static void
2214 gst_subtitle_overlay_init (GstSubtitleOverlay * self,
2215     GstSubtitleOverlayClass * klass)
2216 {
2217   GstPadTemplate *templ;
2218   GstPad *proxypad = NULL;
2219
2220   self->lock = g_mutex_new ();
2221   self->factories_lock = g_mutex_new ();
2222
2223   templ = gst_static_pad_template_get (&srctemplate);
2224   self->srcpad = gst_ghost_pad_new_no_target_from_template ("src", templ);
2225   gst_object_unref (templ);
2226
2227   proxypad =
2228       GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (self->srcpad)));
2229   gst_pad_set_event_function (proxypad,
2230       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_src_proxy_event));
2231   gst_pad_set_chain_function (proxypad,
2232       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_src_proxy_chain));
2233   gst_object_unref (proxypad);
2234
2235   gst_element_add_pad (GST_ELEMENT_CAST (self), self->srcpad);
2236
2237   templ = gst_static_pad_template_get (&video_sinktemplate);
2238   self->video_sinkpad =
2239       gst_ghost_pad_new_no_target_from_template ("video_sink", templ);
2240   gst_object_unref (templ);
2241   gst_pad_set_event_function (self->video_sinkpad,
2242       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_video_sink_event));
2243   gst_pad_set_setcaps_function (self->video_sinkpad,
2244       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_video_sink_setcaps));
2245   gst_pad_set_chain_function (self->video_sinkpad,
2246       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_video_sink_chain));
2247
2248   proxypad =
2249       GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
2250           (self->video_sinkpad)));
2251   self->video_block_pad = proxypad;
2252   gst_object_unref (proxypad);
2253   gst_element_add_pad (GST_ELEMENT_CAST (self), self->video_sinkpad);
2254
2255   templ = gst_static_pad_template_get (&subtitle_sinktemplate);
2256   self->subtitle_sinkpad =
2257       gst_ghost_pad_new_no_target_from_template ("subtitle_sink", templ);
2258   gst_object_unref (templ);
2259   gst_pad_set_link_function (self->subtitle_sinkpad,
2260       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_subtitle_sink_link));
2261   gst_pad_set_unlink_function (self->subtitle_sinkpad,
2262       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_subtitle_sink_unlink));
2263   gst_pad_set_event_function (self->subtitle_sinkpad,
2264       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_subtitle_sink_event));
2265   gst_pad_set_setcaps_function (self->subtitle_sinkpad,
2266       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_subtitle_sink_setcaps));
2267   gst_pad_set_chain_function (self->subtitle_sinkpad,
2268       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_subtitle_sink_chain));
2269   gst_pad_set_getcaps_function (self->subtitle_sinkpad,
2270       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_subtitle_sink_getcaps));
2271   gst_pad_set_acceptcaps_function (self->subtitle_sinkpad,
2272       GST_DEBUG_FUNCPTR (gst_subtitle_overlay_subtitle_sink_acceptcaps));
2273   gst_pad_set_bufferalloc_function (self->subtitle_sinkpad, NULL);
2274
2275   proxypad =
2276       GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
2277           (self->subtitle_sinkpad)));
2278   self->subtitle_block_pad = proxypad;
2279   gst_object_unref (proxypad);
2280
2281   gst_element_add_pad (GST_ELEMENT_CAST (self), self->subtitle_sinkpad);
2282
2283   self->fps_n = 0;
2284   self->fps_d = 0;
2285 }
2286
2287 gboolean
2288 gst_subtitle_overlay_plugin_init (GstPlugin * plugin)
2289 {
2290   GST_DEBUG_CATEGORY_INIT (subtitle_overlay_debug, "subtitleoverlay", 0,
2291       "Subtitle Overlay");
2292
2293   _subtitle_overlay_event_marker_id =
2294       g_quark_from_static_string ("gst-subtitle-overlay-event-marker");
2295
2296   return gst_element_register (plugin, "subtitleoverlay", GST_RANK_NONE,
2297       GST_TYPE_SUBTITLE_OVERLAY);
2298 }