ext/pango/gsttextrender.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) <2009> Young-Ho Cha <ganadist@gmail.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22
  23 /**
  24  * SECTION:element-textrender
  25  * @title: textrender
  26  * @see_also: #GstTextOverlay
  27  *
  28  * This plugin renders text received on the text sink pad to a video
  29  * buffer (retaining the alpha channel), so it can later be overlayed
  30  * on top of video streams using other elements.
  31  *
  32  * The text can contain newline characters. (FIXME: What about text
  33  * wrapping? It does not make sense in this context)
  34  *
  35  * ## Example launch lines
  36  * |[
  37  * gst-launch-1.0 -v filesrc location=subtitles.srt ! subparse ! textrender ! videoconvert ! autovideosink
  38  * ]|
  39  *
  40  */
  41
  42 #ifdef HAVE_CONFIG_H
  43 #include <config.h>
  44 #endif
  45
  46 #include <gst/gst.h>
  47 #include <gst/video/video.h>
  48
  49 #include "gsttextrender.h"
  50 #include <string.h>
  51
  52 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
  53 # define CAIRO_ARGB_A 3
  54 # define CAIRO_ARGB_R 2
  55 # define CAIRO_ARGB_G 1
  56 # define CAIRO_ARGB_B 0
  57 #else
  58 # define CAIRO_ARGB_A 0
  59 # define CAIRO_ARGB_R 1
  60 # define CAIRO_ARGB_G 2
  61 # define CAIRO_ARGB_B 3
  62 #endif
  63
  64 GST_DEBUG_CATEGORY_EXTERN (pango_debug);
  65 #define GST_CAT_DEFAULT pango_debug
  66
  67 #define MINIMUM_OUTLINE_OFFSET 1.0
  68
  69 #define DEFAULT_PROP_VALIGNMENT GST_TEXT_RENDER_VALIGN_BASELINE
  70 #define DEFAULT_PROP_HALIGNMENT GST_TEXT_RENDER_HALIGN_CENTER
  71 #define DEFAULT_PROP_LINE_ALIGNMENT GST_TEXT_RENDER_LINE_ALIGN_CENTER
  72 #define DEFAULT_PROP_XPAD       25
  73 #define DEFAULT_PROP_YPAD       25
  74
  75 #define DEFAULT_RENDER_WIDTH 720
  76 #define DEFAULT_RENDER_HEIGHT 576
  77
  78 enum
  79 {
  80   PROP_0,
  81   PROP_HALIGNMENT,
  82   PROP_VALIGNMENT,
  83   PROP_LINE_ALIGNMENT,
  84   PROP_XPAD,
  85   PROP_YPAD,
  86   PROP_FONT_DESC
  87 };
  88
  89 #define VIDEO_FORMATS "{ AYUV, ARGB } "
  90
  91 static GstStaticPadTemplate src_template_factory =
  92 GST_STATIC_PAD_TEMPLATE ("src",
  93     GST_PAD_SRC,
  94     GST_PAD_ALWAYS,
  95     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (VIDEO_FORMATS))
  96     );
  97
  98 static GstStaticPadTemplate sink_template_factory =
  99 GST_STATIC_PAD_TEMPLATE ("sink",
 100     GST_PAD_SINK,
 101     GST_PAD_ALWAYS,
 102     GST_STATIC_CAPS ("text/x-raw, format = { pango-markup, utf8 }")
 103     );
 104
 105 #define GST_TYPE_TEXT_RENDER_VALIGN (gst_text_render_valign_get_type())
 106 static GType
 107 gst_text_render_valign_get_type (void)
 108 {
 109   static GType text_render_valign_type = 0;
 110   static const GEnumValue text_render_valign[] = {
 111     {GST_TEXT_RENDER_VALIGN_BASELINE, "baseline", "baseline"},
 112     {GST_TEXT_RENDER_VALIGN_BOTTOM, "bottom", "bottom"},
 113     {GST_TEXT_RENDER_VALIGN_TOP, "top", "top"},
 114     {0, NULL, NULL},
 115   };
 116
 117   if (!text_render_valign_type) {
 118     text_render_valign_type =
 119         g_enum_register_static ("GstTextRenderVAlign", text_render_valign);
 120   }
 121   return text_render_valign_type;
 122 }
 123
 124 #define GST_TYPE_TEXT_RENDER_HALIGN (gst_text_render_halign_get_type())
 125 static GType
 126 gst_text_render_halign_get_type (void)
 127 {
 128   static GType text_render_halign_type = 0;
 129   static const GEnumValue text_render_halign[] = {
 130     {GST_TEXT_RENDER_HALIGN_LEFT, "left", "left"},
 131     {GST_TEXT_RENDER_HALIGN_CENTER, "center", "center"},
 132     {GST_TEXT_RENDER_HALIGN_RIGHT, "right", "right"},
 133     {0, NULL, NULL},
 134   };
 135
 136   if (!text_render_halign_type) {
 137     text_render_halign_type =
 138         g_enum_register_static ("GstTextRenderHAlign", text_render_halign);
 139   }
 140   return text_render_halign_type;
 141 }
 142
 143 #define GST_TYPE_TEXT_RENDER_LINE_ALIGN (gst_text_render_line_align_get_type())
 144 static GType
 145 gst_text_render_line_align_get_type (void)
 146 {
 147   static GType text_render_line_align_type = 0;
 148   static const GEnumValue text_render_line_align[] = {
 149     {GST_TEXT_RENDER_LINE_ALIGN_LEFT, "left", "left"},
 150     {GST_TEXT_RENDER_LINE_ALIGN_CENTER, "center", "center"},
 151     {GST_TEXT_RENDER_LINE_ALIGN_RIGHT, "right", "right"},
 152     {0, NULL, NULL}
 153   };
 154
 155   if (!text_render_line_align_type) {
 156     text_render_line_align_type =
 157         g_enum_register_static ("GstTextRenderLineAlign",
 158         text_render_line_align);
 159   }
 160   return text_render_line_align_type;
 161 }
 162
 163 static void gst_text_render_adjust_values_with_fontdesc (GstTextRender *
 164     render, PangoFontDescription * desc);
 165
 166 #define gst_text_render_parent_class parent_class
 167 G_DEFINE_TYPE (GstTextRender, gst_text_render, GST_TYPE_ELEMENT);
 168
 169 static void gst_text_render_finalize (GObject * object);
 170 static void gst_text_render_set_property (GObject * object,
 171     guint prop_id, const GValue * value, GParamSpec * pspec);
 172 static void gst_text_render_get_property (GObject * object,
 173     guint prop_id, GValue * value, GParamSpec * pspec);
 174
 175 static void
 176 gst_text_render_class_init (GstTextRenderClass * klass)
 177 {
 178   GObjectClass *gobject_class;
 179   GstElementClass *gstelement_class;
 180
 181   gobject_class = (GObjectClass *) klass;
 182   gstelement_class = (GstElementClass *) klass;
 183
 184   parent_class = g_type_class_peek_parent (klass);
 185
 186   gobject_class->finalize = gst_text_render_finalize;
 187   gobject_class->set_property = gst_text_render_set_property;
 188   gobject_class->get_property = gst_text_render_get_property;
 189
 190   gst_element_class_add_static_pad_template (gstelement_class,
 191       &src_template_factory);
 192   gst_element_class_add_static_pad_template (gstelement_class,
 193       &sink_template_factory);
 194
 195   gst_element_class_set_static_metadata (gstelement_class, "Text renderer",
 196       "Filter/Editor/Video",
 197       "Renders a text string to an image bitmap",
 198       "David Schleef <ds@schleef.org>, "
 199       "GStreamer maintainers <gstreamer-devel@lists.freedesktop.org>");
 200
 201   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FONT_DESC,
 202       g_param_spec_string ("font-desc", "font description",
 203           "Pango font description of font "
 204           "to be used for rendering. "
 205           "See documentation of "
 206           "pango_font_description_from_string"
 207           " for syntax.", "", G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
 208   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_VALIGNMENT,
 209       g_param_spec_enum ("valignment", "vertical alignment",
 210           "Vertical alignment of the text", GST_TYPE_TEXT_RENDER_VALIGN,
 211           DEFAULT_PROP_VALIGNMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 212   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HALIGNMENT,
 213       g_param_spec_enum ("halignment", "horizontal alignment",
 214           "Horizontal alignment of the text", GST_TYPE_TEXT_RENDER_HALIGN,
 215           DEFAULT_PROP_HALIGNMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 216   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_XPAD,
 217       g_param_spec_int ("xpad", "horizontal paddding",
 218           "Horizontal paddding when using left/right alignment", 0, G_MAXINT,
 219           DEFAULT_PROP_XPAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 220   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_YPAD,
 221       g_param_spec_int ("ypad", "vertical padding",
 222           "Vertical padding when using top/bottom alignment", 0, G_MAXINT,
 223           DEFAULT_PROP_YPAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 224   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_LINE_ALIGNMENT,
 225       g_param_spec_enum ("line-alignment", "line alignment",
 226           "Alignment of text lines relative to each other.",
 227           GST_TYPE_TEXT_RENDER_LINE_ALIGN, DEFAULT_PROP_LINE_ALIGNMENT,
 228           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 229
 230   gst_type_mark_as_plugin_api (GST_TYPE_TEXT_RENDER_HALIGN, 0);
 231   gst_type_mark_as_plugin_api (GST_TYPE_TEXT_RENDER_VALIGN, 0);
 232   gst_type_mark_as_plugin_api (GST_TYPE_TEXT_RENDER_LINE_ALIGN, 0);
 233 }
 234
 235 static void
 236 gst_text_render_adjust_values_with_fontdesc (GstTextRender * render,
 237     PangoFontDescription * desc)
 238 {
 239   gint font_size = pango_font_description_get_size (desc) / PANGO_SCALE;
 240
 241   render->shadow_offset = (double) (font_size) / 13.0;
 242   render->outline_offset = (double) (font_size) / 15.0;
 243   if (render->outline_offset < MINIMUM_OUTLINE_OFFSET)
 244     render->outline_offset = MINIMUM_OUTLINE_OFFSET;
 245 }
 246
 247 static void
 248 gst_text_render_render_pangocairo (GstTextRender * render)
 249 {
 250   cairo_t *cr;
 251   cairo_surface_t *surface;
 252   cairo_t *cr_shadow;
 253   cairo_surface_t *surface_shadow;
 254   PangoRectangle ink_rect, logical_rect;
 255   gint width, height;
 256
 257   pango_layout_get_pixel_extents (render->layout, &ink_rect, &logical_rect);
 258
 259   width = logical_rect.width + render->shadow_offset;
 260   height = logical_rect.height + logical_rect.y + render->shadow_offset;
 261
 262   surface_shadow = cairo_image_surface_create (CAIRO_FORMAT_A8, width, height);
 263   cr_shadow = cairo_create (surface_shadow);
 264
 265   /* clear shadow surface */
 266   cairo_set_operator (cr_shadow, CAIRO_OPERATOR_CLEAR);
 267   cairo_paint (cr_shadow);
 268   cairo_set_operator (cr_shadow, CAIRO_OPERATOR_OVER);
 269
 270   /* draw shadow text */
 271   cairo_save (cr_shadow);
 272   cairo_set_source_rgba (cr_shadow, 0.0, 0.0, 0.0, 0.5);
 273   cairo_translate (cr_shadow, render->shadow_offset, render->shadow_offset);
 274   pango_cairo_show_layout (cr_shadow, render->layout);
 275   cairo_restore (cr_shadow);
 276
 277   /* draw outline text */
 278   cairo_save (cr_shadow);
 279   cairo_set_source_rgb (cr_shadow, 0.0, 0.0, 0.0);
 280   cairo_set_line_width (cr_shadow, render->outline_offset);
 281   pango_cairo_layout_path (cr_shadow, render->layout);
 282   cairo_stroke (cr_shadow);
 283   cairo_restore (cr_shadow);
 284
 285   cairo_destroy (cr_shadow);
 286
 287   render->text_image = g_realloc (render->text_image, 4 * width * height);
 288
 289   surface = cairo_image_surface_create_for_data (render->text_image,
 290       CAIRO_FORMAT_ARGB32, width, height, width * 4);
 291   cr = cairo_create (surface);
 292   cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
 293   cairo_paint (cr);
 294   cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 295
 296   /* set default color */
 297   cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
 298
 299   cairo_save (cr);
 300   /* draw text */
 301   pango_cairo_show_layout (cr, render->layout);
 302   cairo_restore (cr);
 303
 304   /* composite shadow with offset */
 305   cairo_set_operator (cr, CAIRO_OPERATOR_DEST_OVER);
 306   cairo_set_source_surface (cr, surface_shadow, 0.0, 0.0);
 307   cairo_paint (cr);
 308
 309   cairo_destroy (cr);
 310   cairo_surface_destroy (surface_shadow);
 311   cairo_surface_destroy (surface);
 312   render->image_width = width;
 313   render->image_height = height;
 314 }
 315
 316 static void
 317 gst_text_render_check_argb (GstTextRender * render)
 318 {
 319   GstCaps *peer_caps;
 320   peer_caps = gst_pad_get_allowed_caps (render->srcpad);
 321   if (G_LIKELY (peer_caps)) {
 322     guint i = 0, n = 0;
 323
 324     n = gst_caps_get_size (peer_caps);
 325     GST_DEBUG_OBJECT (render, "peer allowed caps (%u structure(s)) are %"
 326         GST_PTR_FORMAT, n, peer_caps);
 327
 328     /* Check if AYUV or ARGB is first */
 329     for (i = 0; i < n; i++) {
 330       GstStructure *s;
 331       GstVideoFormat vformat;
 332       const GstVideoFormatInfo *info;
 333       const gchar *fmt;
 334
 335       s = gst_caps_get_structure (peer_caps, i);
 336       if (!gst_structure_has_name (s, "video/x-raw"))
 337         continue;
 338
 339       fmt = gst_structure_get_string (s, "format");
 340       if (fmt == NULL)
 341         continue;
 342
 343       vformat = gst_video_format_from_string (fmt);
 344       info = gst_video_format_get_info (vformat);
 345       if (info == NULL)
 346         continue;
 347
 348       render->use_ARGB = GST_VIDEO_FORMAT_INFO_IS_RGB (info);
 349     }
 350     gst_caps_unref (peer_caps);
 351   }
 352 }
 353
 354 static gboolean
 355 gst_text_render_src_setcaps (GstTextRender * render, GstCaps * caps)
 356 {
 357   GstStructure *structure;
 358   gboolean ret;
 359   gint width = 0, height = 0;
 360
 361   structure = gst_caps_get_structure (caps, 0);
 362   gst_structure_get_int (structure, "width", &width);
 363   gst_structure_get_int (structure, "height", &height);
 364
 365   GST_DEBUG_OBJECT (render, "Got caps %" GST_PTR_FORMAT, caps);
 366
 367   if (width >= render->image_width && height >= render->image_height) {
 368     render->width = width;
 369     render->height = height;
 370   }
 371
 372   gst_text_render_check_argb (render);
 373
 374   ret = gst_pad_set_caps (render->srcpad, caps);
 375
 376   return ret;
 377 }
 378
 379 static GstCaps *
 380 gst_text_render_fixate_caps (GstTextRender * render, GstCaps * caps)
 381 {
 382   GstStructure *s;
 383
 384   caps = gst_caps_truncate (caps);
 385
 386   caps = gst_caps_make_writable (caps);
 387   s = gst_caps_get_structure (caps, 0);
 388
 389   GST_DEBUG ("Fixating caps %" GST_PTR_FORMAT, caps);
 390   gst_structure_fixate_field_nearest_int (s, "width", MAX (render->image_width,
 391           DEFAULT_RENDER_WIDTH));
 392   gst_structure_fixate_field_nearest_int (s, "height",
 393       MAX (render->image_height + render->ypad, DEFAULT_RENDER_HEIGHT));
 394   caps = gst_caps_fixate (caps);
 395   GST_DEBUG ("Fixated to    %" GST_PTR_FORMAT, caps);
 396
 397   return caps;
 398 }
 399
 400 #define CAIRO_UNPREMULTIPLY(a,r,g,b) G_STMT_START { \
 401   b = (a > 0) ? MIN ((b * 255 + a / 2) / a, 255) : 0; \
 402   g = (a > 0) ? MIN ((g * 255 + a / 2) / a, 255) : 0; \
 403   r = (a > 0) ? MIN ((r * 255 + a / 2) / a, 255) : 0; \
 404 } G_STMT_END
 405
 406 static void
 407 gst_text_renderer_image_to_ayuv (GstTextRender * render, guchar * pixbuf,
 408     int xpos, int ypos, int stride)
 409 {
 410   int y;                        /* text bitmap coordinates */
 411   guchar *p, *bitp;
 412   guchar a, r, g, b;
 413   int width, height;
 414
 415   width = render->image_width;
 416   height = render->image_height;
 417
 418   for (y = 0; y < height && ypos + y < render->height; y++) {
 419     int n;
 420     p = pixbuf + (ypos + y) * stride + xpos * 4;
 421     bitp = render->text_image + y * width * 4;
 422     for (n = 0; n < width && n < render->width; n++) {
 423       b = bitp[CAIRO_ARGB_B];
 424       g = bitp[CAIRO_ARGB_G];
 425       r = bitp[CAIRO_ARGB_R];
 426       a = bitp[CAIRO_ARGB_A];
 427       bitp += 4;
 428
 429       /* Cairo uses pre-multiplied ARGB, unpremultiply it */
 430       CAIRO_UNPREMULTIPLY (a, r, g, b);
 431
 432       *p++ = a;
 433       *p++ = CLAMP ((int) (((19595 * r) >> 16) + ((38470 * g) >> 16) +
 434               ((7471 * b) >> 16)), 0, 255);
 435       *p++ = CLAMP ((int) (-((11059 * r) >> 16) - ((21709 * g) >> 16) +
 436               ((32768 * b) >> 16) + 128), 0, 255);
 437       *p++ = CLAMP ((int) (((32768 * r) >> 16) - ((27439 * g) >> 16) -
 438               ((5329 * b) >> 16) + 128), 0, 255);
 439     }
 440   }
 441 }
 442
 443 static void
 444 gst_text_renderer_image_to_argb (GstTextRender * render, guchar * pixbuf,
 445     int xpos, int ypos, int stride)
 446 {
 447   int i, j;
 448   guchar *p, *bitp;
 449   int width, height;
 450
 451   width = render->image_width;
 452   height = render->image_height;
 453
 454   for (i = 0; i < height && ypos + i < render->height; i++) {
 455     p = pixbuf + (ypos + i) * stride + xpos * 4;
 456     bitp = render->text_image + i * width * 4;
 457     for (j = 0; j < width && j < render->width; j++) {
 458       p[0] = bitp[CAIRO_ARGB_A];
 459       p[1] = bitp[CAIRO_ARGB_R];
 460       p[2] = bitp[CAIRO_ARGB_G];
 461       p[3] = bitp[CAIRO_ARGB_B];
 462
 463       /* Cairo uses pre-multiplied ARGB, unpremultiply it */
 464       CAIRO_UNPREMULTIPLY (p[0], p[1], p[2], p[3]);
 465
 466       bitp += 4;
 467       p += 4;
 468     }
 469   }
 470 }
 471
 472 static GstFlowReturn
 473 gst_text_render_renegotiate (GstTextRender * render)
 474 {
 475   GstCaps *caps = NULL, *padcaps;
 476   GstFlowReturn ret = GST_FLOW_OK;
 477
 478   gst_text_render_check_argb (render);
 479
 480   padcaps = gst_pad_query_caps (render->srcpad, NULL);
 481   caps = gst_pad_peer_query_caps (render->srcpad, padcaps);
 482   gst_caps_unref (padcaps);
 483
 484   if (!caps || gst_caps_is_empty (caps)) {
 485     GST_ELEMENT_ERROR (render, CORE, NEGOTIATION, (NULL), (NULL));
 486     ret = GST_FLOW_ERROR;
 487     goto done;
 488   }
 489
 490   caps = gst_text_render_fixate_caps (render, caps);
 491
 492   if (!gst_text_render_src_setcaps (render, caps)) {
 493     GST_ELEMENT_ERROR (render, CORE, NEGOTIATION, (NULL), (NULL));
 494     ret = GST_FLOW_ERROR;
 495     goto done;
 496   }
 497
 498 done:
 499   if (caps)
 500     gst_caps_unref (caps);
 501   return ret;
 502 }
 503
 504 static GstFlowReturn
 505 gst_text_render_chain (GstPad * pad, GstObject * parent, GstBuffer * inbuf)
 506 {
 507   GstTextRender *render;
 508   GstFlowReturn ret;
 509   GstBuffer *outbuf;
 510   GstMapInfo map;
 511   guint8 *data;
 512   gsize size;
 513   gint n;
 514   gint xpos, ypos;
 515
 516   render = GST_TEXT_RENDER (parent);
 517
 518   gst_buffer_map (inbuf, &map, GST_MAP_READ);
 519   data = map.data;
 520   size = map.size;
 521
 522   /* somehow pango barfs over "\0" buffers... */
 523   while (size > 0 &&
 524       (data[size - 1] == '\r' ||
 525           data[size - 1] == '\n' || data[size - 1] == '\0')) {
 526     size--;
 527   }
 528
 529   /* render text */
 530   GST_DEBUG ("rendering '%*s'", (gint) size, data);
 531   pango_layout_set_markup (render->layout, (gchar *) data, size);
 532   gst_text_render_render_pangocairo (render);
 533   gst_buffer_unmap (inbuf, &map);
 534
 535   if (gst_pad_check_reconfigure (render->srcpad)
 536       || !gst_pad_has_current_caps (render->srcpad)) {
 537     ret = gst_text_render_renegotiate (render);
 538     if (ret != GST_FLOW_OK)
 539       goto done;
 540   }
 541
 542   if (render->segment_event) {
 543     gst_pad_push_event (render->srcpad, render->segment_event);
 544     render->segment_event = NULL;
 545   }
 546
 547   GST_DEBUG ("Allocating buffer WxH = %dx%d", render->width, render->height);
 548   outbuf = gst_buffer_new_and_alloc (render->width * render->height * 4);
 549
 550   gst_buffer_copy_into (outbuf, inbuf, GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
 551
 552   gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
 553   data = map.data;
 554   size = map.size;
 555
 556   if (render->use_ARGB) {
 557     memset (data, 0, render->width * render->height * 4);
 558   } else {
 559     for (n = 0; n < render->width * render->height; n++) {
 560       data[n * 4] = data[n * 4 + 1] = 0;
 561       data[n * 4 + 2] = data[n * 4 + 3] = 128;
 562     }
 563   }
 564
 565   switch (render->halign) {
 566     case GST_TEXT_RENDER_HALIGN_LEFT:
 567       xpos = render->xpad;
 568       break;
 569     case GST_TEXT_RENDER_HALIGN_CENTER:
 570       xpos = (render->width - render->image_width) / 2;
 571       break;
 572     case GST_TEXT_RENDER_HALIGN_RIGHT:
 573       xpos = render->width - render->image_width - render->xpad;
 574       break;
 575     default:
 576       xpos = 0;
 577   }
 578
 579   switch (render->valign) {
 580     case GST_TEXT_RENDER_VALIGN_BOTTOM:
 581       ypos = render->height - render->image_height - render->ypad;
 582       break;
 583     case GST_TEXT_RENDER_VALIGN_BASELINE:
 584       ypos = render->height - (render->image_height + render->ypad);
 585       break;
 586     case GST_TEXT_RENDER_VALIGN_TOP:
 587       ypos = render->ypad;
 588       break;
 589     default:
 590       ypos = render->ypad;
 591       break;
 592   }
 593
 594   if (render->text_image) {
 595     if (render->use_ARGB) {
 596       gst_text_renderer_image_to_argb (render, data, xpos, ypos,
 597           render->width * 4);
 598     } else {
 599       gst_text_renderer_image_to_ayuv (render, data, xpos, ypos,
 600           render->width * 4);
 601     }
 602   }
 603   gst_buffer_unmap (outbuf, &map);
 604
 605   ret = gst_pad_push (render->srcpad, outbuf);
 606
 607 done:
 608   gst_buffer_unref (inbuf);
 609
 610   return ret;
 611 }
 612
 613 static gboolean
 614 gst_text_render_event (GstPad * pad, GstObject * parent, GstEvent * event)
 615 {
 616   GstTextRender *render = GST_TEXT_RENDER (parent);
 617   gboolean ret = TRUE;
 618
 619   switch (GST_EVENT_TYPE (event)) {
 620     case GST_EVENT_SEGMENT:
 621     {
 622       if (gst_pad_has_current_caps (render->srcpad)) {
 623         ret = gst_pad_push_event (render->srcpad, event);
 624       } else {
 625         gst_event_replace (&render->segment_event, event);
 626         gst_event_unref (event);
 627       }
 628       break;
 629     }
 630     default:
 631       ret = gst_pad_push_event (render->srcpad, event);
 632       break;
 633   }
 634
 635   return ret;
 636 }
 637
 638 static void
 639 gst_text_render_finalize (GObject * object)
 640 {
 641   GstTextRender *render = GST_TEXT_RENDER (object);
 642
 643   gst_event_replace (&render->segment_event, NULL);
 644
 645   g_free (render->text_image);
 646
 647   if (render->layout)
 648     g_object_unref (render->layout);
 649
 650   if (render->pango_context)
 651     g_object_unref (render->pango_context);
 652
 653   G_OBJECT_CLASS (parent_class)->finalize (object);
 654 }
 655
 656 static void
 657 gst_text_render_init (GstTextRender * render)
 658 {
 659   GstPadTemplate *template;
 660   PangoFontMap *fontmap;
 661
 662   /* sink */
 663   template = gst_static_pad_template_get (&sink_template_factory);
 664   render->sinkpad = gst_pad_new_from_template (template, "sink");
 665   gst_object_unref (template);
 666   gst_pad_set_chain_function (render->sinkpad,
 667       GST_DEBUG_FUNCPTR (gst_text_render_chain));
 668   gst_pad_set_event_function (render->sinkpad,
 669       GST_DEBUG_FUNCPTR (gst_text_render_event));
 670
 671   gst_element_add_pad (GST_ELEMENT (render), render->sinkpad);
 672
 673   /* source */
 674   template = gst_static_pad_template_get (&src_template_factory);
 675   render->srcpad = gst_pad_new_from_template (template, "src");
 676   gst_object_unref (template);
 677
 678   gst_element_add_pad (GST_ELEMENT (render), render->srcpad);
 679
 680   fontmap = pango_cairo_font_map_new ();
 681   render->pango_context =
 682       pango_font_map_create_context (PANGO_FONT_MAP (fontmap));
 683   g_object_unref (fontmap);
 684
 685   render->line_align = DEFAULT_PROP_LINE_ALIGNMENT;
 686   render->layout = pango_layout_new (render->pango_context);
 687   pango_layout_set_alignment (render->layout,
 688       (PangoAlignment) render->line_align);
 689
 690   render->halign = DEFAULT_PROP_HALIGNMENT;
 691   render->valign = DEFAULT_PROP_VALIGNMENT;
 692   render->xpad = DEFAULT_PROP_XPAD;
 693   render->ypad = DEFAULT_PROP_YPAD;
 694
 695   render->width = DEFAULT_RENDER_WIDTH;
 696   render->height = DEFAULT_RENDER_HEIGHT;
 697
 698   render->use_ARGB = FALSE;
 699 }
 700
 701 static void
 702 gst_text_render_set_property (GObject * object, guint prop_id,
 703     const GValue * value, GParamSpec * pspec)
 704 {
 705   GstTextRender *render = GST_TEXT_RENDER (object);
 706
 707   switch (prop_id) {
 708     case PROP_VALIGNMENT:
 709       render->valign = g_value_get_enum (value);
 710       break;
 711     case PROP_HALIGNMENT:
 712       render->halign = g_value_get_enum (value);
 713       break;
 714     case PROP_LINE_ALIGNMENT:
 715       render->line_align = g_value_get_enum (value);
 716       pango_layout_set_alignment (render->layout,
 717           (PangoAlignment) render->line_align);
 718       break;
 719     case PROP_XPAD:
 720       render->xpad = g_value_get_int (value);
 721       break;
 722     case PROP_YPAD:
 723       render->ypad = g_value_get_int (value);
 724       break;
 725     case PROP_FONT_DESC:
 726     {
 727       PangoFontDescription *desc;
 728
 729       desc = pango_font_description_from_string (g_value_get_string (value));
 730       if (desc) {
 731         GST_LOG ("font description set: %s", g_value_get_string (value));
 732         GST_OBJECT_LOCK (render);
 733         pango_layout_set_font_description (render->layout, desc);
 734         gst_text_render_adjust_values_with_fontdesc (render, desc);
 735         pango_font_description_free (desc);
 736         gst_text_render_render_pangocairo (render);
 737         GST_OBJECT_UNLOCK (render);
 738       } else {
 739         GST_WARNING ("font description parse failed: %s",
 740             g_value_get_string (value));
 741       }
 742       break;
 743     }
 744
 745     default:
 746       break;
 747   }
 748 }
 749
 750 static void
 751 gst_text_render_get_property (GObject * object, guint prop_id,
 752     GValue * value, GParamSpec * pspec)
 753 {
 754   GstTextRender *render = GST_TEXT_RENDER (object);
 755
 756   switch (prop_id) {
 757     case PROP_VALIGNMENT:
 758       g_value_set_enum (value, render->valign);
 759       break;
 760     case PROP_HALIGNMENT:
 761       g_value_set_enum (value, render->halign);
 762       break;
 763     case PROP_LINE_ALIGNMENT:
 764       g_value_set_enum (value, render->line_align);
 765       break;
 766     case PROP_XPAD:
 767       g_value_set_int (value, render->xpad);
 768       break;
 769     case PROP_YPAD:
 770       g_value_set_int (value, render->ypad);
 771       break;
 772     default:
 773       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 774       break;
 775   }
 776 }