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., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22
  23 /**
  24  * SECTION:element-textrender
  25  * @see_also: #GstTextOverlay
  26  *
  27  * This plugin renders text received on the text sink pad to a video
  28  * buffer (retaining the alpha channel), so it can later be overlayed
  29  * on top of video streams using other elements.
  30  *
  31  * The text can contain newline characters. (FIXME: What about text
  32  * wrapping? It does not make sense in this context)
  33  *
  34  * <refsect2>
  35  * <title>Example launch lines</title>
  36  * |[
  37  * gst-launch -v filesrc location=subtitles.srt ! subparse ! textrender ! xvimagesink
  38  * ]|
  39  * </refsect2>
  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-pango-markup; text/plain")
 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   PangoFontMap *fontmap;
 181
 182   gobject_class = (GObjectClass *) klass;
 183   gstelement_class = (GstElementClass *) klass;
 184
 185   parent_class = g_type_class_peek_parent (klass);
 186
 187   gobject_class->finalize = gst_text_render_finalize;
 188   gobject_class->set_property = gst_text_render_set_property;
 189   gobject_class->get_property = gst_text_render_get_property;
 190
 191   gst_element_class_add_pad_template (gstelement_class,
 192       gst_static_pad_template_get (&src_template_factory));
 193   gst_element_class_add_pad_template (gstelement_class,
 194       gst_static_pad_template_get (&sink_template_factory));
 195
 196   gst_element_class_set_details_simple (gstelement_class, "Text renderer",
 197       "Filter/Editor/Video",
 198       "Renders a text string to an image bitmap",
 199       "David Schleef <ds@schleef.org>, "
 200       "GStreamer maintainers <gstreamer-devel@lists.sourceforge.net>");
 201
 202   fontmap = pango_cairo_font_map_get_default ();
 203   klass->pango_context =
 204       pango_cairo_font_map_create_context (PANGO_CAIRO_FONT_MAP (fontmap));
 205   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FONT_DESC,
 206       g_param_spec_string ("font-desc", "font description",
 207           "Pango font description of font "
 208           "to be used for rendering. "
 209           "See documentation of "
 210           "pango_font_description_from_string"
 211           " for syntax.", "", G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
 212   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_VALIGNMENT,
 213       g_param_spec_enum ("valignment", "vertical alignment",
 214           "Vertical alignment of the text", GST_TYPE_TEXT_RENDER_VALIGN,
 215           DEFAULT_PROP_VALIGNMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 216   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HALIGNMENT,
 217       g_param_spec_enum ("halignment", "horizontal alignment",
 218           "Horizontal alignment of the text", GST_TYPE_TEXT_RENDER_HALIGN,
 219           DEFAULT_PROP_HALIGNMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 220   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_XPAD,
 221       g_param_spec_int ("xpad", "horizontal paddding",
 222           "Horizontal paddding when using left/right alignment", 0, G_MAXINT,
 223           DEFAULT_PROP_XPAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 224   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_YPAD,
 225       g_param_spec_int ("ypad", "vertical padding",
 226           "Vertical padding when using top/bottom alignment", 0, G_MAXINT,
 227           DEFAULT_PROP_YPAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 228   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_LINE_ALIGNMENT,
 229       g_param_spec_enum ("line-alignment", "line alignment",
 230           "Alignment of text lines relative to each other.",
 231           GST_TYPE_TEXT_RENDER_LINE_ALIGN, DEFAULT_PROP_LINE_ALIGNMENT,
 232           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 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_HAS_ALPHA (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_push_event (render->srcpad, gst_event_new_caps (caps));
 375
 376   return ret;
 377 }
 378
 379 static void
 380 gst_text_render_fixate_caps (GstTextRender * render, GstCaps * caps)
 381 {
 382   GstStructure *s;
 383
 384   gst_caps_truncate (caps);
 385   s = gst_caps_get_structure (caps, 0);
 386
 387   GST_DEBUG ("Fixating caps %" GST_PTR_FORMAT, caps);
 388   gst_structure_fixate_field_nearest_int (s, "width", MAX (render->image_width,
 389           DEFAULT_RENDER_WIDTH));
 390   gst_structure_fixate_field_nearest_int (s, "height",
 391       MAX (render->image_height + render->ypad, DEFAULT_RENDER_HEIGHT));
 392   GST_DEBUG ("Fixated to    %" GST_PTR_FORMAT, caps);
 393 }
 394
 395 #define CAIRO_UNPREMULTIPLY(a,r,g,b) G_STMT_START { \
 396   b = (a > 0) ? MIN ((b * 255 + a / 2) / a, 255) : 0; \
 397   g = (a > 0) ? MIN ((g * 255 + a / 2) / a, 255) : 0; \
 398   r = (a > 0) ? MIN ((r * 255 + a / 2) / a, 255) : 0; \
 399 } G_STMT_END
 400
 401 static void
 402 gst_text_renderer_image_to_ayuv (GstTextRender * render, guchar * pixbuf,
 403     int xpos, int ypos, int stride)
 404 {
 405   int y;                        /* text bitmap coordinates */
 406   guchar *p, *bitp;
 407   guchar a, r, g, b;
 408   int width, height;
 409
 410   width = render->image_width;
 411   height = render->image_height;
 412
 413   for (y = 0; y < height && ypos + y < render->height; y++) {
 414     int n;
 415     p = pixbuf + (ypos + y) * stride + xpos * 4;
 416     bitp = render->text_image + y * width * 4;
 417     for (n = 0; n < width && n < render->width; n++) {
 418       b = bitp[CAIRO_ARGB_B];
 419       g = bitp[CAIRO_ARGB_G];
 420       r = bitp[CAIRO_ARGB_R];
 421       a = bitp[CAIRO_ARGB_A];
 422       bitp += 4;
 423
 424       /* Cairo uses pre-multiplied ARGB, unpremultiply it */
 425       CAIRO_UNPREMULTIPLY (a, r, g, b);
 426
 427       *p++ = a;
 428       *p++ = CLAMP ((int) (((19595 * r) >> 16) + ((38470 * g) >> 16) +
 429               ((7471 * b) >> 16)), 0, 255);
 430       *p++ = CLAMP ((int) (-((11059 * r) >> 16) - ((21709 * g) >> 16) +
 431               ((32768 * b) >> 16) + 128), 0, 255);
 432       *p++ = CLAMP ((int) (((32768 * r) >> 16) - ((27439 * g) >> 16) -
 433               ((5329 * b) >> 16) + 128), 0, 255);
 434     }
 435   }
 436 }
 437
 438 static void
 439 gst_text_renderer_image_to_argb (GstTextRender * render, guchar * pixbuf,
 440     int xpos, int ypos, int stride)
 441 {
 442   int i, j;
 443   guchar *p, *bitp;
 444   int width, height;
 445
 446   width = render->image_width;
 447   height = render->image_height;
 448
 449   for (i = 0; i < height && ypos + i < render->height; i++) {
 450     p = pixbuf + (ypos + i) * stride + xpos * 4;
 451     bitp = render->text_image + i * width * 4;
 452     for (j = 0; j < width && j < render->width; j++) {
 453       p[0] = bitp[CAIRO_ARGB_A];
 454       p[1] = bitp[CAIRO_ARGB_R];
 455       p[2] = bitp[CAIRO_ARGB_G];
 456       p[3] = bitp[CAIRO_ARGB_B];
 457
 458       /* Cairo uses pre-multiplied ARGB, unpremultiply it */
 459       CAIRO_UNPREMULTIPLY (p[0], p[1], p[2], p[3]);
 460
 461       bitp += 4;
 462       p += 4;
 463     }
 464   }
 465 }
 466
 467 static GstFlowReturn
 468 gst_text_render_chain (GstPad * pad, GstBuffer * inbuf)
 469 {
 470   GstTextRender *render;
 471   GstFlowReturn ret;
 472   GstBuffer *outbuf;
 473   GstCaps *caps = NULL, *padcaps;
 474   guint8 *data;
 475   gsize size;
 476   gint n;
 477   gint xpos, ypos;
 478
 479   render = GST_TEXT_RENDER (gst_pad_get_parent (pad));
 480
 481   data = gst_buffer_map (inbuf, &size, NULL, GST_MAP_READ);
 482
 483   /* somehow pango barfs over "\0" buffers... */
 484   while (size > 0 &&
 485       (data[size - 1] == '\r' ||
 486           data[size - 1] == '\n' || data[size - 1] == '\0')) {
 487     size--;
 488   }
 489
 490   /* render text */
 491   GST_DEBUG ("rendering '%*s'", (gint) size, data);
 492   pango_layout_set_markup (render->layout, (gchar *) data, size);
 493   gst_text_render_render_pangocairo (render);
 494   gst_buffer_unmap (inbuf, data, size);
 495
 496   gst_text_render_check_argb (render);
 497
 498   padcaps = gst_pad_query_caps (render->srcpad, NULL);
 499   caps = gst_pad_peer_get_caps (render->srcpad, padcaps);
 500   gst_caps_unref (padcaps);
 501
 502   if (!caps || gst_caps_is_empty (caps)) {
 503     GST_ELEMENT_ERROR (render, CORE, NEGOTIATION, (NULL), (NULL));
 504     ret = GST_FLOW_ERROR;
 505     goto done;
 506   }
 507
 508   gst_text_render_fixate_caps (render, caps);
 509
 510   if (!gst_text_render_src_setcaps (render, caps)) {
 511     GST_ELEMENT_ERROR (render, CORE, NEGOTIATION, (NULL), (NULL));
 512     ret = GST_FLOW_ERROR;
 513     goto done;
 514   }
 515
 516   GST_DEBUG ("Allocating buffer WxH = %dx%d", render->width, render->height);
 517   outbuf = gst_buffer_new_and_alloc (render->width * render->height * 4);
 518
 519   gst_buffer_copy_into (outbuf, inbuf, GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
 520   data = gst_buffer_map (outbuf, &size, NULL, GST_MAP_WRITE);
 521
 522   if (render->use_ARGB) {
 523     memset (data, 0, render->width * render->height * 4);
 524   } else {
 525     for (n = 0; n < render->width * render->height; n++) {
 526       data[n * 4] = data[n * 4 + 1] = 0;
 527       data[n * 4 + 2] = data[n * 4 + 3] = 128;
 528     }
 529   }
 530
 531   switch (render->halign) {
 532     case GST_TEXT_RENDER_HALIGN_LEFT:
 533       xpos = render->xpad;
 534       break;
 535     case GST_TEXT_RENDER_HALIGN_CENTER:
 536       xpos = (render->width - render->image_width) / 2;
 537       break;
 538     case GST_TEXT_RENDER_HALIGN_RIGHT:
 539       xpos = render->width - render->image_width - render->xpad;
 540       break;
 541     default:
 542       xpos = 0;
 543   }
 544
 545   switch (render->valign) {
 546     case GST_TEXT_RENDER_VALIGN_BOTTOM:
 547       ypos = render->height - render->image_height - render->ypad;
 548       break;
 549     case GST_TEXT_RENDER_VALIGN_BASELINE:
 550       ypos = render->height - (render->image_height + render->ypad);
 551       break;
 552     case GST_TEXT_RENDER_VALIGN_TOP:
 553       ypos = render->ypad;
 554       break;
 555     default:
 556       ypos = render->ypad;
 557       break;
 558   }
 559
 560   if (render->text_image) {
 561     if (render->use_ARGB) {
 562       gst_text_renderer_image_to_argb (render, data, xpos, ypos,
 563           render->width * 4);
 564     } else {
 565       gst_text_renderer_image_to_ayuv (render, data, xpos, ypos,
 566           render->width * 4);
 567     }
 568   }
 569   gst_buffer_unmap (outbuf, data, size);
 570
 571   ret = gst_pad_push (render->srcpad, outbuf);
 572
 573 done:
 574   if (caps)
 575     gst_caps_unref (caps);
 576   gst_buffer_unref (inbuf);
 577   gst_object_unref (render);
 578   return ret;
 579 }
 580
 581 static void
 582 gst_text_render_finalize (GObject * object)
 583 {
 584   GstTextRender *render = GST_TEXT_RENDER (object);
 585
 586   g_free (render->text_image);
 587
 588   if (render->layout)
 589     g_object_unref (render->layout);
 590
 591   G_OBJECT_CLASS (parent_class)->finalize (object);
 592 }
 593
 594 static void
 595 gst_text_render_init (GstTextRender * render)
 596 {
 597   GstPadTemplate *template;
 598
 599   /* sink */
 600   template = gst_static_pad_template_get (&sink_template_factory);
 601   render->sinkpad = gst_pad_new_from_template (template, "sink");
 602   gst_object_unref (template);
 603   gst_pad_set_chain_function (render->sinkpad,
 604       GST_DEBUG_FUNCPTR (gst_text_render_chain));
 605   gst_element_add_pad (GST_ELEMENT (render), render->sinkpad);
 606
 607   /* source */
 608   template = gst_static_pad_template_get (&src_template_factory);
 609   render->srcpad = gst_pad_new_from_template (template, "src");
 610   gst_object_unref (template);
 611
 612   gst_element_add_pad (GST_ELEMENT (render), render->srcpad);
 613
 614   render->line_align = DEFAULT_PROP_LINE_ALIGNMENT;
 615   render->layout =
 616       pango_layout_new (GST_TEXT_RENDER_GET_CLASS (render)->pango_context);
 617   pango_layout_set_alignment (render->layout,
 618       (PangoAlignment) render->line_align);
 619
 620   render->halign = DEFAULT_PROP_HALIGNMENT;
 621   render->valign = DEFAULT_PROP_VALIGNMENT;
 622   render->xpad = DEFAULT_PROP_XPAD;
 623   render->ypad = DEFAULT_PROP_YPAD;
 624
 625   render->width = DEFAULT_RENDER_WIDTH;
 626   render->height = DEFAULT_RENDER_HEIGHT;
 627
 628   render->use_ARGB = FALSE;
 629 }
 630
 631 static void
 632 gst_text_render_set_property (GObject * object, guint prop_id,
 633     const GValue * value, GParamSpec * pspec)
 634 {
 635   GstTextRender *render = GST_TEXT_RENDER (object);
 636
 637   switch (prop_id) {
 638     case PROP_VALIGNMENT:
 639       render->valign = g_value_get_enum (value);
 640       break;
 641     case PROP_HALIGNMENT:
 642       render->halign = g_value_get_enum (value);
 643       break;
 644     case PROP_LINE_ALIGNMENT:
 645       render->line_align = g_value_get_enum (value);
 646       pango_layout_set_alignment (render->layout,
 647           (PangoAlignment) render->line_align);
 648       break;
 649     case PROP_XPAD:
 650       render->xpad = g_value_get_int (value);
 651       break;
 652     case PROP_YPAD:
 653       render->ypad = g_value_get_int (value);
 654       break;
 655     case PROP_FONT_DESC:
 656     {
 657       PangoFontDescription *desc;
 658
 659       desc = pango_font_description_from_string (g_value_get_string (value));
 660       if (desc) {
 661         GST_LOG ("font description set: %s", g_value_get_string (value));
 662         GST_OBJECT_LOCK (render);
 663         pango_layout_set_font_description (render->layout, desc);
 664         gst_text_render_adjust_values_with_fontdesc (render, desc);
 665         pango_font_description_free (desc);
 666         gst_text_render_render_pangocairo (render);
 667         GST_OBJECT_UNLOCK (render);
 668       } else {
 669         GST_WARNING ("font description parse failed: %s",
 670             g_value_get_string (value));
 671       }
 672       break;
 673     }
 674
 675     default:
 676       break;
 677   }
 678 }
 679
 680 static void
 681 gst_text_render_get_property (GObject * object, guint prop_id,
 682     GValue * value, GParamSpec * pspec)
 683 {
 684   GstTextRender *render = GST_TEXT_RENDER (object);
 685
 686   switch (prop_id) {
 687     case PROP_VALIGNMENT:
 688       g_value_set_enum (value, render->valign);
 689       break;
 690     case PROP_HALIGNMENT:
 691       g_value_set_enum (value, render->halign);
 692       break;
 693     case PROP_LINE_ALIGNMENT:
 694       g_value_set_enum (value, render->line_align);
 695       break;
 696     case PROP_XPAD:
 697       g_value_set_int (value, render->xpad);
 698       break;
 699     case PROP_YPAD:
 700       g_value_set_int (value, render->ypad);
 701       break;
 702     default:
 703       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 704       break;
 705   }
 706 }