ext/pango/gstbasetextoverlay.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) <2003> David Schleef <ds@schleef.org>
   4  * Copyright (C) <2006> Julien Moutte <julien@moutte.net>
   5  * Copyright (C) <2006> Zeeshan Ali <zeeshan.ali@nokia.com>
   6  * Copyright (C) <2006-2008> Tim-Philipp Müller <tim centricular net>
   7  * Copyright (C) <2009> Young-Ho Cha <ganadist@gmail.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 /**
  26  * SECTION:element-textoverlay
  27  * @see_also: #GstTextRender, #GstClockOverlay, #GstTimeOverlay, #GstSubParse
  28  *
  29  * This plugin renders text on top of a video stream. This can be either
  30  * static text or text from buffers received on the text sink pad, e.g.
  31  * as produced by the subparse element. If the text sink pad is not linked,
  32  * the text set via the "text" property will be rendered. If the text sink
  33  * pad is linked, text will be rendered as it is received on that pad,
  34  * honouring and matching the buffer timestamps of both input streams.
  35  *
  36  * The text can contain newline characters and text wrapping is enabled by
  37  * default.
  38  *
  39  * <refsect2>
  40  * <title>Example launch lines</title>
  41  * |[
  42  * gst-launch -v videotestsrc ! textoverlay text="Room A" valign=top halign=left ! xvimagesink
  43  * ]| Here is a simple pipeline that displays a static text in the top left
  44  * corner of the video picture
  45  * |[
  46  * gst-launch -v filesrc location=subtitles.srt ! subparse ! txt.   videotestsrc ! timeoverlay ! textoverlay name=txt shaded-background=yes ! xvimagesink
  47  * ]| Here is another pipeline that displays subtitles from an .srt subtitle
  48  * file, centered at the bottom of the picture and with a rectangular shading
  49  * around the text in the background:
  50  * <para>
  51  * If you do not have such a subtitle file, create one looking like this
  52  * in a text editor:
  53  * |[
  54  * 1
  55  * 00:00:03,000 --> 00:00:05,000
  56  * Hello? (3-5s)
  57  *
  58  * 2
  59  * 00:00:08,000 --> 00:00:13,000
  60  * Yes, this is a subtitle. Don&apos;t
  61  * you like it? (8-13s)
  62  *
  63  * 3
  64  * 00:00:18,826 --> 00:01:02,886
  65  * Uh? What are you talking about?
  66  * I don&apos;t understand  (18-62s)
  67  * ]|
  68  * </para>
  69  * </refsect2>
  70  */
  71
  72 /* FIXME: alloc segment as part of instance struct */
  73
  74 #ifdef HAVE_CONFIG_H
  75 #include <config.h>
  76 #endif
  77
  78 #include <gst/video/video.h>
  79 #include <gst/video/gstvideometa.h>
  80
  81 #include "gstbasetextoverlay.h"
  82 #include "gsttextoverlay.h"
  83 #include "gsttimeoverlay.h"
  84 #include "gstclockoverlay.h"
  85 #include "gsttextrender.h"
  86 #include <string.h>
  87
  88 /* FIXME:
  89  *  - use proper strides and offset for I420
  90  *  - if text is wider than the video picture, it does not get
  91  *    clipped properly during blitting (if wrapping is disabled)
  92  *  - make 'shading_value' a property (or enum:  light/normal/dark/verydark)?
  93  */
  94
  95 GST_DEBUG_CATEGORY (pango_debug);
  96 #define GST_CAT_DEFAULT pango_debug
  97
  98 #define DEFAULT_PROP_TEXT       ""
  99 #define DEFAULT_PROP_SHADING    FALSE
 100 #define DEFAULT_PROP_VALIGNMENT GST_BASE_TEXT_OVERLAY_VALIGN_BASELINE
 101 #define DEFAULT_PROP_HALIGNMENT GST_BASE_TEXT_OVERLAY_HALIGN_CENTER
 102 #define DEFAULT_PROP_XPAD       25
 103 #define DEFAULT_PROP_YPAD       25
 104 #define DEFAULT_PROP_DELTAX     0
 105 #define DEFAULT_PROP_DELTAY     0
 106 #define DEFAULT_PROP_XPOS       0.5
 107 #define DEFAULT_PROP_YPOS       0.5
 108 #define DEFAULT_PROP_WRAP_MODE  GST_BASE_TEXT_OVERLAY_WRAP_MODE_WORD_CHAR
 109 #define DEFAULT_PROP_FONT_DESC  ""
 110 #define DEFAULT_PROP_SILENT     FALSE
 111 #define DEFAULT_PROP_LINE_ALIGNMENT GST_BASE_TEXT_OVERLAY_LINE_ALIGN_CENTER
 112 #define DEFAULT_PROP_WAIT_TEXT  TRUE
 113 #define DEFAULT_PROP_AUTO_ADJUST_SIZE TRUE
 114 #define DEFAULT_PROP_VERTICAL_RENDER  FALSE
 115 #define DEFAULT_PROP_COLOR      0xffffffff
 116 #define DEFAULT_PROP_OUTLINE_COLOR 0xff000000
 117
 118 /* make a property of me */
 119 #define DEFAULT_SHADING_VALUE    -80
 120
 121 #define MINIMUM_OUTLINE_OFFSET 1.0
 122 #define DEFAULT_SCALE_BASIS    640
 123
 124 #define COMP_Y(ret, r, g, b) \
 125 { \
 126    ret = (int) (((19595 * r) >> 16) + ((38470 * g) >> 16) + ((7471 * b) >> 16)); \
 127    ret = CLAMP (ret, 0, 255); \
 128 }
 129
 130 #define COMP_U(ret, r, g, b) \
 131 { \
 132    ret = (int) (-((11059 * r) >> 16) - ((21709 * g) >> 16) + ((32768 * b) >> 16) + 128); \
 133    ret = CLAMP (ret, 0, 255); \
 134 }
 135
 136 #define COMP_V(ret, r, g, b) \
 137 { \
 138    ret = (int) (((32768 * r) >> 16) - ((27439 * g) >> 16) - ((5329 * b) >> 16) + 128); \
 139    ret = CLAMP (ret, 0, 255); \
 140 }
 141
 142 #define BLEND(ret, alpha, v0, v1) \
 143 { \
 144         ret = (v0 * alpha + v1 * (255 - alpha)) / 255; \
 145 }
 146
 147 #define OVER(ret, alphaA, Ca, alphaB, Cb, alphaNew)     \
 148 { \
 149     gint _tmp; \
 150     _tmp = (Ca * alphaA + Cb * alphaB * (255 - alphaA) / 255) / alphaNew; \
 151     ret = CLAMP (_tmp, 0, 255); \
 152 }
 153
 154 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
 155 # define CAIRO_ARGB_A 3
 156 # define CAIRO_ARGB_R 2
 157 # define CAIRO_ARGB_G 1
 158 # define CAIRO_ARGB_B 0
 159 #else
 160 # define CAIRO_ARGB_A 0
 161 # define CAIRO_ARGB_R 1
 162 # define CAIRO_ARGB_G 2
 163 # define CAIRO_ARGB_B 3
 164 #endif
 165
 166 enum
 167 {
 168   PROP_0,
 169   PROP_TEXT,
 170   PROP_SHADING,
 171   PROP_HALIGNMENT,
 172   PROP_VALIGNMENT,
 173   PROP_XPAD,
 174   PROP_YPAD,
 175   PROP_DELTAX,
 176   PROP_DELTAY,
 177   PROP_XPOS,
 178   PROP_YPOS,
 179   PROP_WRAP_MODE,
 180   PROP_FONT_DESC,
 181   PROP_SILENT,
 182   PROP_LINE_ALIGNMENT,
 183   PROP_WAIT_TEXT,
 184   PROP_AUTO_ADJUST_SIZE,
 185   PROP_VERTICAL_RENDER,
 186   PROP_COLOR,
 187   PROP_SHADOW,
 188   PROP_OUTLINE_COLOR,
 189   PROP_LAST
 190 };
 191
 192 #define VIDEO_FORMATS "{ BGRx, RGBx, xRGB, xBGR, RGBA, BGRA, ARGB, ABGR, RGB, BGR, \
 193     I420, YV12, AYUV, YUY2, UYVY, v308, v210, v216, Y41B, Y42B, Y444, \
 194     NV12, NV21, UYVP, A420, YUV9, IYU1, GRAY8, GRAY16_LE, GRAY16_BE }"
 195
 196 static GstStaticPadTemplate src_template_factory =
 197 GST_STATIC_PAD_TEMPLATE ("src",
 198     GST_PAD_SRC,
 199     GST_PAD_ALWAYS,
 200     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (VIDEO_FORMATS))
 201     );
 202
 203 static GstStaticPadTemplate video_sink_template_factory =
 204 GST_STATIC_PAD_TEMPLATE ("video_sink",
 205     GST_PAD_SINK,
 206     GST_PAD_ALWAYS,
 207     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (VIDEO_FORMATS))
 208     );
 209
 210 #define GST_TYPE_BASE_TEXT_OVERLAY_VALIGN (gst_base_text_overlay_valign_get_type())
 211 static GType
 212 gst_base_text_overlay_valign_get_type (void)
 213 {
 214   static GType base_text_overlay_valign_type = 0;
 215   static const GEnumValue base_text_overlay_valign[] = {
 216     {GST_BASE_TEXT_OVERLAY_VALIGN_BASELINE, "baseline", "baseline"},
 217     {GST_BASE_TEXT_OVERLAY_VALIGN_BOTTOM, "bottom", "bottom"},
 218     {GST_BASE_TEXT_OVERLAY_VALIGN_TOP, "top", "top"},
 219     {GST_BASE_TEXT_OVERLAY_VALIGN_POS, "position", "position"},
 220     {GST_BASE_TEXT_OVERLAY_VALIGN_CENTER, "center", "center"},
 221     {0, NULL, NULL},
 222   };
 223
 224   if (!base_text_overlay_valign_type) {
 225     base_text_overlay_valign_type =
 226         g_enum_register_static ("GstBaseTextOverlayVAlign",
 227         base_text_overlay_valign);
 228   }
 229   return base_text_overlay_valign_type;
 230 }
 231
 232 #define GST_TYPE_BASE_TEXT_OVERLAY_HALIGN (gst_base_text_overlay_halign_get_type())
 233 static GType
 234 gst_base_text_overlay_halign_get_type (void)
 235 {
 236   static GType base_text_overlay_halign_type = 0;
 237   static const GEnumValue base_text_overlay_halign[] = {
 238     {GST_BASE_TEXT_OVERLAY_HALIGN_LEFT, "left", "left"},
 239     {GST_BASE_TEXT_OVERLAY_HALIGN_CENTER, "center", "center"},
 240     {GST_BASE_TEXT_OVERLAY_HALIGN_RIGHT, "right", "right"},
 241     {GST_BASE_TEXT_OVERLAY_HALIGN_POS, "position", "position"},
 242     {0, NULL, NULL},
 243   };
 244
 245   if (!base_text_overlay_halign_type) {
 246     base_text_overlay_halign_type =
 247         g_enum_register_static ("GstBaseTextOverlayHAlign",
 248         base_text_overlay_halign);
 249   }
 250   return base_text_overlay_halign_type;
 251 }
 252
 253
 254 #define GST_TYPE_BASE_TEXT_OVERLAY_WRAP_MODE (gst_base_text_overlay_wrap_mode_get_type())
 255 static GType
 256 gst_base_text_overlay_wrap_mode_get_type (void)
 257 {
 258   static GType base_text_overlay_wrap_mode_type = 0;
 259   static const GEnumValue base_text_overlay_wrap_mode[] = {
 260     {GST_BASE_TEXT_OVERLAY_WRAP_MODE_NONE, "none", "none"},
 261     {GST_BASE_TEXT_OVERLAY_WRAP_MODE_WORD, "word", "word"},
 262     {GST_BASE_TEXT_OVERLAY_WRAP_MODE_CHAR, "char", "char"},
 263     {GST_BASE_TEXT_OVERLAY_WRAP_MODE_WORD_CHAR, "wordchar", "wordchar"},
 264     {0, NULL, NULL},
 265   };
 266
 267   if (!base_text_overlay_wrap_mode_type) {
 268     base_text_overlay_wrap_mode_type =
 269         g_enum_register_static ("GstBaseTextOverlayWrapMode",
 270         base_text_overlay_wrap_mode);
 271   }
 272   return base_text_overlay_wrap_mode_type;
 273 }
 274
 275 #define GST_TYPE_BASE_TEXT_OVERLAY_LINE_ALIGN (gst_base_text_overlay_line_align_get_type())
 276 static GType
 277 gst_base_text_overlay_line_align_get_type (void)
 278 {
 279   static GType base_text_overlay_line_align_type = 0;
 280   static const GEnumValue base_text_overlay_line_align[] = {
 281     {GST_BASE_TEXT_OVERLAY_LINE_ALIGN_LEFT, "left", "left"},
 282     {GST_BASE_TEXT_OVERLAY_LINE_ALIGN_CENTER, "center", "center"},
 283     {GST_BASE_TEXT_OVERLAY_LINE_ALIGN_RIGHT, "right", "right"},
 284     {0, NULL, NULL}
 285   };
 286
 287   if (!base_text_overlay_line_align_type) {
 288     base_text_overlay_line_align_type =
 289         g_enum_register_static ("GstBaseTextOverlayLineAlign",
 290         base_text_overlay_line_align);
 291   }
 292   return base_text_overlay_line_align_type;
 293 }
 294
 295 #define GST_BASE_TEXT_OVERLAY_GET_LOCK(ov) (&GST_BASE_TEXT_OVERLAY (ov)->lock)
 296 #define GST_BASE_TEXT_OVERLAY_GET_COND(ov) (&GST_BASE_TEXT_OVERLAY (ov)->cond)
 297 #define GST_BASE_TEXT_OVERLAY_LOCK(ov)     (g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_LOCK (ov)))
 298 #define GST_BASE_TEXT_OVERLAY_UNLOCK(ov)   (g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_LOCK (ov)))
 299 #define GST_BASE_TEXT_OVERLAY_WAIT(ov)     (g_cond_wait (GST_BASE_TEXT_OVERLAY_GET_COND (ov), GST_BASE_TEXT_OVERLAY_GET_LOCK (ov)))
 300 #define GST_BASE_TEXT_OVERLAY_SIGNAL(ov)   (g_cond_signal (GST_BASE_TEXT_OVERLAY_GET_COND (ov)))
 301 #define GST_BASE_TEXT_OVERLAY_BROADCAST(ov)(g_cond_broadcast (GST_BASE_TEXT_OVERLAY_GET_COND (ov)))
 302
 303 static GstElementClass *parent_class = NULL;
 304 static void gst_base_text_overlay_base_init (gpointer g_class);
 305 static void gst_base_text_overlay_class_init (GstBaseTextOverlayClass * klass);
 306 static void gst_base_text_overlay_init (GstBaseTextOverlay * overlay,
 307     GstBaseTextOverlayClass * klass);
 308
 309 static GstStateChangeReturn gst_base_text_overlay_change_state (GstElement *
 310     element, GstStateChange transition);
 311
 312 static GstCaps *gst_base_text_overlay_getcaps (GstPad * pad,
 313     GstBaseTextOverlay * overlay, GstCaps * filter);
 314 static gboolean gst_base_text_overlay_setcaps (GstBaseTextOverlay * overlay,
 315     GstCaps * caps);
 316 static gboolean gst_base_text_overlay_setcaps_txt (GstBaseTextOverlay * overlay,
 317     GstCaps * caps);
 318 static gboolean gst_base_text_overlay_src_event (GstPad * pad,
 319     GstObject * parent, GstEvent * event);
 320 static gboolean gst_base_text_overlay_src_query (GstPad * pad,
 321     GstObject * parent, GstQuery * query);
 322
 323 static gboolean gst_base_text_overlay_video_event (GstPad * pad,
 324     GstObject * parent, GstEvent * event);
 325 static gboolean gst_base_text_overlay_video_query (GstPad * pad,
 326     GstObject * parent, GstQuery * query);
 327 static GstFlowReturn gst_base_text_overlay_video_chain (GstPad * pad,
 328     GstObject * parent, GstBuffer * buffer);
 329
 330 static gboolean gst_base_text_overlay_text_event (GstPad * pad,
 331     GstObject * parent, GstEvent * event);
 332 static GstFlowReturn gst_base_text_overlay_text_chain (GstPad * pad,
 333     GstObject * parent, GstBuffer * buffer);
 334 static GstPadLinkReturn gst_base_text_overlay_text_pad_link (GstPad * pad,
 335     GstObject * parent, GstPad * peer);
 336 static void gst_base_text_overlay_text_pad_unlink (GstPad * pad,
 337     GstObject * parent);
 338 static void gst_base_text_overlay_pop_text (GstBaseTextOverlay * overlay);
 339 static void gst_base_text_overlay_update_render_mode (GstBaseTextOverlay *
 340     overlay);
 341
 342 static void gst_base_text_overlay_finalize (GObject * object);
 343 static void gst_base_text_overlay_set_property (GObject * object, guint prop_id,
 344     const GValue * value, GParamSpec * pspec);
 345 static void gst_base_text_overlay_get_property (GObject * object, guint prop_id,
 346     GValue * value, GParamSpec * pspec);
 347 static void
 348 gst_base_text_overlay_adjust_values_with_fontdesc (GstBaseTextOverlay * overlay,
 349     PangoFontDescription * desc);
 350
 351 GType
 352 gst_base_text_overlay_get_type (void)
 353 {
 354   static GType type = 0;
 355
 356   if (g_once_init_enter ((gsize *) & type)) {
 357     static const GTypeInfo info = {
 358       sizeof (GstBaseTextOverlayClass),
 359       (GBaseInitFunc) gst_base_text_overlay_base_init,
 360       NULL,
 361       (GClassInitFunc) gst_base_text_overlay_class_init,
 362       NULL,
 363       NULL,
 364       sizeof (GstBaseTextOverlay),
 365       0,
 366       (GInstanceInitFunc) gst_base_text_overlay_init,
 367     };
 368
 369     g_once_init_leave ((gsize *) & type,
 370         g_type_register_static (GST_TYPE_ELEMENT, "GstBaseTextOverlay", &info,
 371             0));
 372   }
 373
 374   return type;
 375 }
 376
 377 static gchar *
 378 gst_base_text_overlay_get_text (GstBaseTextOverlay * overlay,
 379     GstBuffer * video_frame)
 380 {
 381   return g_strdup (overlay->default_text);
 382 }
 383
 384 static void
 385 gst_base_text_overlay_base_init (gpointer g_class)
 386 {
 387   GstBaseTextOverlayClass *klass = GST_BASE_TEXT_OVERLAY_CLASS (g_class);
 388   PangoFontMap *fontmap;
 389
 390   /* Only lock for the subclasses here, the base class
 391    * doesn't have this mutex yet and it's not necessary
 392    * here */
 393   if (klass->pango_lock)
 394     g_mutex_lock (klass->pango_lock);
 395   fontmap = pango_cairo_font_map_get_default ();
 396   klass->pango_context =
 397       pango_font_map_create_context (PANGO_FONT_MAP (fontmap));
 398   if (klass->pango_lock)
 399     g_mutex_unlock (klass->pango_lock);
 400 }
 401
 402 static void
 403 gst_base_text_overlay_class_init (GstBaseTextOverlayClass * klass)
 404 {
 405   GObjectClass *gobject_class;
 406   GstElementClass *gstelement_class;
 407
 408   gobject_class = (GObjectClass *) klass;
 409   gstelement_class = (GstElementClass *) klass;
 410
 411   parent_class = g_type_class_peek_parent (klass);
 412
 413   gobject_class->finalize = gst_base_text_overlay_finalize;
 414   gobject_class->set_property = gst_base_text_overlay_set_property;
 415   gobject_class->get_property = gst_base_text_overlay_get_property;
 416
 417   gst_element_class_add_pad_template (gstelement_class,
 418       gst_static_pad_template_get (&src_template_factory));
 419   gst_element_class_add_pad_template (gstelement_class,
 420       gst_static_pad_template_get (&video_sink_template_factory));
 421
 422   gstelement_class->change_state =
 423       GST_DEBUG_FUNCPTR (gst_base_text_overlay_change_state);
 424
 425   klass->pango_lock = g_slice_new (GMutex);
 426   g_mutex_init (klass->pango_lock);
 427
 428   klass->get_text = gst_base_text_overlay_get_text;
 429
 430   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TEXT,
 431       g_param_spec_string ("text", "text",
 432           "Text to be display.", DEFAULT_PROP_TEXT,
 433           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 434   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SHADING,
 435       g_param_spec_boolean ("shaded-background", "shaded background",
 436           "Whether to shade the background under the text area",
 437           DEFAULT_PROP_SHADING, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 438   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_VALIGNMENT,
 439       g_param_spec_enum ("valignment", "vertical alignment",
 440           "Vertical alignment of the text", GST_TYPE_BASE_TEXT_OVERLAY_VALIGN,
 441           DEFAULT_PROP_VALIGNMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 442   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HALIGNMENT,
 443       g_param_spec_enum ("halignment", "horizontal alignment",
 444           "Horizontal alignment of the text", GST_TYPE_BASE_TEXT_OVERLAY_HALIGN,
 445           DEFAULT_PROP_HALIGNMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 446   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_XPAD,
 447       g_param_spec_int ("xpad", "horizontal paddding",
 448           "Horizontal paddding when using left/right alignment", 0, G_MAXINT,
 449           DEFAULT_PROP_XPAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 450   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_YPAD,
 451       g_param_spec_int ("ypad", "vertical padding",
 452           "Vertical padding when using top/bottom alignment", 0, G_MAXINT,
 453           DEFAULT_PROP_YPAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 454   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_DELTAX,
 455       g_param_spec_int ("deltax", "X position modifier",
 456           "Shift X position to the left or to the right. Unit is pixels.",
 457           G_MININT, G_MAXINT, DEFAULT_PROP_DELTAX,
 458           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 459   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_DELTAY,
 460       g_param_spec_int ("deltay", "Y position modifier",
 461           "Shift Y position up or down. Unit is pixels.", G_MININT, G_MAXINT,
 462           DEFAULT_PROP_DELTAY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 463   /**
 464    * GstBaseTextOverlay:xpos
 465    *
 466    * Horizontal position of the rendered text when using positioned alignment.
 467    *
 468    * Since: 0.10.31
 469    **/
 470   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_XPOS,
 471       g_param_spec_double ("xpos", "horizontal position",
 472           "Horizontal position when using position alignment", 0, 1.0,
 473           DEFAULT_PROP_XPOS,
 474           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 475   /**
 476    * GstBaseTextOverlay:ypos
 477    *
 478    * Vertical position of the rendered text when using positioned alignment.
 479    *
 480    * Since: 0.10.31
 481    **/
 482   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_YPOS,
 483       g_param_spec_double ("ypos", "vertical position",
 484           "Vertical position when using position alignment", 0, 1.0,
 485           DEFAULT_PROP_YPOS,
 486           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 487   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_WRAP_MODE,
 488       g_param_spec_enum ("wrap-mode", "wrap mode",
 489           "Whether to wrap the text and if so how.",
 490           GST_TYPE_BASE_TEXT_OVERLAY_WRAP_MODE, DEFAULT_PROP_WRAP_MODE,
 491           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 492   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FONT_DESC,
 493       g_param_spec_string ("font-desc", "font description",
 494           "Pango font description of font to be used for rendering. "
 495           "See documentation of pango_font_description_from_string "
 496           "for syntax.", DEFAULT_PROP_FONT_DESC,
 497           G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
 498   /**
 499    * GstBaseTextOverlay:color
 500    *
 501    * Color of the rendered text.
 502    *
 503    * Since: 0.10.31
 504    **/
 505   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_COLOR,
 506       g_param_spec_uint ("color", "Color",
 507           "Color to use for text (big-endian ARGB).", 0, G_MAXUINT32,
 508           DEFAULT_PROP_COLOR,
 509           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 510   /**
 511    * GstTextOverlay:outline-color
 512    *
 513    * Color of the outline of the rendered text.
 514    *
 515    * Since: 0.10.35
 516    **/
 517   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_OUTLINE_COLOR,
 518       g_param_spec_uint ("outline-color", "Text Outline Color",
 519           "Color to use for outline the text (big-endian ARGB).", 0,
 520           G_MAXUINT32, DEFAULT_PROP_OUTLINE_COLOR,
 521           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 522
 523   /**
 524    * GstBaseTextOverlay:line-alignment
 525    *
 526    * Alignment of text lines relative to each other (for multi-line text)
 527    *
 528    * Since: 0.10.15
 529    **/
 530   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_LINE_ALIGNMENT,
 531       g_param_spec_enum ("line-alignment", "line alignment",
 532           "Alignment of text lines relative to each other.",
 533           GST_TYPE_BASE_TEXT_OVERLAY_LINE_ALIGN, DEFAULT_PROP_LINE_ALIGNMENT,
 534           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 535   /**
 536    * GstBaseTextOverlay:silent
 537    *
 538    * If set, no text is rendered. Useful to switch off text rendering
 539    * temporarily without removing the textoverlay element from the pipeline.
 540    *
 541    * Since: 0.10.15
 542    **/
 543   /* FIXME 0.11: rename to "visible" or "text-visible" or "render-text" */
 544   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SILENT,
 545       g_param_spec_boolean ("silent", "silent",
 546           "Whether to render the text string",
 547           DEFAULT_PROP_SILENT,
 548           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 549   /**
 550    * GstBaseTextOverlay:wait-text
 551    *
 552    * If set, the video will block until a subtitle is received on the text pad.
 553    * If video and subtitles are sent in sync, like from the same demuxer, this
 554    * property should be set.
 555    *
 556    * Since: 0.10.20
 557    **/
 558   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_WAIT_TEXT,
 559       g_param_spec_boolean ("wait-text", "Wait Text",
 560           "Whether to wait for subtitles",
 561           DEFAULT_PROP_WAIT_TEXT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 562
 563   g_object_class_install_property (G_OBJECT_CLASS (klass),
 564       PROP_AUTO_ADJUST_SIZE, g_param_spec_boolean ("auto-resize", "auto resize",
 565           "Automatically adjust font size to screen-size.",
 566           DEFAULT_PROP_AUTO_ADJUST_SIZE,
 567           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 568
 569   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_VERTICAL_RENDER,
 570       g_param_spec_boolean ("vertical-render", "vertical render",
 571           "Vertical Render.", DEFAULT_PROP_VERTICAL_RENDER,
 572           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 573 }
 574
 575 static void
 576 gst_base_text_overlay_finalize (GObject * object)
 577 {
 578   GstBaseTextOverlay *overlay = GST_BASE_TEXT_OVERLAY (object);
 579
 580   g_free (overlay->default_text);
 581
 582   if (overlay->composition) {
 583     gst_video_overlay_composition_unref (overlay->composition);
 584     overlay->composition = NULL;
 585   }
 586
 587   if (overlay->text_image) {
 588     gst_buffer_unref (overlay->text_image);
 589     overlay->text_image = NULL;
 590   }
 591
 592   if (overlay->layout) {
 593     g_object_unref (overlay->layout);
 594     overlay->layout = NULL;
 595   }
 596
 597   if (overlay->text_buffer) {
 598     gst_buffer_unref (overlay->text_buffer);
 599     overlay->text_buffer = NULL;
 600   }
 601
 602   g_mutex_clear (&overlay->lock);
 603   g_cond_clear (&overlay->cond);
 604
 605   G_OBJECT_CLASS (parent_class)->finalize (object);
 606 }
 607
 608 static void
 609 gst_base_text_overlay_init (GstBaseTextOverlay * overlay,
 610     GstBaseTextOverlayClass * klass)
 611 {
 612   GstPadTemplate *template;
 613   PangoFontDescription *desc;
 614
 615   /* video sink */
 616   template = gst_static_pad_template_get (&video_sink_template_factory);
 617   overlay->video_sinkpad = gst_pad_new_from_template (template, "video_sink");
 618   gst_object_unref (template);
 619   gst_pad_set_event_function (overlay->video_sinkpad,
 620       GST_DEBUG_FUNCPTR (gst_base_text_overlay_video_event));
 621   gst_pad_set_chain_function (overlay->video_sinkpad,
 622       GST_DEBUG_FUNCPTR (gst_base_text_overlay_video_chain));
 623   gst_pad_set_query_function (overlay->video_sinkpad,
 624       GST_DEBUG_FUNCPTR (gst_base_text_overlay_video_query));
 625   GST_PAD_SET_PROXY_ALLOCATION (overlay->video_sinkpad);
 626   gst_element_add_pad (GST_ELEMENT (overlay), overlay->video_sinkpad);
 627
 628   template =
 629       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass),
 630       "text_sink");
 631   if (template) {
 632     /* text sink */
 633     overlay->text_sinkpad = gst_pad_new_from_template (template, "text_sink");
 634
 635     gst_pad_set_event_function (overlay->text_sinkpad,
 636         GST_DEBUG_FUNCPTR (gst_base_text_overlay_text_event));
 637     gst_pad_set_chain_function (overlay->text_sinkpad,
 638         GST_DEBUG_FUNCPTR (gst_base_text_overlay_text_chain));
 639     gst_pad_set_link_function (overlay->text_sinkpad,
 640         GST_DEBUG_FUNCPTR (gst_base_text_overlay_text_pad_link));
 641     gst_pad_set_unlink_function (overlay->text_sinkpad,
 642         GST_DEBUG_FUNCPTR (gst_base_text_overlay_text_pad_unlink));
 643     gst_element_add_pad (GST_ELEMENT (overlay), overlay->text_sinkpad);
 644   }
 645
 646   /* (video) source */
 647   template = gst_static_pad_template_get (&src_template_factory);
 648   overlay->srcpad = gst_pad_new_from_template (template, "src");
 649   gst_object_unref (template);
 650   gst_pad_set_event_function (overlay->srcpad,
 651       GST_DEBUG_FUNCPTR (gst_base_text_overlay_src_event));
 652   gst_pad_set_query_function (overlay->srcpad,
 653       GST_DEBUG_FUNCPTR (gst_base_text_overlay_src_query));
 654   gst_element_add_pad (GST_ELEMENT (overlay), overlay->srcpad);
 655
 656   g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 657   overlay->line_align = DEFAULT_PROP_LINE_ALIGNMENT;
 658   overlay->layout =
 659       pango_layout_new (GST_BASE_TEXT_OVERLAY_GET_CLASS
 660       (overlay)->pango_context);
 661   desc =
 662       pango_context_get_font_description (GST_BASE_TEXT_OVERLAY_GET_CLASS
 663       (overlay)->pango_context);
 664   gst_base_text_overlay_adjust_values_with_fontdesc (overlay, desc);
 665
 666   overlay->color = DEFAULT_PROP_COLOR;
 667   overlay->outline_color = DEFAULT_PROP_OUTLINE_COLOR;
 668   overlay->halign = DEFAULT_PROP_HALIGNMENT;
 669   overlay->valign = DEFAULT_PROP_VALIGNMENT;
 670   overlay->xpad = DEFAULT_PROP_XPAD;
 671   overlay->ypad = DEFAULT_PROP_YPAD;
 672   overlay->deltax = DEFAULT_PROP_DELTAX;
 673   overlay->deltay = DEFAULT_PROP_DELTAY;
 674   overlay->xpos = DEFAULT_PROP_XPOS;
 675   overlay->ypos = DEFAULT_PROP_YPOS;
 676
 677   overlay->wrap_mode = DEFAULT_PROP_WRAP_MODE;
 678
 679   overlay->want_shading = DEFAULT_PROP_SHADING;
 680   overlay->shading_value = DEFAULT_SHADING_VALUE;
 681   overlay->silent = DEFAULT_PROP_SILENT;
 682   overlay->wait_text = DEFAULT_PROP_WAIT_TEXT;
 683   overlay->auto_adjust_size = DEFAULT_PROP_AUTO_ADJUST_SIZE;
 684
 685   overlay->default_text = g_strdup (DEFAULT_PROP_TEXT);
 686   overlay->need_render = TRUE;
 687   overlay->text_image = NULL;
 688   overlay->use_vertical_render = DEFAULT_PROP_VERTICAL_RENDER;
 689   gst_base_text_overlay_update_render_mode (overlay);
 690
 691   overlay->text_buffer = NULL;
 692   overlay->text_linked = FALSE;
 693   g_mutex_init (&overlay->lock);
 694   g_cond_init (&overlay->cond);
 695   gst_segment_init (&overlay->segment, GST_FORMAT_TIME);
 696   g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 697 }
 698
 699 static void
 700 gst_base_text_overlay_update_wrap_mode (GstBaseTextOverlay * overlay)
 701 {
 702   if (overlay->wrap_mode == GST_BASE_TEXT_OVERLAY_WRAP_MODE_NONE) {
 703     GST_DEBUG_OBJECT (overlay, "Set wrap mode NONE");
 704     pango_layout_set_width (overlay->layout, -1);
 705   } else {
 706     int width;
 707
 708     if (overlay->auto_adjust_size) {
 709       width = DEFAULT_SCALE_BASIS * PANGO_SCALE;
 710       if (overlay->use_vertical_render) {
 711         width = width * (overlay->height - overlay->ypad * 2) / overlay->width;
 712       }
 713     } else {
 714       width =
 715           (overlay->use_vertical_render ? overlay->height : overlay->width) *
 716           PANGO_SCALE;
 717     }
 718
 719     GST_DEBUG_OBJECT (overlay, "Set layout width %d", overlay->width);
 720     GST_DEBUG_OBJECT (overlay, "Set wrap mode    %d", overlay->wrap_mode);
 721     pango_layout_set_width (overlay->layout, width);
 722     pango_layout_set_wrap (overlay->layout, (PangoWrapMode) overlay->wrap_mode);
 723   }
 724 }
 725
 726 static void
 727 gst_base_text_overlay_update_render_mode (GstBaseTextOverlay * overlay)
 728 {
 729   PangoMatrix matrix = PANGO_MATRIX_INIT;
 730   PangoContext *context = pango_layout_get_context (overlay->layout);
 731
 732   if (overlay->use_vertical_render) {
 733     pango_matrix_rotate (&matrix, -90);
 734     pango_context_set_base_gravity (context, PANGO_GRAVITY_AUTO);
 735     pango_context_set_matrix (context, &matrix);
 736     pango_layout_set_alignment (overlay->layout, PANGO_ALIGN_LEFT);
 737   } else {
 738     pango_context_set_base_gravity (context, PANGO_GRAVITY_SOUTH);
 739     pango_context_set_matrix (context, &matrix);
 740     pango_layout_set_alignment (overlay->layout,
 741         (PangoAlignment) overlay->line_align);
 742   }
 743 }
 744
 745 static gboolean
 746 gst_base_text_overlay_setcaps_txt (GstBaseTextOverlay * overlay, GstCaps * caps)
 747 {
 748   GstStructure *structure;
 749   const gchar *format;
 750
 751   structure = gst_caps_get_structure (caps, 0);
 752   format = gst_structure_get_string (structure, "format");
 753   overlay->have_pango_markup = (strcmp (format, "pango-markup") == 0);
 754
 755   return TRUE;
 756 }
 757
 758 /* FIXME: upstream nego (e.g. when the video window is resized) */
 759
 760 /* only negotiate/query video overlay composition support for now */
 761 static gboolean
 762 gst_base_text_overlay_negotiate (GstBaseTextOverlay * overlay)
 763 {
 764   GstCaps *target;
 765   GstQuery *query;
 766   gboolean attach = FALSE;
 767
 768   GST_DEBUG_OBJECT (overlay, "performing negotiation");
 769
 770   target = gst_pad_get_current_caps (overlay->srcpad);
 771
 772   if (!target || gst_caps_is_empty (target))
 773     goto no_format;
 774
 775   /* find supported meta */
 776   query = gst_query_new_allocation (target, TRUE);
 777
 778   if (!gst_pad_peer_query (overlay->srcpad, query)) {
 779     /* no problem, we use the query defaults */
 780     GST_DEBUG_OBJECT (overlay, "ALLOCATION query failed");
 781   }
 782
 783   if (gst_query_find_allocation_meta (query,
 784           GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, NULL))
 785     attach = TRUE;
 786
 787   overlay->attach_compo_to_buffer = attach;
 788
 789   gst_query_unref (query);
 790   gst_caps_unref (target);
 791
 792   return TRUE;
 793
 794 no_format:
 795   {
 796     if (target)
 797       gst_caps_unref (target);
 798     return FALSE;
 799   }
 800 }
 801
 802 static gboolean
 803 gst_base_text_overlay_setcaps (GstBaseTextOverlay * overlay, GstCaps * caps)
 804 {
 805   GstVideoInfo info;
 806   gboolean ret = FALSE;
 807
 808   if (!gst_video_info_from_caps (&info, caps))
 809     goto invalid_caps;
 810
 811   overlay->info = info;
 812   overlay->format = GST_VIDEO_INFO_FORMAT (&info);
 813   overlay->width = GST_VIDEO_INFO_WIDTH (&info);
 814   overlay->height = GST_VIDEO_INFO_HEIGHT (&info);
 815
 816   ret = gst_pad_set_caps (overlay->srcpad, caps);
 817
 818   if (ret) {
 819     GST_BASE_TEXT_OVERLAY_LOCK (overlay);
 820     g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 821     gst_base_text_overlay_negotiate (overlay);
 822     gst_base_text_overlay_update_wrap_mode (overlay);
 823     g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 824     GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
 825   }
 826
 827   return ret;
 828
 829   /* ERRORS */
 830 invalid_caps:
 831   {
 832     GST_DEBUG_OBJECT (overlay, "could not parse caps");
 833     return FALSE;
 834   }
 835 }
 836
 837 static void
 838 gst_base_text_overlay_set_property (GObject * object, guint prop_id,
 839     const GValue * value, GParamSpec * pspec)
 840 {
 841   GstBaseTextOverlay *overlay = GST_BASE_TEXT_OVERLAY (object);
 842
 843   GST_BASE_TEXT_OVERLAY_LOCK (overlay);
 844   switch (prop_id) {
 845     case PROP_TEXT:
 846       g_free (overlay->default_text);
 847       overlay->default_text = g_value_dup_string (value);
 848       overlay->need_render = TRUE;
 849       break;
 850     case PROP_SHADING:
 851       overlay->want_shading = g_value_get_boolean (value);
 852       break;
 853     case PROP_XPAD:
 854       overlay->xpad = g_value_get_int (value);
 855       break;
 856     case PROP_YPAD:
 857       overlay->ypad = g_value_get_int (value);
 858       break;
 859     case PROP_DELTAX:
 860       overlay->deltax = g_value_get_int (value);
 861       break;
 862     case PROP_DELTAY:
 863       overlay->deltay = g_value_get_int (value);
 864       break;
 865     case PROP_XPOS:
 866       overlay->xpos = g_value_get_double (value);
 867       break;
 868     case PROP_YPOS:
 869       overlay->ypos = g_value_get_double (value);
 870       break;
 871     case PROP_VALIGNMENT:
 872       overlay->valign = g_value_get_enum (value);
 873       break;
 874     case PROP_HALIGNMENT:
 875       overlay->halign = g_value_get_enum (value);
 876       break;
 877     case PROP_WRAP_MODE:
 878       overlay->wrap_mode = g_value_get_enum (value);
 879       g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 880       gst_base_text_overlay_update_wrap_mode (overlay);
 881       g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 882       break;
 883     case PROP_FONT_DESC:
 884     {
 885       PangoFontDescription *desc;
 886       const gchar *fontdesc_str;
 887
 888       fontdesc_str = g_value_get_string (value);
 889       g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 890       desc = pango_font_description_from_string (fontdesc_str);
 891       if (desc) {
 892         GST_LOG_OBJECT (overlay, "font description set: %s", fontdesc_str);
 893         pango_layout_set_font_description (overlay->layout, desc);
 894         gst_base_text_overlay_adjust_values_with_fontdesc (overlay, desc);
 895         pango_font_description_free (desc);
 896       } else {
 897         GST_WARNING_OBJECT (overlay, "font description parse failed: %s",
 898             fontdesc_str);
 899       }
 900       g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 901       break;
 902     }
 903     case PROP_COLOR:
 904       overlay->color = g_value_get_uint (value);
 905       break;
 906     case PROP_OUTLINE_COLOR:
 907       overlay->outline_color = g_value_get_uint (value);
 908       break;
 909     case PROP_SILENT:
 910       overlay->silent = g_value_get_boolean (value);
 911       break;
 912     case PROP_LINE_ALIGNMENT:
 913       overlay->line_align = g_value_get_enum (value);
 914       g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 915       pango_layout_set_alignment (overlay->layout,
 916           (PangoAlignment) overlay->line_align);
 917       g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 918       break;
 919     case PROP_WAIT_TEXT:
 920       overlay->wait_text = g_value_get_boolean (value);
 921       break;
 922     case PROP_AUTO_ADJUST_SIZE:
 923       overlay->auto_adjust_size = g_value_get_boolean (value);
 924       overlay->need_render = TRUE;
 925       break;
 926     case PROP_VERTICAL_RENDER:
 927       overlay->use_vertical_render = g_value_get_boolean (value);
 928       g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 929       gst_base_text_overlay_update_render_mode (overlay);
 930       g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
 931       overlay->need_render = TRUE;
 932       break;
 933     default:
 934       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 935       break;
 936   }
 937
 938   overlay->need_render = TRUE;
 939   GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
 940 }
 941
 942 static void
 943 gst_base_text_overlay_get_property (GObject * object, guint prop_id,
 944     GValue * value, GParamSpec * pspec)
 945 {
 946   GstBaseTextOverlay *overlay = GST_BASE_TEXT_OVERLAY (object);
 947
 948   GST_BASE_TEXT_OVERLAY_LOCK (overlay);
 949   switch (prop_id) {
 950     case PROP_TEXT:
 951       g_value_set_string (value, overlay->default_text);
 952       break;
 953     case PROP_SHADING:
 954       g_value_set_boolean (value, overlay->want_shading);
 955       break;
 956     case PROP_XPAD:
 957       g_value_set_int (value, overlay->xpad);
 958       break;
 959     case PROP_YPAD:
 960       g_value_set_int (value, overlay->ypad);
 961       break;
 962     case PROP_DELTAX:
 963       g_value_set_int (value, overlay->deltax);
 964       break;
 965     case PROP_DELTAY:
 966       g_value_set_int (value, overlay->deltay);
 967       break;
 968     case PROP_XPOS:
 969       g_value_set_double (value, overlay->xpos);
 970       break;
 971     case PROP_YPOS:
 972       g_value_set_double (value, overlay->ypos);
 973       break;
 974     case PROP_VALIGNMENT:
 975       g_value_set_enum (value, overlay->valign);
 976       break;
 977     case PROP_HALIGNMENT:
 978       g_value_set_enum (value, overlay->halign);
 979       break;
 980     case PROP_WRAP_MODE:
 981       g_value_set_enum (value, overlay->wrap_mode);
 982       break;
 983     case PROP_SILENT:
 984       g_value_set_boolean (value, overlay->silent);
 985       break;
 986     case PROP_LINE_ALIGNMENT:
 987       g_value_set_enum (value, overlay->line_align);
 988       break;
 989     case PROP_WAIT_TEXT:
 990       g_value_set_boolean (value, overlay->wait_text);
 991       break;
 992     case PROP_AUTO_ADJUST_SIZE:
 993       g_value_set_boolean (value, overlay->auto_adjust_size);
 994       break;
 995     case PROP_VERTICAL_RENDER:
 996       g_value_set_boolean (value, overlay->use_vertical_render);
 997       break;
 998     case PROP_COLOR:
 999       g_value_set_uint (value, overlay->color);
1000       break;
1001     case PROP_OUTLINE_COLOR:
1002       g_value_set_uint (value, overlay->outline_color);
1003       break;
1004     default:
1005       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1006       break;
1007   }
1008
1009   overlay->need_render = TRUE;
1010   GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1011 }
1012
1013 static gboolean
1014 gst_base_text_overlay_src_query (GstPad * pad, GstObject * parent,
1015     GstQuery * query)
1016 {
1017   gboolean ret = FALSE;
1018   GstBaseTextOverlay *overlay;
1019
1020   overlay = GST_BASE_TEXT_OVERLAY (parent);
1021
1022   switch (GST_QUERY_TYPE (query)) {
1023     case GST_QUERY_CAPS:
1024     {
1025       GstCaps *filter, *caps;
1026
1027       gst_query_parse_caps (query, &filter);
1028       caps = gst_base_text_overlay_getcaps (pad, overlay, filter);
1029       gst_query_set_caps_result (query, caps);
1030       gst_caps_unref (caps);
1031       ret = TRUE;
1032       break;
1033     }
1034     default:
1035       ret = gst_pad_peer_query (overlay->video_sinkpad, query);
1036       break;
1037   }
1038
1039   return ret;
1040 }
1041
1042 static gboolean
1043 gst_base_text_overlay_src_event (GstPad * pad, GstObject * parent,
1044     GstEvent * event)
1045 {
1046   gboolean ret = FALSE;
1047   GstBaseTextOverlay *overlay = NULL;
1048
1049   overlay = GST_BASE_TEXT_OVERLAY (parent);
1050
1051   switch (GST_EVENT_TYPE (event)) {
1052     case GST_EVENT_SEEK:{
1053       GstSeekFlags flags;
1054
1055       /* We don't handle seek if we have not text pad */
1056       if (!overlay->text_linked) {
1057         GST_DEBUG_OBJECT (overlay, "seek received, pushing upstream");
1058         ret = gst_pad_push_event (overlay->video_sinkpad, event);
1059         goto beach;
1060       }
1061
1062       GST_DEBUG_OBJECT (overlay, "seek received, driving from here");
1063
1064       gst_event_parse_seek (event, NULL, NULL, &flags, NULL, NULL, NULL, NULL);
1065
1066       /* Flush downstream, only for flushing seek */
1067       if (flags & GST_SEEK_FLAG_FLUSH)
1068         gst_pad_push_event (overlay->srcpad, gst_event_new_flush_start ());
1069
1070       /* Mark ourself as flushing, unblock chains */
1071       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1072       overlay->video_flushing = TRUE;
1073       overlay->text_flushing = TRUE;
1074       gst_base_text_overlay_pop_text (overlay);
1075       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1076
1077       /* Seek on each sink pad */
1078       gst_event_ref (event);
1079       ret = gst_pad_push_event (overlay->video_sinkpad, event);
1080       if (ret) {
1081         ret = gst_pad_push_event (overlay->text_sinkpad, event);
1082       } else {
1083         gst_event_unref (event);
1084       }
1085       break;
1086     }
1087     default:
1088       if (overlay->text_linked) {
1089         gst_event_ref (event);
1090         ret = gst_pad_push_event (overlay->video_sinkpad, event);
1091         gst_pad_push_event (overlay->text_sinkpad, event);
1092       } else {
1093         ret = gst_pad_push_event (overlay->video_sinkpad, event);
1094       }
1095       break;
1096   }
1097
1098 beach:
1099
1100   return ret;
1101 }
1102
1103 static GstCaps *
1104 gst_base_text_overlay_getcaps (GstPad * pad, GstBaseTextOverlay * overlay,
1105     GstCaps * filter)
1106 {
1107   GstPad *otherpad;
1108   GstCaps *caps;
1109
1110   if (G_UNLIKELY (!overlay))
1111     return gst_pad_get_pad_template_caps (pad);
1112
1113   if (pad == overlay->srcpad)
1114     otherpad = overlay->video_sinkpad;
1115   else
1116     otherpad = overlay->srcpad;
1117
1118   /* we can do what the peer can */
1119   caps = gst_pad_peer_query_caps (otherpad, filter);
1120   if (caps) {
1121     GstCaps *temp, *templ;
1122
1123     GST_DEBUG_OBJECT (pad, "peer caps  %" GST_PTR_FORMAT, caps);
1124
1125     /* filtered against our padtemplate */
1126     templ = gst_pad_get_pad_template_caps (otherpad);
1127     GST_DEBUG_OBJECT (pad, "our template  %" GST_PTR_FORMAT, templ);
1128     temp = gst_caps_intersect_full (caps, templ, GST_CAPS_INTERSECT_FIRST);
1129     GST_DEBUG_OBJECT (pad, "intersected %" GST_PTR_FORMAT, temp);
1130     gst_caps_unref (caps);
1131     gst_caps_unref (templ);
1132     /* this is what we can do */
1133     caps = temp;
1134   } else {
1135     /* no peer, our padtemplate is enough then */
1136     caps = gst_pad_get_pad_template_caps (pad);
1137     if (filter) {
1138       GstCaps *intersection;
1139
1140       intersection =
1141           gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
1142       gst_caps_unref (caps);
1143       caps = intersection;
1144     }
1145   }
1146
1147   GST_DEBUG_OBJECT (overlay, "returning  %" GST_PTR_FORMAT, caps);
1148
1149   return caps;
1150 }
1151
1152 static void
1153 gst_base_text_overlay_adjust_values_with_fontdesc (GstBaseTextOverlay * overlay,
1154     PangoFontDescription * desc)
1155 {
1156   gint font_size = pango_font_description_get_size (desc) / PANGO_SCALE;
1157   overlay->shadow_offset = (double) (font_size) / 13.0;
1158   overlay->outline_offset = (double) (font_size) / 15.0;
1159   if (overlay->outline_offset < MINIMUM_OUTLINE_OFFSET)
1160     overlay->outline_offset = MINIMUM_OUTLINE_OFFSET;
1161 }
1162
1163 static void
1164 gst_base_text_overlay_get_pos (GstBaseTextOverlay * overlay,
1165     gint * xpos, gint * ypos)
1166 {
1167   gint width, height;
1168   GstBaseTextOverlayVAlign valign;
1169   GstBaseTextOverlayHAlign halign;
1170
1171   width = overlay->image_width;
1172   height = overlay->image_height;
1173
1174   if (overlay->use_vertical_render)
1175     halign = GST_BASE_TEXT_OVERLAY_HALIGN_RIGHT;
1176   else
1177     halign = overlay->halign;
1178
1179   switch (halign) {
1180     case GST_BASE_TEXT_OVERLAY_HALIGN_LEFT:
1181       *xpos = overlay->xpad;
1182       break;
1183     case GST_BASE_TEXT_OVERLAY_HALIGN_CENTER:
1184       *xpos = (overlay->width - width) / 2;
1185       break;
1186     case GST_BASE_TEXT_OVERLAY_HALIGN_RIGHT:
1187       *xpos = overlay->width - width - overlay->xpad;
1188       break;
1189     case GST_BASE_TEXT_OVERLAY_HALIGN_POS:
1190       *xpos = (gint) (overlay->width * overlay->xpos) - width / 2;
1191       *xpos = CLAMP (*xpos, 0, overlay->width - width);
1192       if (*xpos < 0)
1193         *xpos = 0;
1194       break;
1195     default:
1196       *xpos = 0;
1197   }
1198   *xpos += overlay->deltax;
1199
1200   if (overlay->use_vertical_render)
1201     valign = GST_BASE_TEXT_OVERLAY_VALIGN_TOP;
1202   else
1203     valign = overlay->valign;
1204
1205   switch (valign) {
1206     case GST_BASE_TEXT_OVERLAY_VALIGN_BOTTOM:
1207       *ypos = overlay->height - height - overlay->ypad;
1208       break;
1209     case GST_BASE_TEXT_OVERLAY_VALIGN_BASELINE:
1210       *ypos = overlay->height - (height + overlay->ypad);
1211       break;
1212     case GST_BASE_TEXT_OVERLAY_VALIGN_TOP:
1213       *ypos = overlay->ypad;
1214       break;
1215     case GST_BASE_TEXT_OVERLAY_VALIGN_POS:
1216       *ypos = (gint) (overlay->height * overlay->ypos) - height / 2;
1217       *ypos = CLAMP (*ypos, 0, overlay->height - height);
1218       break;
1219     case GST_BASE_TEXT_OVERLAY_VALIGN_CENTER:
1220       *ypos = (overlay->height - height) / 2;
1221       break;
1222     default:
1223       *ypos = overlay->ypad;
1224       break;
1225   }
1226   *ypos += overlay->deltay;
1227 }
1228
1229 static inline void
1230 gst_base_text_overlay_set_composition (GstBaseTextOverlay * overlay)
1231 {
1232   gint xpos, ypos;
1233   GstVideoOverlayRectangle *rectangle;
1234
1235   gst_base_text_overlay_get_pos (overlay, &xpos, &ypos);
1236
1237   if (overlay->text_image) {
1238     gst_buffer_add_video_meta (overlay->text_image, GST_VIDEO_FRAME_FLAG_NONE,
1239         GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB,
1240         overlay->image_width, overlay->image_height);
1241     rectangle = gst_video_overlay_rectangle_new_raw (overlay->text_image,
1242         xpos, ypos, overlay->image_width, overlay->image_height,
1243         GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA);
1244
1245     if (overlay->composition)
1246       gst_video_overlay_composition_unref (overlay->composition);
1247     overlay->composition = gst_video_overlay_composition_new (rectangle);
1248     gst_video_overlay_rectangle_unref (rectangle);
1249
1250   } else if (overlay->composition) {
1251     gst_video_overlay_composition_unref (overlay->composition);
1252     overlay->composition = NULL;
1253   }
1254 }
1255
1256 static gboolean
1257 gst_text_overlay_filter_foreground_attr (PangoAttribute * attr, gpointer data)
1258 {
1259   if (attr->klass->type == PANGO_ATTR_FOREGROUND) {
1260     return FALSE;
1261   } else {
1262     return TRUE;
1263   }
1264 }
1265
1266 static void
1267 gst_base_text_overlay_render_pangocairo (GstBaseTextOverlay * overlay,
1268     const gchar * string, gint textlen)
1269 {
1270   cairo_t *cr;
1271   cairo_surface_t *surface;
1272   PangoRectangle ink_rect, logical_rect;
1273   cairo_matrix_t cairo_matrix;
1274   int width, height;
1275   double scalef = 1.0;
1276   double a, r, g, b;
1277   GstBuffer *buffer;
1278   GstMapInfo map;
1279
1280   g_mutex_lock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
1281
1282   if (overlay->auto_adjust_size) {
1283     /* 640 pixel is default */
1284     scalef = (double) (overlay->width) / DEFAULT_SCALE_BASIS;
1285   }
1286   pango_layout_set_width (overlay->layout, -1);
1287   /* set text on pango layout */
1288   pango_layout_set_markup (overlay->layout, string, textlen);
1289
1290   /* get subtitle image size */
1291   pango_layout_get_pixel_extents (overlay->layout, &ink_rect, &logical_rect);
1292
1293   width = (logical_rect.width + overlay->shadow_offset) * scalef;
1294
1295   if (width + overlay->deltax >
1296       (overlay->use_vertical_render ? overlay->height : overlay->width)) {
1297     /*
1298      * subtitle image width is larger then overlay width
1299      * so rearrange overlay wrap mode.
1300      */
1301     gst_base_text_overlay_update_wrap_mode (overlay);
1302     pango_layout_get_pixel_extents (overlay->layout, &ink_rect, &logical_rect);
1303     width = overlay->width;
1304   }
1305
1306   height =
1307       (logical_rect.height + logical_rect.y + overlay->shadow_offset) * scalef;
1308   if (height > overlay->height) {
1309     height = overlay->height;
1310   }
1311   if (overlay->use_vertical_render) {
1312     PangoRectangle rect;
1313     PangoContext *context;
1314     PangoMatrix matrix = PANGO_MATRIX_INIT;
1315     int tmp;
1316
1317     context = pango_layout_get_context (overlay->layout);
1318
1319     pango_matrix_rotate (&matrix, -90);
1320
1321     rect.x = rect.y = 0;
1322     rect.width = width;
1323     rect.height = height;
1324     pango_matrix_transform_pixel_rectangle (&matrix, &rect);
1325     matrix.x0 = -rect.x;
1326     matrix.y0 = -rect.y;
1327
1328     pango_context_set_matrix (context, &matrix);
1329
1330     cairo_matrix.xx = matrix.xx;
1331     cairo_matrix.yx = matrix.yx;
1332     cairo_matrix.xy = matrix.xy;
1333     cairo_matrix.yy = matrix.yy;
1334     cairo_matrix.x0 = matrix.x0;
1335     cairo_matrix.y0 = matrix.y0;
1336     cairo_matrix_scale (&cairo_matrix, scalef, scalef);
1337
1338     tmp = height;
1339     height = width;
1340     width = tmp;
1341   } else {
1342     cairo_matrix_init_scale (&cairo_matrix, scalef, scalef);
1343   }
1344
1345   /* reallocate overlay buffer */
1346   buffer = gst_buffer_new_and_alloc (4 * width * height);
1347   gst_buffer_replace (&overlay->text_image, buffer);
1348   gst_buffer_unref (buffer);
1349
1350   gst_buffer_map (buffer, &map, GST_MAP_READWRITE);
1351   surface = cairo_image_surface_create_for_data (map.data,
1352       CAIRO_FORMAT_ARGB32, width, height, width * 4);
1353   cr = cairo_create (surface);
1354
1355   /* clear surface */
1356   cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
1357   cairo_paint (cr);
1358
1359   cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
1360
1361   if (overlay->want_shading)
1362     cairo_paint_with_alpha (cr, overlay->shading_value);
1363
1364   /* apply transformations */
1365   cairo_set_matrix (cr, &cairo_matrix);
1366
1367   /* FIXME: We use show_layout everywhere except for the surface
1368    * because it's really faster and internally does all kinds of
1369    * caching. Unfortunately we have to paint to a cairo path for
1370    * the outline and this is slow. Once Pango supports user fonts
1371    * we should use them, see
1372    * https://bugzilla.gnome.org/show_bug.cgi?id=598695
1373    *
1374    * Idea would the be, to create a cairo user font that
1375    * does shadow, outline, text painting in the
1376    * render_glyph function.
1377    */
1378
1379   /* draw shadow text */
1380   {
1381     PangoAttrList *origin_attr, *filtered_attr;
1382
1383     origin_attr =
1384         pango_attr_list_ref (pango_layout_get_attributes (overlay->layout));
1385     filtered_attr =
1386         pango_attr_list_filter (pango_attr_list_copy (origin_attr),
1387         gst_text_overlay_filter_foreground_attr, NULL);
1388
1389     cairo_save (cr);
1390     cairo_translate (cr, overlay->shadow_offset, overlay->shadow_offset);
1391     cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.5);
1392     pango_layout_set_attributes (overlay->layout, filtered_attr);
1393     pango_cairo_show_layout (cr, overlay->layout);
1394     pango_layout_set_attributes (overlay->layout, origin_attr);
1395     pango_attr_list_unref (filtered_attr);
1396     pango_attr_list_unref (origin_attr);
1397     cairo_restore (cr);
1398   }
1399
1400   a = (overlay->outline_color >> 24) & 0xff;
1401   r = (overlay->outline_color >> 16) & 0xff;
1402   g = (overlay->outline_color >> 8) & 0xff;
1403   b = (overlay->outline_color >> 0) & 0xff;
1404
1405   /* draw outline text */
1406   cairo_save (cr);
1407   cairo_set_source_rgba (cr, r / 255.0, g / 255.0, b / 255.0, a / 255.0);
1408   cairo_set_line_width (cr, overlay->outline_offset);
1409   pango_cairo_layout_path (cr, overlay->layout);
1410   cairo_stroke (cr);
1411   cairo_restore (cr);
1412
1413   a = (overlay->color >> 24) & 0xff;
1414   r = (overlay->color >> 16) & 0xff;
1415   g = (overlay->color >> 8) & 0xff;
1416   b = (overlay->color >> 0) & 0xff;
1417
1418   /* draw text */
1419   cairo_save (cr);
1420   cairo_set_source_rgba (cr, r / 255.0, g / 255.0, b / 255.0, a / 255.0);
1421   pango_cairo_show_layout (cr, overlay->layout);
1422   cairo_restore (cr);
1423
1424   cairo_destroy (cr);
1425   cairo_surface_destroy (surface);
1426   gst_buffer_unmap (buffer, &map);
1427   overlay->image_width = width;
1428   overlay->image_height = height;
1429   overlay->baseline_y = ink_rect.y;
1430   g_mutex_unlock (GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay)->pango_lock);
1431
1432   gst_base_text_overlay_set_composition (overlay);
1433 }
1434
1435 static inline void
1436 gst_base_text_overlay_shade_planar_Y (GstBaseTextOverlay * overlay,
1437     GstVideoFrame * dest, gint x0, gint x1, gint y0, gint y1)
1438 {
1439   gint i, j, dest_stride;
1440   guint8 *dest_ptr;
1441
1442   dest_stride = dest->info.stride[0];
1443   dest_ptr = dest->data[0];
1444
1445   for (i = y0; i < y1; ++i) {
1446     for (j = x0; j < x1; ++j) {
1447       gint y = dest_ptr[(i * dest_stride) + j] + overlay->shading_value;
1448
1449       dest_ptr[(i * dest_stride) + j] = CLAMP (y, 0, 255);
1450     }
1451   }
1452 }
1453
1454 static inline void
1455 gst_base_text_overlay_shade_packed_Y (GstBaseTextOverlay * overlay,
1456     GstVideoFrame * dest, gint x0, gint x1, gint y0, gint y1)
1457 {
1458   gint i, j;
1459   guint dest_stride, pixel_stride;
1460   guint8 *dest_ptr;
1461
1462   dest_stride = GST_VIDEO_FRAME_COMP_STRIDE (dest, 0);
1463   dest_ptr = GST_VIDEO_FRAME_COMP_DATA (dest, 0);
1464   pixel_stride = GST_VIDEO_FRAME_COMP_PSTRIDE (dest, 0);
1465
1466   if (x0 != 0)
1467     x0 = GST_VIDEO_FORMAT_INFO_SCALE_WIDTH (dest->info.finfo, 0, x0);
1468   if (x1 != 0)
1469     x1 = GST_VIDEO_FORMAT_INFO_SCALE_WIDTH (dest->info.finfo, 0, x1);
1470
1471   if (y0 != 0)
1472     y0 = GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (dest->info.finfo, 0, y0);
1473   if (y1 != 0)
1474     y1 = GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (dest->info.finfo, 0, y1);
1475
1476   for (i = y0; i < y1; i++) {
1477     for (j = x0; j < x1; j++) {
1478       gint y;
1479       gint y_pos;
1480
1481       y_pos = (i * dest_stride) + j * pixel_stride;
1482       y = dest_ptr[y_pos] + overlay->shading_value;
1483
1484       dest_ptr[y_pos] = CLAMP (y, 0, 255);
1485     }
1486   }
1487 }
1488
1489 #define gst_base_text_overlay_shade_BGRx gst_base_text_overlay_shade_xRGB
1490 #define gst_base_text_overlay_shade_RGBx gst_base_text_overlay_shade_xRGB
1491 #define gst_base_text_overlay_shade_xBGR gst_base_text_overlay_shade_xRGB
1492 static inline void
1493 gst_base_text_overlay_shade_xRGB (GstBaseTextOverlay * overlay,
1494     GstVideoFrame * dest, gint x0, gint x1, gint y0, gint y1)
1495 {
1496   gint i, j;
1497   guint8 *dest_ptr;
1498
1499   dest_ptr = dest->data[0];
1500
1501   for (i = y0; i < y1; i++) {
1502     for (j = x0; j < x1; j++) {
1503       gint y, y_pos, k;
1504
1505       y_pos = (i * 4 * overlay->width) + j * 4;
1506       for (k = 0; k < 4; k++) {
1507         y = dest_ptr[y_pos + k] + overlay->shading_value;
1508         dest_ptr[y_pos + k] = CLAMP (y, 0, 255);
1509       }
1510     }
1511   }
1512 }
1513
1514 #define ARGB_SHADE_FUNCTION(name, OFFSET)       \
1515 static inline void \
1516 gst_base_text_overlay_shade_##name (GstBaseTextOverlay * overlay, GstVideoFrame * dest, \
1517 gint x0, gint x1, gint y0, gint y1) \
1518 { \
1519   gint i, j;\
1520   guint8 *dest_ptr;\
1521   \
1522   dest_ptr = dest->data[0];\
1523   \
1524   for (i = y0; i < y1; i++) {\
1525     for (j = x0; j < x1; j++) {\
1526       gint y, y_pos, k;\
1527       y_pos = (i * 4 * overlay->width) + j * 4;\
1528       for (k = OFFSET; k < 3+OFFSET; k++) {\
1529         y = dest_ptr[y_pos + k] + overlay->shading_value;\
1530         dest_ptr[y_pos + k] = CLAMP (y, 0, 255);\
1531       }\
1532     }\
1533   }\
1534 }
1535 ARGB_SHADE_FUNCTION (ARGB, 1);
1536 ARGB_SHADE_FUNCTION (ABGR, 1);
1537 ARGB_SHADE_FUNCTION (RGBA, 0);
1538 ARGB_SHADE_FUNCTION (BGRA, 0);
1539
1540 static void
1541 gst_base_text_overlay_render_text (GstBaseTextOverlay * overlay,
1542     const gchar * text, gint textlen)
1543 {
1544   gchar *string;
1545
1546   if (!overlay->need_render) {
1547     GST_DEBUG ("Using previously rendered text.");
1548     return;
1549   }
1550
1551   /* -1 is the whole string */
1552   if (text != NULL && textlen < 0) {
1553     textlen = strlen (text);
1554   }
1555
1556   if (text != NULL) {
1557     string = g_strndup (text, textlen);
1558   } else {                      /* empty string */
1559     string = g_strdup (" ");
1560   }
1561   g_strdelimit (string, "\r\t", ' ');
1562   textlen = strlen (string);
1563
1564   /* FIXME: should we check for UTF-8 here? */
1565
1566   GST_DEBUG ("Rendering '%s'", string);
1567   gst_base_text_overlay_render_pangocairo (overlay, string, textlen);
1568
1569   g_free (string);
1570
1571   overlay->need_render = FALSE;
1572 }
1573
1574 /* FIXME: should probably be relative to width/height (adjusted for PAR) */
1575 #define BOX_XPAD  6
1576 #define BOX_YPAD  6
1577
1578 static void
1579 gst_base_text_overlay_shade_background (GstBaseTextOverlay * overlay,
1580     GstVideoFrame * frame, gint x0, gint x1, gint y0, gint y1)
1581 {
1582   x0 = CLAMP (x0 - BOX_XPAD, 0, overlay->width);
1583   x1 = CLAMP (x1 + BOX_XPAD, 0, overlay->width);
1584
1585   y0 = CLAMP (y0 - BOX_YPAD, 0, overlay->height);
1586   y1 = CLAMP (y1 + BOX_YPAD, 0, overlay->height);
1587
1588   switch (overlay->format) {
1589     case GST_VIDEO_FORMAT_I420:
1590     case GST_VIDEO_FORMAT_YV12:
1591     case GST_VIDEO_FORMAT_NV12:
1592     case GST_VIDEO_FORMAT_NV21:
1593     case GST_VIDEO_FORMAT_Y41B:
1594     case GST_VIDEO_FORMAT_Y42B:
1595     case GST_VIDEO_FORMAT_Y444:
1596     case GST_VIDEO_FORMAT_YUV9:
1597     case GST_VIDEO_FORMAT_YVU9:
1598     case GST_VIDEO_FORMAT_GRAY8:
1599       gst_base_text_overlay_shade_planar_Y (overlay, frame, x0, x1, y0, y1);
1600       break;
1601     case GST_VIDEO_FORMAT_AYUV:
1602     case GST_VIDEO_FORMAT_UYVY:
1603     case GST_VIDEO_FORMAT_YUY2:
1604     case GST_VIDEO_FORMAT_v308:
1605       gst_base_text_overlay_shade_packed_Y (overlay, frame, x0, x1, y0, y1);
1606       break;
1607     case GST_VIDEO_FORMAT_xRGB:
1608       gst_base_text_overlay_shade_xRGB (overlay, frame, x0, x1, y0, y1);
1609       break;
1610     case GST_VIDEO_FORMAT_xBGR:
1611       gst_base_text_overlay_shade_xBGR (overlay, frame, x0, x1, y0, y1);
1612       break;
1613     case GST_VIDEO_FORMAT_BGRx:
1614       gst_base_text_overlay_shade_BGRx (overlay, frame, x0, x1, y0, y1);
1615       break;
1616     case GST_VIDEO_FORMAT_RGBx:
1617       gst_base_text_overlay_shade_RGBx (overlay, frame, x0, x1, y0, y1);
1618       break;
1619     case GST_VIDEO_FORMAT_ARGB:
1620       gst_base_text_overlay_shade_ARGB (overlay, frame, x0, x1, y0, y1);
1621       break;
1622     case GST_VIDEO_FORMAT_ABGR:
1623       gst_base_text_overlay_shade_ABGR (overlay, frame, x0, x1, y0, y1);
1624       break;
1625     case GST_VIDEO_FORMAT_RGBA:
1626       gst_base_text_overlay_shade_RGBA (overlay, frame, x0, x1, y0, y1);
1627       break;
1628     case GST_VIDEO_FORMAT_BGRA:
1629       gst_base_text_overlay_shade_BGRA (overlay, frame, x0, x1, y0, y1);
1630       break;
1631     default:
1632       GST_FIXME_OBJECT (overlay, "implement background shading for format %s",
1633           gst_video_format_to_string (GST_VIDEO_FRAME_FORMAT (frame)));
1634       break;
1635   }
1636 }
1637
1638 static GstFlowReturn
1639 gst_base_text_overlay_push_frame (GstBaseTextOverlay * overlay,
1640     GstBuffer * video_frame)
1641 {
1642   GstVideoFrame frame;
1643
1644   if (overlay->composition == NULL)
1645     goto done;
1646
1647   if (gst_pad_check_reconfigure (overlay->srcpad))
1648     gst_base_text_overlay_negotiate (overlay);
1649
1650   video_frame = gst_buffer_make_writable (video_frame);
1651
1652   if (overlay->attach_compo_to_buffer) {
1653     GST_DEBUG_OBJECT (overlay, "Attaching text overlay image to video buffer");
1654     gst_buffer_add_video_overlay_composition_meta (video_frame,
1655         overlay->composition);
1656     /* FIXME: emulate shaded background box if want_shading=true */
1657     goto done;
1658   }
1659
1660   if (!gst_video_frame_map (&frame, &overlay->info, video_frame,
1661           GST_MAP_READWRITE))
1662     goto invalid_frame;
1663
1664   /* shaded background box */
1665   if (overlay->want_shading) {
1666     gint xpos, ypos;
1667
1668     gst_base_text_overlay_get_pos (overlay, &xpos, &ypos);
1669
1670     gst_base_text_overlay_shade_background (overlay, &frame,
1671         xpos, xpos + overlay->image_width, ypos, ypos + overlay->image_height);
1672   }
1673
1674   gst_video_overlay_composition_blend (overlay->composition, &frame);
1675
1676   gst_video_frame_unmap (&frame);
1677
1678 done:
1679
1680   return gst_pad_push (overlay->srcpad, video_frame);
1681
1682   /* ERRORS */
1683 invalid_frame:
1684   {
1685     gst_buffer_unref (video_frame);
1686     GST_DEBUG_OBJECT (overlay, "received invalid buffer");
1687     return GST_FLOW_OK;
1688   }
1689 }
1690
1691 static GstPadLinkReturn
1692 gst_base_text_overlay_text_pad_link (GstPad * pad, GstObject * parent,
1693     GstPad * peer)
1694 {
1695   GstBaseTextOverlay *overlay;
1696
1697   overlay = GST_BASE_TEXT_OVERLAY (parent);
1698   if (G_UNLIKELY (!overlay))
1699     return GST_PAD_LINK_REFUSED;
1700
1701   GST_DEBUG_OBJECT (overlay, "Text pad linked");
1702
1703   overlay->text_linked = TRUE;
1704
1705   return GST_PAD_LINK_OK;
1706 }
1707
1708 static void
1709 gst_base_text_overlay_text_pad_unlink (GstPad * pad, GstObject * parent)
1710 {
1711   GstBaseTextOverlay *overlay;
1712
1713   /* don't use gst_pad_get_parent() here, will deadlock */
1714   overlay = GST_BASE_TEXT_OVERLAY (parent);
1715
1716   GST_DEBUG_OBJECT (overlay, "Text pad unlinked");
1717
1718   overlay->text_linked = FALSE;
1719
1720   gst_segment_init (&overlay->text_segment, GST_FORMAT_UNDEFINED);
1721 }
1722
1723 static gboolean
1724 gst_base_text_overlay_text_event (GstPad * pad, GstObject * parent,
1725     GstEvent * event)
1726 {
1727   gboolean ret = FALSE;
1728   GstBaseTextOverlay *overlay = NULL;
1729
1730   overlay = GST_BASE_TEXT_OVERLAY (parent);
1731
1732   GST_LOG_OBJECT (pad, "received event %s", GST_EVENT_TYPE_NAME (event));
1733
1734   switch (GST_EVENT_TYPE (event)) {
1735     case GST_EVENT_CAPS:
1736     {
1737       GstCaps *caps;
1738
1739       gst_event_parse_caps (event, &caps);
1740       ret = gst_base_text_overlay_setcaps_txt (overlay, caps);
1741       gst_event_unref (event);
1742       break;
1743     }
1744     case GST_EVENT_SEGMENT:
1745     {
1746       const GstSegment *segment;
1747
1748       overlay->text_eos = FALSE;
1749
1750       gst_event_parse_segment (event, &segment);
1751
1752       if (segment->format == GST_FORMAT_TIME) {
1753         GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1754         gst_segment_copy_into (segment, &overlay->text_segment);
1755         GST_DEBUG_OBJECT (overlay, "TEXT SEGMENT now: %" GST_SEGMENT_FORMAT,
1756             &overlay->text_segment);
1757         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1758       } else {
1759         GST_ELEMENT_WARNING (overlay, STREAM, MUX, (NULL),
1760             ("received non-TIME newsegment event on text input"));
1761       }
1762
1763       gst_event_unref (event);
1764       ret = TRUE;
1765
1766       /* wake up the video chain, it might be waiting for a text buffer or
1767        * a text segment update */
1768       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1769       GST_BASE_TEXT_OVERLAY_BROADCAST (overlay);
1770       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1771       break;
1772     }
1773     case GST_EVENT_GAP:
1774     {
1775       GstClockTime start, duration;
1776
1777       gst_event_parse_gap (event, &start, &duration);
1778       if (GST_CLOCK_TIME_IS_VALID (duration))
1779         start += duration;
1780       /* we do not expect another buffer until after gap,
1781        * so that is our position now */
1782       overlay->text_segment.position = start;
1783
1784       /* wake up the video chain, it might be waiting for a text buffer or
1785        * a text segment update */
1786       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1787       GST_BASE_TEXT_OVERLAY_BROADCAST (overlay);
1788       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1789       break;
1790     }
1791     case GST_EVENT_FLUSH_STOP:
1792       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1793       GST_INFO_OBJECT (overlay, "text flush stop");
1794       overlay->text_flushing = FALSE;
1795       overlay->text_eos = FALSE;
1796       gst_base_text_overlay_pop_text (overlay);
1797       gst_segment_init (&overlay->text_segment, GST_FORMAT_TIME);
1798       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1799       gst_event_unref (event);
1800       ret = TRUE;
1801       break;
1802     case GST_EVENT_FLUSH_START:
1803       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1804       GST_INFO_OBJECT (overlay, "text flush start");
1805       overlay->text_flushing = TRUE;
1806       GST_BASE_TEXT_OVERLAY_BROADCAST (overlay);
1807       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1808       gst_event_unref (event);
1809       ret = TRUE;
1810       break;
1811     case GST_EVENT_EOS:
1812       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1813       overlay->text_eos = TRUE;
1814       GST_INFO_OBJECT (overlay, "text EOS");
1815       /* wake up the video chain, it might be waiting for a text buffer or
1816        * a text segment update */
1817       GST_BASE_TEXT_OVERLAY_BROADCAST (overlay);
1818       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1819       gst_event_unref (event);
1820       ret = TRUE;
1821       break;
1822     default:
1823       ret = gst_pad_event_default (pad, parent, event);
1824       break;
1825   }
1826
1827   return ret;
1828 }
1829
1830 static gboolean
1831 gst_base_text_overlay_video_event (GstPad * pad, GstObject * parent,
1832     GstEvent * event)
1833 {
1834   gboolean ret = FALSE;
1835   GstBaseTextOverlay *overlay = NULL;
1836
1837   overlay = GST_BASE_TEXT_OVERLAY (parent);
1838
1839   GST_DEBUG_OBJECT (pad, "received event %s", GST_EVENT_TYPE_NAME (event));
1840
1841   switch (GST_EVENT_TYPE (event)) {
1842     case GST_EVENT_CAPS:
1843     {
1844       GstCaps *caps;
1845
1846       gst_event_parse_caps (event, &caps);
1847       ret = gst_base_text_overlay_setcaps (overlay, caps);
1848       gst_event_unref (event);
1849       break;
1850     }
1851     case GST_EVENT_SEGMENT:
1852     {
1853       const GstSegment *segment;
1854
1855       GST_DEBUG_OBJECT (overlay, "received new segment");
1856
1857       gst_event_parse_segment (event, &segment);
1858
1859       if (segment->format == GST_FORMAT_TIME) {
1860         GST_DEBUG_OBJECT (overlay, "VIDEO SEGMENT now: %" GST_SEGMENT_FORMAT,
1861             &overlay->segment);
1862
1863         gst_segment_copy_into (segment, &overlay->segment);
1864       } else {
1865         GST_ELEMENT_WARNING (overlay, STREAM, MUX, (NULL),
1866             ("received non-TIME newsegment event on video input"));
1867       }
1868
1869       ret = gst_pad_event_default (pad, parent, event);
1870       break;
1871     }
1872     case GST_EVENT_EOS:
1873       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1874       GST_INFO_OBJECT (overlay, "video EOS");
1875       overlay->video_eos = TRUE;
1876       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1877       ret = gst_pad_event_default (pad, parent, event);
1878       break;
1879     case GST_EVENT_FLUSH_START:
1880       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1881       GST_INFO_OBJECT (overlay, "video flush start");
1882       overlay->video_flushing = TRUE;
1883       GST_BASE_TEXT_OVERLAY_BROADCAST (overlay);
1884       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1885       ret = gst_pad_event_default (pad, parent, event);
1886       break;
1887     case GST_EVENT_FLUSH_STOP:
1888       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1889       GST_INFO_OBJECT (overlay, "video flush stop");
1890       overlay->video_flushing = FALSE;
1891       overlay->video_eos = FALSE;
1892       gst_segment_init (&overlay->segment, GST_FORMAT_TIME);
1893       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1894       ret = gst_pad_event_default (pad, parent, event);
1895       break;
1896     default:
1897       ret = gst_pad_event_default (pad, parent, event);
1898       break;
1899   }
1900
1901   return ret;
1902 }
1903
1904 static gboolean
1905 gst_base_text_overlay_video_query (GstPad * pad, GstObject * parent,
1906     GstQuery * query)
1907 {
1908   gboolean ret = FALSE;
1909   GstBaseTextOverlay *overlay;
1910
1911   overlay = GST_BASE_TEXT_OVERLAY (parent);
1912
1913   switch (GST_QUERY_TYPE (query)) {
1914     case GST_QUERY_CAPS:
1915     {
1916       GstCaps *filter, *caps;
1917
1918       gst_query_parse_caps (query, &filter);
1919       caps = gst_base_text_overlay_getcaps (pad, overlay, filter);
1920       gst_query_set_caps_result (query, caps);
1921       gst_caps_unref (caps);
1922       ret = TRUE;
1923       break;
1924     }
1925     default:
1926       ret = gst_pad_query_default (pad, parent, query);
1927       break;
1928   }
1929
1930   return ret;
1931 }
1932
1933 /* Called with lock held */
1934 static void
1935 gst_base_text_overlay_pop_text (GstBaseTextOverlay * overlay)
1936 {
1937   g_return_if_fail (GST_IS_BASE_TEXT_OVERLAY (overlay));
1938
1939   if (overlay->text_buffer) {
1940     GST_DEBUG_OBJECT (overlay, "releasing text buffer %p",
1941         overlay->text_buffer);
1942     gst_buffer_unref (overlay->text_buffer);
1943     overlay->text_buffer = NULL;
1944   }
1945
1946   /* Let the text task know we used that buffer */
1947   GST_BASE_TEXT_OVERLAY_BROADCAST (overlay);
1948 }
1949
1950 /* We receive text buffers here. If they are out of segment we just ignore them.
1951    If the buffer is in our segment we keep it internally except if another one
1952    is already waiting here, in that case we wait that it gets kicked out */
1953 static GstFlowReturn
1954 gst_base_text_overlay_text_chain (GstPad * pad, GstObject * parent,
1955     GstBuffer * buffer)
1956 {
1957   GstFlowReturn ret = GST_FLOW_OK;
1958   GstBaseTextOverlay *overlay = NULL;
1959   gboolean in_seg = FALSE;
1960   guint64 clip_start = 0, clip_stop = 0;
1961
1962   overlay = GST_BASE_TEXT_OVERLAY (parent);
1963
1964   GST_BASE_TEXT_OVERLAY_LOCK (overlay);
1965
1966   if (overlay->text_flushing) {
1967     GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1968     ret = GST_FLOW_FLUSHING;
1969     GST_LOG_OBJECT (overlay, "text flushing");
1970     goto beach;
1971   }
1972
1973   if (overlay->text_eos) {
1974     GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
1975     ret = GST_FLOW_EOS;
1976     GST_LOG_OBJECT (overlay, "text EOS");
1977     goto beach;
1978   }
1979
1980   GST_LOG_OBJECT (overlay, "%" GST_SEGMENT_FORMAT "  BUFFER: ts=%"
1981       GST_TIME_FORMAT ", end=%" GST_TIME_FORMAT, &overlay->segment,
1982       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
1983       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer) +
1984           GST_BUFFER_DURATION (buffer)));
1985
1986   if (G_LIKELY (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))) {
1987     GstClockTime stop;
1988
1989     if (G_LIKELY (GST_BUFFER_DURATION_IS_VALID (buffer)))
1990       stop = GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer);
1991     else
1992       stop = GST_CLOCK_TIME_NONE;
1993
1994     in_seg = gst_segment_clip (&overlay->text_segment, GST_FORMAT_TIME,
1995         GST_BUFFER_TIMESTAMP (buffer), stop, &clip_start, &clip_stop);
1996   } else {
1997     in_seg = TRUE;
1998   }
1999
2000   if (in_seg) {
2001     if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
2002       GST_BUFFER_TIMESTAMP (buffer) = clip_start;
2003     else if (GST_BUFFER_DURATION_IS_VALID (buffer))
2004       GST_BUFFER_DURATION (buffer) = clip_stop - clip_start;
2005
2006     /* Wait for the previous buffer to go away */
2007     while (overlay->text_buffer != NULL) {
2008       GST_DEBUG ("Pad %s:%s has a buffer queued, waiting",
2009           GST_DEBUG_PAD_NAME (pad));
2010       GST_BASE_TEXT_OVERLAY_WAIT (overlay);
2011       GST_DEBUG ("Pad %s:%s resuming", GST_DEBUG_PAD_NAME (pad));
2012       if (overlay->text_flushing) {
2013         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2014         ret = GST_FLOW_FLUSHING;
2015         goto beach;
2016       }
2017     }
2018
2019     if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
2020       overlay->text_segment.position = clip_start;
2021
2022     overlay->text_buffer = buffer;
2023     /* That's a new text buffer we need to render */
2024     overlay->need_render = TRUE;
2025
2026     /* in case the video chain is waiting for a text buffer, wake it up */
2027     GST_BASE_TEXT_OVERLAY_BROADCAST (overlay);
2028   }
2029
2030   GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2031
2032 beach:
2033
2034   return ret;
2035 }
2036
2037 static GstFlowReturn
2038 gst_base_text_overlay_video_chain (GstPad * pad, GstObject * parent,
2039     GstBuffer * buffer)
2040 {
2041   GstBaseTextOverlayClass *klass;
2042   GstBaseTextOverlay *overlay;
2043   GstFlowReturn ret = GST_FLOW_OK;
2044   gboolean in_seg = FALSE;
2045   guint64 start, stop, clip_start = 0, clip_stop = 0;
2046   gchar *text = NULL;
2047
2048   overlay = GST_BASE_TEXT_OVERLAY (parent);
2049   klass = GST_BASE_TEXT_OVERLAY_GET_CLASS (overlay);
2050
2051   if (!GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
2052     goto missing_timestamp;
2053
2054   /* ignore buffers that are outside of the current segment */
2055   start = GST_BUFFER_TIMESTAMP (buffer);
2056
2057   if (!GST_BUFFER_DURATION_IS_VALID (buffer)) {
2058     stop = GST_CLOCK_TIME_NONE;
2059   } else {
2060     stop = start + GST_BUFFER_DURATION (buffer);
2061   }
2062
2063   GST_LOG_OBJECT (overlay, "%" GST_SEGMENT_FORMAT "  BUFFER: ts=%"
2064       GST_TIME_FORMAT ", end=%" GST_TIME_FORMAT, &overlay->segment,
2065       GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
2066
2067   /* segment_clip() will adjust start unconditionally to segment_start if
2068    * no stop time is provided, so handle this ourselves */
2069   if (stop == GST_CLOCK_TIME_NONE && start < overlay->segment.start)
2070     goto out_of_segment;
2071
2072   in_seg = gst_segment_clip (&overlay->segment, GST_FORMAT_TIME, start, stop,
2073       &clip_start, &clip_stop);
2074
2075   if (!in_seg)
2076     goto out_of_segment;
2077
2078   /* if the buffer is only partially in the segment, fix up stamps */
2079   if (clip_start != start || (stop != -1 && clip_stop != stop)) {
2080     GST_DEBUG_OBJECT (overlay, "clipping buffer timestamp/duration to segment");
2081     buffer = gst_buffer_make_writable (buffer);
2082     GST_BUFFER_TIMESTAMP (buffer) = clip_start;
2083     if (stop != -1)
2084       GST_BUFFER_DURATION (buffer) = clip_stop - clip_start;
2085   }
2086
2087   /* now, after we've done the clipping, fix up end time if there's no
2088    * duration (we only use those estimated values internally though, we
2089    * don't want to set bogus values on the buffer itself) */
2090   if (stop == -1) {
2091     GstCaps *caps;
2092     GstStructure *s;
2093     gint fps_num, fps_denom;
2094
2095     /* FIXME, store this in setcaps */
2096     caps = gst_pad_get_current_caps (pad);
2097     s = gst_caps_get_structure (caps, 0);
2098     if (gst_structure_get_fraction (s, "framerate", &fps_num, &fps_denom) &&
2099         fps_num && fps_denom) {
2100       GST_DEBUG_OBJECT (overlay, "estimating duration based on framerate");
2101       stop = start + gst_util_uint64_scale_int (GST_SECOND, fps_denom, fps_num);
2102     } else {
2103       GST_WARNING_OBJECT (overlay, "no duration, assuming minimal duration");
2104       stop = start + 1;         /* we need to assume some interval */
2105     }
2106     gst_caps_unref (caps);
2107   }
2108
2109   gst_object_sync_values (GST_OBJECT (overlay), GST_BUFFER_TIMESTAMP (buffer));
2110
2111 wait_for_text_buf:
2112
2113   GST_BASE_TEXT_OVERLAY_LOCK (overlay);
2114
2115   if (overlay->video_flushing)
2116     goto flushing;
2117
2118   if (overlay->video_eos)
2119     goto have_eos;
2120
2121   if (overlay->silent) {
2122     GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2123     ret = gst_pad_push (overlay->srcpad, buffer);
2124
2125     /* Update position */
2126     overlay->segment.position = clip_start;
2127
2128     return ret;
2129   }
2130
2131   /* Text pad not linked, rendering internal text */
2132   if (!overlay->text_linked) {
2133     if (klass->get_text) {
2134       text = klass->get_text (overlay, buffer);
2135     } else {
2136       text = g_strdup (overlay->default_text);
2137     }
2138
2139     GST_LOG_OBJECT (overlay, "Text pad not linked, rendering default "
2140         "text: '%s'", GST_STR_NULL (text));
2141
2142     GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2143
2144     if (text != NULL && *text != '\0') {
2145       /* Render and push */
2146       gst_base_text_overlay_render_text (overlay, text, -1);
2147       ret = gst_base_text_overlay_push_frame (overlay, buffer);
2148     } else {
2149       /* Invalid or empty string */
2150       ret = gst_pad_push (overlay->srcpad, buffer);
2151     }
2152   } else {
2153     /* Text pad linked, check if we have a text buffer queued */
2154     if (overlay->text_buffer) {
2155       gboolean pop_text = FALSE, valid_text_time = TRUE;
2156       GstClockTime text_start = GST_CLOCK_TIME_NONE;
2157       GstClockTime text_end = GST_CLOCK_TIME_NONE;
2158       GstClockTime text_running_time = GST_CLOCK_TIME_NONE;
2159       GstClockTime text_running_time_end = GST_CLOCK_TIME_NONE;
2160       GstClockTime vid_running_time, vid_running_time_end;
2161
2162       /* if the text buffer isn't stamped right, pop it off the
2163        * queue and display it for the current video frame only */
2164       if (!GST_BUFFER_TIMESTAMP_IS_VALID (overlay->text_buffer) ||
2165           !GST_BUFFER_DURATION_IS_VALID (overlay->text_buffer)) {
2166         GST_WARNING_OBJECT (overlay,
2167             "Got text buffer with invalid timestamp or duration");
2168         pop_text = TRUE;
2169         valid_text_time = FALSE;
2170       } else {
2171         text_start = GST_BUFFER_TIMESTAMP (overlay->text_buffer);
2172         text_end = text_start + GST_BUFFER_DURATION (overlay->text_buffer);
2173       }
2174
2175       vid_running_time =
2176           gst_segment_to_running_time (&overlay->segment, GST_FORMAT_TIME,
2177           start);
2178       vid_running_time_end =
2179           gst_segment_to_running_time (&overlay->segment, GST_FORMAT_TIME,
2180           stop);
2181
2182       /* If timestamp and duration are valid */
2183       if (valid_text_time) {
2184         text_running_time =
2185             gst_segment_to_running_time (&overlay->segment, GST_FORMAT_TIME,
2186             text_start);
2187         text_running_time_end =
2188             gst_segment_to_running_time (&overlay->segment, GST_FORMAT_TIME,
2189             text_end);
2190       }
2191
2192       GST_LOG_OBJECT (overlay, "T: %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
2193           GST_TIME_ARGS (text_running_time),
2194           GST_TIME_ARGS (text_running_time_end));
2195       GST_LOG_OBJECT (overlay, "V: %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
2196           GST_TIME_ARGS (vid_running_time),
2197           GST_TIME_ARGS (vid_running_time_end));
2198
2199       /* Text too old or in the future */
2200       if (valid_text_time && text_running_time_end <= vid_running_time) {
2201         /* text buffer too old, get rid of it and do nothing  */
2202         GST_LOG_OBJECT (overlay, "text buffer too old, popping");
2203         pop_text = FALSE;
2204         gst_base_text_overlay_pop_text (overlay);
2205         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2206         goto wait_for_text_buf;
2207       } else if (valid_text_time && vid_running_time_end <= text_running_time) {
2208         GST_LOG_OBJECT (overlay, "text in future, pushing video buf");
2209         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2210         /* Push the video frame */
2211         ret = gst_pad_push (overlay->srcpad, buffer);
2212       } else {
2213         GstMapInfo map;
2214         gchar *in_text;
2215         gsize in_size;
2216
2217         gst_buffer_map (overlay->text_buffer, &map, GST_MAP_READ);
2218         in_text = (gchar *) map.data;
2219         in_size = map.size;
2220
2221         if (in_size > 0) {
2222           /* g_markup_escape_text() absolutely requires valid UTF8 input, it
2223            * might crash otherwise. We don't fall back on GST_SUBTITLE_ENCODING
2224            * here on purpose, this is something that needs fixing upstream */
2225           if (!g_utf8_validate (in_text, in_size, NULL)) {
2226             const gchar *end = NULL;
2227
2228             GST_WARNING_OBJECT (overlay, "received invalid UTF-8");
2229             in_text = g_strndup (in_text, in_size);
2230             while (!g_utf8_validate (in_text, in_size, &end) && end)
2231               *((gchar *) end) = '*';
2232           }
2233
2234           /* Get the string */
2235           if (overlay->have_pango_markup) {
2236             text = g_strndup (in_text, in_size);
2237           } else {
2238             text = g_markup_escape_text (in_text, in_size);
2239           }
2240
2241           if (text != NULL && *text != '\0') {
2242             gint text_len = strlen (text);
2243
2244             while (text_len > 0 && (text[text_len - 1] == '\n' ||
2245                     text[text_len - 1] == '\r')) {
2246               --text_len;
2247             }
2248             GST_DEBUG_OBJECT (overlay, "Rendering text '%*s'", text_len, text);
2249             gst_base_text_overlay_render_text (overlay, text, text_len);
2250           } else {
2251             GST_DEBUG_OBJECT (overlay, "No text to render (empty buffer)");
2252             gst_base_text_overlay_render_text (overlay, " ", 1);
2253           }
2254           if (in_text != (gchar *) map.data)
2255             g_free (in_text);
2256         } else {
2257           GST_DEBUG_OBJECT (overlay, "No text to render (empty buffer)");
2258           gst_base_text_overlay_render_text (overlay, " ", 1);
2259         }
2260
2261         gst_buffer_unmap (overlay->text_buffer, &map);
2262
2263         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2264         ret = gst_base_text_overlay_push_frame (overlay, buffer);
2265
2266         if (valid_text_time && text_running_time_end <= vid_running_time_end) {
2267           GST_LOG_OBJECT (overlay, "text buffer not needed any longer");
2268           pop_text = TRUE;
2269         }
2270       }
2271       if (pop_text) {
2272         GST_BASE_TEXT_OVERLAY_LOCK (overlay);
2273         gst_base_text_overlay_pop_text (overlay);
2274         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2275       }
2276     } else {
2277       gboolean wait_for_text_buf = TRUE;
2278
2279       if (overlay->text_eos)
2280         wait_for_text_buf = FALSE;
2281
2282       if (!overlay->wait_text)
2283         wait_for_text_buf = FALSE;
2284
2285       /* Text pad linked, but no text buffer available - what now? */
2286       if (overlay->text_segment.format == GST_FORMAT_TIME) {
2287         GstClockTime text_start_running_time, text_position_running_time;
2288         GstClockTime vid_running_time;
2289
2290         vid_running_time =
2291             gst_segment_to_running_time (&overlay->segment, GST_FORMAT_TIME,
2292             GST_BUFFER_TIMESTAMP (buffer));
2293         text_start_running_time =
2294             gst_segment_to_running_time (&overlay->text_segment,
2295             GST_FORMAT_TIME, overlay->text_segment.start);
2296         text_position_running_time =
2297             gst_segment_to_running_time (&overlay->text_segment,
2298             GST_FORMAT_TIME, overlay->text_segment.position);
2299
2300         if ((GST_CLOCK_TIME_IS_VALID (text_start_running_time) &&
2301                 vid_running_time < text_start_running_time) ||
2302             (GST_CLOCK_TIME_IS_VALID (text_position_running_time) &&
2303                 vid_running_time < text_position_running_time)) {
2304           wait_for_text_buf = FALSE;
2305         }
2306       }
2307
2308       if (wait_for_text_buf) {
2309         GST_DEBUG_OBJECT (overlay, "no text buffer, need to wait for one");
2310         GST_BASE_TEXT_OVERLAY_WAIT (overlay);
2311         GST_DEBUG_OBJECT (overlay, "resuming");
2312         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2313         goto wait_for_text_buf;
2314       } else {
2315         GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2316         GST_LOG_OBJECT (overlay, "no need to wait for a text buffer");
2317         ret = gst_pad_push (overlay->srcpad, buffer);
2318       }
2319     }
2320   }
2321
2322   g_free (text);
2323
2324   /* Update position */
2325   overlay->segment.position = clip_start;
2326
2327   return ret;
2328
2329 missing_timestamp:
2330   {
2331     GST_WARNING_OBJECT (overlay, "buffer without timestamp, discarding");
2332     gst_buffer_unref (buffer);
2333     return GST_FLOW_OK;
2334   }
2335
2336 flushing:
2337   {
2338     GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2339     GST_DEBUG_OBJECT (overlay, "flushing, discarding buffer");
2340     gst_buffer_unref (buffer);
2341     return GST_FLOW_FLUSHING;
2342   }
2343 have_eos:
2344   {
2345     GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2346     GST_DEBUG_OBJECT (overlay, "eos, discarding buffer");
2347     gst_buffer_unref (buffer);
2348     return GST_FLOW_EOS;
2349   }
2350 out_of_segment:
2351   {
2352     GST_DEBUG_OBJECT (overlay, "buffer out of segment, discarding");
2353     gst_buffer_unref (buffer);
2354     return GST_FLOW_OK;
2355   }
2356 }
2357
2358 static GstStateChangeReturn
2359 gst_base_text_overlay_change_state (GstElement * element,
2360     GstStateChange transition)
2361 {
2362   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
2363   GstBaseTextOverlay *overlay = GST_BASE_TEXT_OVERLAY (element);
2364
2365   switch (transition) {
2366     case GST_STATE_CHANGE_PAUSED_TO_READY:
2367       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
2368       overlay->text_flushing = TRUE;
2369       overlay->video_flushing = TRUE;
2370       /* pop_text will broadcast on the GCond and thus also make the video
2371        * chain exit if it's waiting for a text buffer */
2372       gst_base_text_overlay_pop_text (overlay);
2373       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2374       break;
2375     default:
2376       break;
2377   }
2378
2379   ret = parent_class->change_state (element, transition);
2380   if (ret == GST_STATE_CHANGE_FAILURE)
2381     return ret;
2382
2383   switch (transition) {
2384     case GST_STATE_CHANGE_READY_TO_PAUSED:
2385       GST_BASE_TEXT_OVERLAY_LOCK (overlay);
2386       overlay->text_flushing = FALSE;
2387       overlay->video_flushing = FALSE;
2388       overlay->video_eos = FALSE;
2389       overlay->text_eos = FALSE;
2390       gst_segment_init (&overlay->segment, GST_FORMAT_TIME);
2391       gst_segment_init (&overlay->text_segment, GST_FORMAT_TIME);
2392       GST_BASE_TEXT_OVERLAY_UNLOCK (overlay);
2393       break;
2394     default:
2395       break;
2396   }
2397
2398   return ret;
2399 }
2400
2401 static gboolean
2402 plugin_init (GstPlugin * plugin)
2403 {
2404   if (!gst_element_register (plugin, "textoverlay", GST_RANK_NONE,
2405           GST_TYPE_TEXT_OVERLAY) ||
2406       !gst_element_register (plugin, "timeoverlay", GST_RANK_NONE,
2407           GST_TYPE_TIME_OVERLAY) ||
2408       !gst_element_register (plugin, "clockoverlay", GST_RANK_NONE,
2409           GST_TYPE_CLOCK_OVERLAY) ||
2410       !gst_element_register (plugin, "textrender", GST_RANK_NONE,
2411           GST_TYPE_TEXT_RENDER)) {
2412     return FALSE;
2413   }
2414
2415   /*texttestsrc_plugin_init(module, plugin); */
2416
2417   GST_DEBUG_CATEGORY_INIT (pango_debug, "pango", 0, "Pango elements");
2418
2419   return TRUE;
2420 }
2421
2422 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR,
2423     pango, "Pango-based text rendering and overlay", plugin_init,
2424     VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)