ext/assrender/gstassrender.c

   1 /*
   2  * Copyright (c) 2008 Benjamin Schmitz <vortex@wolpzone.de>
   3  * Copyright (c) 2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-assrender
  23  *
  24  * Renders timestamped SSA/ASS subtitles on top of a video stream.
  25  *
  26  * <refsect2>
  27  * <title>Example launch line</title>
  28  * |[
  29  * gst-launch -v filesrc location=/path/to/mkv ! matroskademux name=d ! queue ! mp3parse ! mad ! audioconvert ! autoaudiosink  d. ! queue ! ffdec_h264 ! ffmpegcolorspace ! r.   d. ! queue ! "application/x-ass" ! assrender name=r ! ffmpegcolorspace ! autovideosink
  30  * ]| This pipeline demuxes a Matroska file with h.264 video, MP3 audio and embedded ASS subtitles and renders the subtitles on top of the video.
  31  * </refsect2>
  32  */
  33
  34
  35 #ifdef HAVE_CONFIG_H
  36 #  include <config.h>
  37 #endif
  38
  39 #include "gstassrender.h"
  40
  41 #include <string.h>
  42
  43 GST_DEBUG_CATEGORY_STATIC (gst_ass_render_debug);
  44 GST_DEBUG_CATEGORY_STATIC (gst_ass_render_lib_debug);
  45 #define GST_CAT_DEFAULT gst_ass_render_debug
  46
  47 /* Filter signals and props */
  48 enum
  49 {
  50   LAST_SIGNAL
  51 };
  52
  53 enum
  54 {
  55   PROP_0,
  56   PROP_ENABLE,
  57   PROP_EMBEDDEDFONTS
  58 };
  59
  60 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
  61     GST_PAD_SRC,
  62     GST_PAD_ALWAYS,
  63     GST_STATIC_CAPS (GST_VIDEO_CAPS_RGB ";" GST_VIDEO_CAPS_BGR ";"
  64         GST_VIDEO_CAPS_xRGB ";" GST_VIDEO_CAPS_xBGR ";"
  65         GST_VIDEO_CAPS_RGBx ";" GST_VIDEO_CAPS_BGRx ";"
  66         GST_VIDEO_CAPS_YUV ("I420"))
  67     );
  68
  69 static GstStaticPadTemplate video_sink_factory =
  70     GST_STATIC_PAD_TEMPLATE ("video_sink",
  71     GST_PAD_SINK,
  72     GST_PAD_ALWAYS,
  73     GST_STATIC_CAPS (GST_VIDEO_CAPS_RGB ";" GST_VIDEO_CAPS_BGR ";"
  74         GST_VIDEO_CAPS_xRGB ";" GST_VIDEO_CAPS_xBGR ";"
  75         GST_VIDEO_CAPS_RGBx ";" GST_VIDEO_CAPS_BGRx ";"
  76         GST_VIDEO_CAPS_YUV ("I420"))
  77     );
  78
  79 static GstStaticPadTemplate text_sink_factory =
  80     GST_STATIC_PAD_TEMPLATE ("text_sink",
  81     GST_PAD_SINK,
  82     GST_PAD_ALWAYS,
  83     GST_STATIC_CAPS ("application/x-ass; application/x-ssa")
  84     );
  85
  86 static void gst_ass_render_set_property (GObject * object, guint prop_id,
  87     const GValue * value, GParamSpec * pspec);
  88 static void gst_ass_render_get_property (GObject * object, guint prop_id,
  89     GValue * value, GParamSpec * pspec);
  90
  91 static void gst_ass_render_finalize (GObject * object);
  92
  93 static GstStateChangeReturn gst_ass_render_change_state (GstElement * element,
  94     GstStateChange transition);
  95
  96 GST_BOILERPLATE (GstAssRender, gst_ass_render, GstElement, GST_TYPE_ELEMENT);
  97
  98 static GstCaps *gst_ass_render_getcaps (GstPad * pad);
  99
 100 static gboolean gst_ass_render_setcaps_video (GstPad * pad, GstCaps * caps);
 101 static gboolean gst_ass_render_setcaps_text (GstPad * pad, GstCaps * caps);
 102
 103 static GstFlowReturn gst_ass_render_chain_video (GstPad * pad, GstBuffer * buf);
 104 static GstFlowReturn gst_ass_render_chain_text (GstPad * pad, GstBuffer * buf);
 105
 106 static gboolean gst_ass_render_event_video (GstPad * pad, GstEvent * event);
 107 static gboolean gst_ass_render_event_text (GstPad * pad, GstEvent * event);
 108 static gboolean gst_ass_render_event_src (GstPad * pad, GstEvent * event);
 109
 110 static GstFlowReturn gst_ass_render_bufferalloc_video (GstPad * pad,
 111     guint64 offset, guint size, GstCaps * caps, GstBuffer ** buffer);
 112
 113 static gboolean gst_ass_render_query_src (GstPad * pad, GstQuery * query);
 114
 115 static void
 116 gst_ass_render_base_init (gpointer gclass)
 117 {
 118   GstElementClass *element_class = (GstElementClass *) gclass;
 119
 120   gst_element_class_add_pad_template (element_class,
 121       gst_static_pad_template_get (&src_factory));
 122   gst_element_class_add_pad_template (element_class,
 123       gst_static_pad_template_get (&video_sink_factory));
 124   gst_element_class_add_pad_template (element_class,
 125       gst_static_pad_template_get (&text_sink_factory));
 126
 127   gst_element_class_set_details_simple (element_class, "ASS/SSA Render",
 128       "Mixer/Video/Overlay/Subtitle",
 129       "Renders ASS/SSA subtitles with libass",
 130       "Benjamin Schmitz <vortex@wolpzone.de>, "
 131       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 132 }
 133
 134 /* initialize the plugin's class */
 135 static void
 136 gst_ass_render_class_init (GstAssRenderClass * klass)
 137 {
 138   GObjectClass *gobject_class = (GObjectClass *) klass;
 139   GstElementClass *gstelement_class = (GstElementClass *) klass;
 140
 141   gobject_class->set_property = gst_ass_render_set_property;
 142   gobject_class->get_property = gst_ass_render_get_property;
 143   gobject_class->finalize = gst_ass_render_finalize;
 144
 145   g_object_class_install_property (gobject_class, PROP_ENABLE,
 146       g_param_spec_boolean ("enable", "Enable",
 147           "Enable rendering of subtitles", TRUE,
 148           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 149   g_object_class_install_property (gobject_class, PROP_EMBEDDEDFONTS,
 150       g_param_spec_boolean ("embeddedfonts", "Embedded Fonts",
 151           "Extract and use fonts embedded in the stream", TRUE,
 152           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 153
 154   gstelement_class->change_state =
 155       GST_DEBUG_FUNCPTR (gst_ass_render_change_state);
 156 }
 157
 158 #if defined(LIBASS_VERSION) && LIBASS_VERSION >= 0x00907000
 159 static void
 160 _libass_message_cb (gint level, const gchar * fmt, va_list args,
 161     gpointer render)
 162 {
 163   gchar *message = g_strdup_vprintf (fmt, args);
 164
 165   if (level < 2)
 166     GST_CAT_ERROR_OBJECT (gst_ass_render_lib_debug, render, "%s", message);
 167   else if (level < 4)
 168     GST_CAT_WARNING_OBJECT (gst_ass_render_lib_debug, render, "%s", message);
 169   else if (level < 5)
 170     GST_CAT_INFO_OBJECT (gst_ass_render_lib_debug, render, "%s", message);
 171   else if (level < 6)
 172     GST_CAT_DEBUG_OBJECT (gst_ass_render_lib_debug, render, "%s", message);
 173   else
 174     GST_CAT_LOG_OBJECT (gst_ass_render_lib_debug, render, "%s", message);
 175
 176   g_free (message);
 177 }
 178 #endif
 179
 180 static void
 181 gst_ass_render_init (GstAssRender * render, GstAssRenderClass * gclass)
 182 {
 183   GST_DEBUG_OBJECT (render, "init");
 184
 185   render->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
 186   render->video_sinkpad =
 187       gst_pad_new_from_static_template (&video_sink_factory, "video_sink");
 188   render->text_sinkpad =
 189       gst_pad_new_from_static_template (&text_sink_factory, "text_sink");
 190
 191   gst_pad_set_setcaps_function (render->video_sinkpad,
 192       GST_DEBUG_FUNCPTR (gst_ass_render_setcaps_video));
 193   gst_pad_set_setcaps_function (render->text_sinkpad,
 194       GST_DEBUG_FUNCPTR (gst_ass_render_setcaps_text));
 195
 196   gst_pad_set_getcaps_function (render->srcpad,
 197       GST_DEBUG_FUNCPTR (gst_ass_render_getcaps));
 198   gst_pad_set_getcaps_function (render->video_sinkpad,
 199       GST_DEBUG_FUNCPTR (gst_ass_render_getcaps));
 200
 201   gst_pad_set_chain_function (render->video_sinkpad,
 202       GST_DEBUG_FUNCPTR (gst_ass_render_chain_video));
 203   gst_pad_set_chain_function (render->text_sinkpad,
 204       GST_DEBUG_FUNCPTR (gst_ass_render_chain_text));
 205
 206   gst_pad_set_event_function (render->video_sinkpad,
 207       GST_DEBUG_FUNCPTR (gst_ass_render_event_video));
 208   gst_pad_set_event_function (render->text_sinkpad,
 209       GST_DEBUG_FUNCPTR (gst_ass_render_event_text));
 210   gst_pad_set_event_function (render->srcpad,
 211       GST_DEBUG_FUNCPTR (gst_ass_render_event_src));
 212
 213   gst_pad_set_bufferalloc_function (render->video_sinkpad,
 214       GST_DEBUG_FUNCPTR (gst_ass_render_bufferalloc_video));
 215
 216   gst_pad_set_query_function (render->srcpad,
 217       GST_DEBUG_FUNCPTR (gst_ass_render_query_src));
 218
 219   gst_element_add_pad (GST_ELEMENT (render), render->srcpad);
 220   gst_element_add_pad (GST_ELEMENT (render), render->video_sinkpad);
 221   gst_element_add_pad (GST_ELEMENT (render), render->text_sinkpad);
 222
 223   render->width = 0;
 224   render->height = 0;
 225
 226   render->subtitle_mutex = g_mutex_new ();
 227   render->subtitle_cond = g_cond_new ();
 228
 229   render->renderer_init_ok = FALSE;
 230   render->track_init_ok = FALSE;
 231   render->enable = TRUE;
 232   render->embeddedfonts = TRUE;
 233
 234   gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
 235   gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
 236
 237   render->ass_mutex = g_mutex_new ();
 238   render->ass_library = ass_library_init ();
 239 #if defined(LIBASS_VERSION) && LIBASS_VERSION >= 0x00907000
 240   ass_set_message_cb (render->ass_library, _libass_message_cb, render);
 241 #endif
 242   ass_set_extract_fonts (render->ass_library, 1);
 243
 244   render->ass_renderer = ass_renderer_init (render->ass_library);
 245   if (!render->ass_renderer) {
 246     GST_WARNING_OBJECT (render, "cannot create renderer instance");
 247     g_assert_not_reached ();
 248   }
 249
 250   render->ass_track = NULL;
 251
 252   GST_DEBUG_OBJECT (render, "init complete");
 253 }
 254
 255 static void
 256 gst_ass_render_finalize (GObject * object)
 257 {
 258   GstAssRender *render = GST_ASS_RENDER (object);
 259
 260   if (render->subtitle_mutex)
 261     g_mutex_free (render->subtitle_mutex);
 262
 263   if (render->subtitle_cond)
 264     g_cond_free (render->subtitle_cond);
 265
 266   if (render->ass_track) {
 267     ass_free_track (render->ass_track);
 268   }
 269
 270   if (render->ass_renderer) {
 271     ass_renderer_done (render->ass_renderer);
 272   }
 273
 274   if (render->ass_library) {
 275     ass_library_done (render->ass_library);
 276   }
 277
 278   if (render->ass_mutex)
 279     g_mutex_free (render->ass_mutex);
 280
 281   G_OBJECT_CLASS (parent_class)->finalize (object);
 282 }
 283
 284 static void
 285 gst_ass_render_set_property (GObject * object, guint prop_id,
 286     const GValue * value, GParamSpec * pspec)
 287 {
 288   GstAssRender *render = GST_ASS_RENDER (object);
 289
 290   switch (prop_id) {
 291     case PROP_ENABLE:
 292       render->enable = g_value_get_boolean (value);
 293       break;
 294     case PROP_EMBEDDEDFONTS:
 295       render->embeddedfonts = g_value_get_boolean (value);
 296       g_mutex_lock (render->ass_mutex);
 297       ass_set_extract_fonts (render->ass_library, render->embeddedfonts);
 298       g_mutex_unlock (render->ass_mutex);
 299       break;
 300     default:
 301       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 302       break;
 303   }
 304 }
 305
 306 static void
 307 gst_ass_render_get_property (GObject * object, guint prop_id,
 308     GValue * value, GParamSpec * pspec)
 309 {
 310   GstAssRender *render = GST_ASS_RENDER (object);
 311
 312   switch (prop_id) {
 313     case PROP_ENABLE:
 314       g_value_set_boolean (value, render->enable);
 315       break;
 316     case PROP_EMBEDDEDFONTS:
 317       g_value_set_boolean (value, render->embeddedfonts);
 318       break;
 319     default:
 320       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 321       break;
 322   }
 323 }
 324
 325 static GstStateChangeReturn
 326 gst_ass_render_change_state (GstElement * element, GstStateChange transition)
 327 {
 328   GstAssRender *render = GST_ASS_RENDER (element);
 329   GstStateChangeReturn ret;
 330
 331   switch (transition) {
 332     case GST_STATE_CHANGE_READY_TO_PAUSED:
 333       render->subtitle_flushing = FALSE;
 334       gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
 335       gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
 336       break;
 337     case GST_STATE_CHANGE_NULL_TO_READY:
 338     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 339     default:
 340       break;
 341
 342     case GST_STATE_CHANGE_PAUSED_TO_READY:
 343       g_mutex_lock (render->subtitle_mutex);
 344       render->subtitle_flushing = TRUE;
 345       if (render->subtitle_pending)
 346         gst_buffer_unref (render->subtitle_pending);
 347       render->subtitle_pending = NULL;
 348       g_cond_signal (render->subtitle_cond);
 349       g_mutex_unlock (render->subtitle_mutex);
 350       break;
 351   }
 352
 353   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 354
 355   switch (transition) {
 356     case GST_STATE_CHANGE_PAUSED_TO_READY:
 357       g_mutex_lock (render->ass_mutex);
 358       if (render->ass_track)
 359         ass_free_track (render->ass_track);
 360       render->ass_track = NULL;
 361       g_mutex_unlock (render->ass_mutex);
 362       render->track_init_ok = FALSE;
 363       render->renderer_init_ok = FALSE;
 364       break;
 365     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 366     case GST_STATE_CHANGE_READY_TO_NULL:
 367     default:
 368       break;
 369   }
 370
 371
 372   return ret;
 373 }
 374
 375 static gboolean
 376 gst_ass_render_query_src (GstPad * pad, GstQuery * query)
 377 {
 378   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
 379   gboolean ret;
 380
 381   ret = gst_pad_peer_query (render->video_sinkpad, query);
 382
 383   gst_object_unref (render);
 384   return ret;
 385 }
 386
 387 static gboolean
 388 gst_ass_render_event_src (GstPad * pad, GstEvent * event)
 389 {
 390   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
 391   gboolean ret = FALSE;
 392
 393   switch (GST_EVENT_TYPE (event)) {
 394     case GST_EVENT_SEEK:{
 395       GstSeekFlags flags;
 396
 397       GST_DEBUG_OBJECT (render, "seek received, driving from here");
 398
 399       gst_event_parse_seek (event, NULL, NULL, &flags, NULL, NULL, NULL, NULL);
 400
 401       /* Flush downstream, only for flushing seek */
 402       if (flags & GST_SEEK_FLAG_FLUSH)
 403         gst_pad_push_event (render->srcpad, gst_event_new_flush_start ());
 404
 405       /* Mark subtitle as flushing, unblocks chains */
 406       g_mutex_lock (render->subtitle_mutex);
 407       if (render->subtitle_pending)
 408         gst_buffer_unref (render->subtitle_pending);
 409       render->subtitle_pending = NULL;
 410       render->subtitle_flushing = TRUE;
 411       g_cond_signal (render->subtitle_cond);
 412       g_mutex_unlock (render->subtitle_mutex);
 413
 414       /* Seek on each sink pad */
 415       gst_event_ref (event);
 416       ret = gst_pad_push_event (render->video_sinkpad, event);
 417       if (ret) {
 418         ret = gst_pad_push_event (render->text_sinkpad, event);
 419       } else {
 420         gst_event_unref (event);
 421       }
 422       break;
 423     }
 424     default:
 425       gst_event_ref (event);
 426       ret = gst_pad_push_event (render->video_sinkpad, event);
 427       gst_pad_push_event (render->text_sinkpad, event);
 428       break;
 429   }
 430
 431   gst_object_unref (render);
 432
 433   return ret;
 434 }
 435
 436 static GstCaps *
 437 gst_ass_render_getcaps (GstPad * pad)
 438 {
 439   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
 440   GstPad *otherpad;
 441   GstCaps *caps;
 442
 443   if (pad == render->srcpad)
 444     otherpad = render->video_sinkpad;
 445   else
 446     otherpad = render->srcpad;
 447
 448   /* we can do what the peer can */
 449   caps = gst_pad_peer_get_caps (otherpad);
 450   if (caps) {
 451     GstCaps *temp;
 452     const GstCaps *templ;
 453
 454     /* filtered against our padtemplate */
 455     templ = gst_pad_get_pad_template_caps (otherpad);
 456     temp = gst_caps_intersect (caps, templ);
 457     gst_caps_unref (caps);
 458     /* this is what we can do */
 459     caps = temp;
 460   } else {
 461     /* no peer, our padtemplate is enough then */
 462     caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
 463   }
 464
 465   gst_object_unref (render);
 466
 467   return caps;
 468 }
 469
 470 #define CREATE_RGB_BLIT_FUNCTION(name,bpp,R,G,B) \
 471 static void \
 472 blit_##name (GstAssRender * render, ASS_Image * ass_image, GstBuffer * buffer) \
 473 { \
 474   guint counter = 0; \
 475   gint alpha, r, g, b, k; \
 476   const guint8 *src; \
 477   guint8 *dst; \
 478   gint x, y, w, h; \
 479   gint width = render->width; \
 480   gint height = render->height; \
 481   gint dst_stride = GST_ROUND_UP_4 (width * bpp); \
 482   gint dst_skip; \
 483   gint src_stride, src_skip; \
 484   \
 485   while (ass_image) { \
 486     if (ass_image->dst_y > height || ass_image->dst_x > width) \
 487       goto next; \
 488     \
 489     /* blend subtitles onto the video frame */ \
 490     alpha = 255 - ((ass_image->color) & 0xff); \
 491     r = ((ass_image->color) >> 24) & 0xff; \
 492     g = ((ass_image->color) >> 16) & 0xff; \
 493     b = ((ass_image->color) >> 8) & 0xff; \
 494     src = ass_image->bitmap; \
 495     dst = buffer->data + ass_image->dst_y * dst_stride + ass_image->dst_x * bpp; \
 496     \
 497     w = MIN (ass_image->w, width - ass_image->dst_x); \
 498     h = MIN (ass_image->h, height - ass_image->dst_y); \
 499     src_stride = ass_image->stride; \
 500     src_skip = ass_image->stride - w; \
 501     dst_skip = dst_stride - w * bpp; \
 502     \
 503     for (y = 0; y < h; y++) { \
 504       for (x = 0; x < w; x++) { \
 505         k = src[0] * alpha / 255; \
 506         dst[R] = (k * r + (255 - k) * dst[R]) / 255; \
 507         dst[G] = (k * g + (255 - k) * dst[G]) / 255; \
 508         dst[B] = (k * b + (255 - k) * dst[B]) / 255; \
 509         src++; \
 510         dst += bpp; \
 511       } \
 512       src += src_skip; \
 513       dst += dst_skip; \
 514     } \
 515 next: \
 516     counter++; \
 517     ass_image = ass_image->next; \
 518   } \
 519   GST_LOG_OBJECT (render, "amount of rendered ass_image: %u", counter); \
 520 }
 521
 522 CREATE_RGB_BLIT_FUNCTION (rgb, 3, 0, 1, 2);
 523 CREATE_RGB_BLIT_FUNCTION (bgr, 3, 2, 1, 0);
 524 CREATE_RGB_BLIT_FUNCTION (xrgb, 4, 1, 2, 3);
 525 CREATE_RGB_BLIT_FUNCTION (xbgr, 4, 3, 2, 1);
 526 CREATE_RGB_BLIT_FUNCTION (rgbx, 4, 0, 1, 2);
 527 CREATE_RGB_BLIT_FUNCTION (bgrx, 4, 2, 1, 0);
 528
 529 #undef CREATE_RGB_BLIT_FUNCTION
 530
 531 static inline gint
 532 rgb_to_y (gint r, gint g, gint b)
 533 {
 534   gint ret;
 535
 536   ret = (gint) (((19595 * r) >> 16) + ((38470 * g) >> 16) + ((7471 * b) >> 16));
 537   ret = CLAMP (ret, 0, 255);
 538   return ret;
 539 }
 540
 541 static inline gint
 542 rgb_to_u (gint r, gint g, gint b)
 543 {
 544   gint ret;
 545
 546   ret =
 547       (gint) (-((11059 * r) >> 16) - ((21709 * g) >> 16) + ((32768 * b) >> 16) +
 548       128);
 549   ret = CLAMP (ret, 0, 255);
 550   return ret;
 551 }
 552
 553 static inline gint
 554 rgb_to_v (gint r, gint g, gint b)
 555 {
 556   gint ret;
 557
 558   ret =
 559       (gint) (((32768 * r) >> 16) - ((27439 * g) >> 16) - ((5329 * b) >> 16) +
 560       128);
 561   ret = CLAMP (ret, 0, 255);
 562   return ret;
 563 }
 564
 565 static void
 566 blit_i420 (GstAssRender * render, ASS_Image * ass_image, GstBuffer * buffer)
 567 {
 568   guint counter = 0;
 569   gint alpha, r, g, b, k, k2;
 570   gint Y, U, V;
 571   const guint8 *src;
 572   guint8 *dst_y, *dst_u, *dst_v;
 573   gint x, y, w, h;
 574   gint w2, h2;
 575   gint width = render->width;
 576   gint height = render->height;
 577   gint src_stride;
 578   gint y_offset, y_height, y_width, y_stride;
 579   gint u_offset, u_height, u_width, u_stride;
 580   gint v_offset, v_height, v_width, v_stride;
 581
 582   y_offset =
 583       gst_video_format_get_component_offset (GST_VIDEO_FORMAT_I420, 0, width,
 584       height);
 585   u_offset =
 586       gst_video_format_get_component_offset (GST_VIDEO_FORMAT_I420, 1, width,
 587       height);
 588   v_offset =
 589       gst_video_format_get_component_offset (GST_VIDEO_FORMAT_I420, 2, width,
 590       height);
 591
 592   y_height =
 593       gst_video_format_get_component_height (GST_VIDEO_FORMAT_I420, 0, height);
 594   u_height =
 595       gst_video_format_get_component_height (GST_VIDEO_FORMAT_I420, 1, height);
 596   v_height =
 597       gst_video_format_get_component_height (GST_VIDEO_FORMAT_I420, 2, height);
 598
 599   y_width =
 600       gst_video_format_get_component_width (GST_VIDEO_FORMAT_I420, 0, width);
 601   u_width =
 602       gst_video_format_get_component_width (GST_VIDEO_FORMAT_I420, 1, width);
 603   v_width =
 604       gst_video_format_get_component_width (GST_VIDEO_FORMAT_I420, 2, width);
 605
 606   y_stride = gst_video_format_get_row_stride (GST_VIDEO_FORMAT_I420, 0, width);
 607   u_stride = gst_video_format_get_row_stride (GST_VIDEO_FORMAT_I420, 1, width);
 608   v_stride = gst_video_format_get_row_stride (GST_VIDEO_FORMAT_I420, 2, width);
 609
 610   while (ass_image) {
 611     if (ass_image->dst_y > height || ass_image->dst_x > width)
 612       goto next;
 613
 614     /* blend subtitles onto the video frame */
 615     alpha = 255 - ((ass_image->color) & 0xff);
 616     r = ((ass_image->color) >> 24) & 0xff;
 617     g = ((ass_image->color) >> 16) & 0xff;
 618     b = ((ass_image->color) >> 8) & 0xff;
 619
 620     Y = rgb_to_y (r, g, b);
 621     U = rgb_to_u (r, g, b);
 622     V = rgb_to_v (r, g, b);
 623
 624     w = MIN (ass_image->w, width - ass_image->dst_x);
 625     h = MIN (ass_image->h, height - ass_image->dst_y);
 626
 627     w2 = (w + 1) / 2;
 628     h2 = (h + 1) / 2;
 629
 630     src_stride = ass_image->stride;
 631
 632     src = ass_image->bitmap;
 633     dst_y =
 634         buffer->data + y_offset + ass_image->dst_y * y_stride +
 635         ass_image->dst_x;
 636     dst_u =
 637         buffer->data + u_offset + ((ass_image->dst_y + 1) / 2) * u_stride +
 638         (ass_image->dst_x + 1) / 2;
 639     dst_v =
 640         buffer->data + v_offset + ((ass_image->dst_y + 1) / 2) * v_stride +
 641         (ass_image->dst_x + 1) / 2;
 642
 643     for (y = 0; y < h - 1; y += 2) {
 644       for (x = 0; x < w - 1; x += 2) {
 645         k = src[0] * alpha / 255;
 646         k2 = k;
 647         dst_y[0] = (k * Y + (255 - k) * dst_y[0]) / 255;
 648
 649         k = src[1] * alpha / 255;
 650         k2 += k;
 651         dst_y[1] = (k * Y + (255 - k) * dst_y[1]) / 255;
 652
 653         src += src_stride;
 654         dst_y += y_stride;
 655
 656         k = src[0] * alpha / 255;
 657         k2 += k;
 658         dst_y[0] = (k * Y + (255 - k) * dst_y[0]) / 255;
 659
 660         k = src[1] * alpha / 255;
 661         k2 += k;
 662         dst_y[1] = (k * Y + (255 - k) * dst_y[1]) / 255;
 663
 664         k2 /= 4;
 665         dst_u[0] = (k2 * U + (255 - k2) * dst_u[0]) / 255;
 666         dst_v[0] = (k2 * V + (255 - k2) * dst_v[0]) / 255;
 667         dst_u++;
 668         dst_v++;
 669
 670         src += -src_stride + 2;
 671         dst_y += -y_stride + 2;
 672       }
 673
 674       if (x < w) {
 675         k = src[0] * alpha / 255;
 676         k2 = k;
 677         dst_y[0] = (k * Y + (255 - k) * dst_y[0]) / 255;
 678
 679         src += src_stride;
 680         dst_y += y_stride;
 681
 682         k = src[0] * alpha / 255;
 683         k2 += k;
 684         dst_y[0] = (k * Y + (255 - k) * dst_y[0]) / 255;
 685
 686         k2 /= 2;
 687         dst_u[0] = (k2 * U + (255 - k2) * dst_u[0]) / 255;
 688         dst_v[0] = (k2 * V + (255 - k2) * dst_v[0]) / 255;
 689         dst_u++;
 690         dst_v++;
 691
 692         src += -src_stride + 1;
 693         dst_y += -y_stride + 1;
 694       }
 695
 696       src += src_stride + (src_stride - w);
 697       dst_y += y_stride + (y_stride - w);
 698       dst_u += u_stride - w2;
 699       dst_v += v_stride - w2;
 700     }
 701
 702     if (y < h) {
 703       for (x = 0; x < w - 1; x += 2) {
 704         k = src[0] * alpha / 255;
 705         k2 = k;
 706         dst_y[0] = (k * Y + (255 - k) * dst_y[0]) / 255;
 707
 708         k = src[1] * alpha / 255;
 709         k2 += k;
 710         dst_y[1] = (k * Y + (255 - k) * dst_y[1]) / 255;
 711
 712         k2 /= 2;
 713         dst_u[0] = (k2 * U + (255 - k2) * dst_u[0]) / 255;
 714         dst_v[0] = (k2 * V + (255 - k2) * dst_v[0]) / 255;
 715         dst_u++;
 716         dst_v++;
 717
 718         src += 2;
 719         dst_y += 2;
 720       }
 721
 722       if (x < w) {
 723         k = src[0] * alpha / 255;
 724         k2 = k;
 725         dst_y[0] = (k * Y + (255 - k) * dst_y[0]) / 255;
 726
 727         dst_u[0] = (k2 * U + (255 - k2) * dst_u[0]) / 255;
 728         dst_v[0] = (k2 * V + (255 - k2) * dst_v[0]) / 255;
 729       }
 730     }
 731
 732   next:
 733     counter++;
 734     ass_image = ass_image->next;
 735   }
 736
 737   GST_LOG_OBJECT (render, "amount of rendered ass_image: %u", counter);
 738 }
 739
 740 static gboolean
 741 gst_ass_render_setcaps_video (GstPad * pad, GstCaps * caps)
 742 {
 743   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
 744   gboolean ret = FALSE;
 745   gint par_n = 1, par_d = 1;
 746   gdouble dar;
 747
 748   render->width = 0;
 749   render->height = 0;
 750
 751   if (!gst_video_format_parse_caps (caps, &render->format, &render->width,
 752           &render->height) ||
 753       !gst_video_parse_caps_framerate (caps, &render->fps_n, &render->fps_d)) {
 754     GST_ERROR_OBJECT (render, "Can't parse caps: %" GST_PTR_FORMAT, caps);
 755     ret = FALSE;
 756     goto out;
 757   }
 758
 759   gst_video_parse_caps_pixel_aspect_ratio (caps, &par_n, &par_d);
 760
 761   ret = gst_pad_set_caps (render->srcpad, caps);
 762   if (!ret)
 763     goto out;
 764
 765   switch (render->format) {
 766     case GST_VIDEO_FORMAT_RGB:
 767       render->blit = blit_rgb;
 768       break;
 769     case GST_VIDEO_FORMAT_BGR:
 770       render->blit = blit_bgr;
 771       break;
 772     case GST_VIDEO_FORMAT_xRGB:
 773       render->blit = blit_xrgb;
 774       break;
 775     case GST_VIDEO_FORMAT_xBGR:
 776       render->blit = blit_xbgr;
 777       break;
 778     case GST_VIDEO_FORMAT_RGBx:
 779       render->blit = blit_rgbx;
 780       break;
 781     case GST_VIDEO_FORMAT_BGRx:
 782       render->blit = blit_bgrx;
 783       break;
 784     case GST_VIDEO_FORMAT_I420:
 785       render->blit = blit_i420;
 786       break;
 787     default:
 788       ret = FALSE;
 789       goto out;
 790   }
 791
 792   g_mutex_lock (render->ass_mutex);
 793   ass_set_frame_size (render->ass_renderer, render->width, render->height);
 794
 795   dar = (((gdouble) par_n) * ((gdouble) render->width))
 796       / (((gdouble) par_d) * ((gdouble) render->height));
 797 #if !defined(LIBASS_VERSION) || LIBASS_VERSION < 0x00907000
 798   ass_set_aspect_ratio (render->ass_renderer, dar);
 799 #else
 800   ass_set_aspect_ratio (render->ass_renderer,
 801       dar, ((gdouble) render->width) / ((gdouble) render->height));
 802 #endif
 803   ass_set_font_scale (render->ass_renderer, 1.0);
 804   ass_set_hinting (render->ass_renderer, ASS_HINTING_LIGHT);
 805
 806 #if !defined(LIBASS_VERSION) || LIBASS_VERSION < 0x00907000
 807   ass_set_fonts (render->ass_renderer, "Arial", "sans-serif");
 808   ass_set_fonts (render->ass_renderer, NULL, "Sans");
 809 #else
 810   ass_set_fonts (render->ass_renderer, "Arial", "sans-serif", 1, NULL, 1);
 811   ass_set_fonts (render->ass_renderer, NULL, "Sans", 1, NULL, 1);
 812 #endif
 813   ass_set_margins (render->ass_renderer, 0, 0, 0, 0);
 814   ass_set_use_margins (render->ass_renderer, 0);
 815   g_mutex_unlock (render->ass_mutex);
 816
 817   render->renderer_init_ok = TRUE;
 818
 819   GST_DEBUG_OBJECT (render, "ass renderer setup complete");
 820
 821 out:
 822   gst_object_unref (render);
 823
 824   return ret;
 825 }
 826
 827 static gboolean
 828 gst_ass_render_setcaps_text (GstPad * pad, GstCaps * caps)
 829 {
 830   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
 831   GstStructure *structure;
 832   const GValue *value;
 833   GstBuffer *priv;
 834   gchar *codec_private;
 835   guint codec_private_size;
 836   gboolean ret = FALSE;
 837
 838   structure = gst_caps_get_structure (caps, 0);
 839
 840   GST_DEBUG_OBJECT (render, "text pad linked with caps:  %" GST_PTR_FORMAT,
 841       caps);
 842
 843   value = gst_structure_get_value (structure, "codec_data");
 844
 845   g_mutex_lock (render->ass_mutex);
 846   if (value != NULL) {
 847     priv = gst_value_get_buffer (value);
 848     g_return_val_if_fail (priv != NULL, FALSE);
 849
 850     codec_private = (gchar *) GST_BUFFER_DATA (priv);
 851     codec_private_size = GST_BUFFER_SIZE (priv);
 852
 853     if (!render->ass_track)
 854       render->ass_track = ass_new_track (render->ass_library);
 855
 856     ass_process_codec_private (render->ass_track,
 857         codec_private, codec_private_size);
 858
 859     GST_DEBUG_OBJECT (render, "ass track created");
 860
 861     render->track_init_ok = TRUE;
 862
 863     ret = TRUE;
 864   } else if (!render->ass_track) {
 865     render->ass_track = ass_new_track (render->ass_library);
 866
 867     render->track_init_ok = TRUE;
 868
 869     ret = TRUE;
 870   }
 871   g_mutex_unlock (render->ass_mutex);
 872
 873   gst_object_unref (render);
 874
 875   return ret;
 876 }
 877
 878
 879 static void
 880 gst_ass_render_process_text (GstAssRender * render, GstBuffer * buffer,
 881     GstClockTime running_time, GstClockTime duration)
 882 {
 883   gchar *data = (gchar *) GST_BUFFER_DATA (buffer);
 884   guint size = GST_BUFFER_SIZE (buffer);
 885   gdouble pts_start, pts_end;
 886
 887   pts_start = running_time;
 888   pts_start /= GST_MSECOND;
 889   pts_end = duration;
 890   pts_end /= GST_MSECOND;
 891
 892   GST_DEBUG_OBJECT (render,
 893       "Processing subtitles with running time %" GST_TIME_FORMAT
 894       " and duration %" GST_TIME_FORMAT, GST_TIME_ARGS (running_time),
 895       GST_TIME_ARGS (duration));
 896   g_mutex_lock (render->ass_mutex);
 897   ass_process_chunk (render->ass_track, data, size, pts_start, pts_end);
 898   g_mutex_unlock (render->ass_mutex);
 899   gst_buffer_unref (buffer);
 900 }
 901
 902 static GstFlowReturn
 903 gst_ass_render_bufferalloc_video (GstPad * pad, guint64 offset, guint size,
 904     GstCaps * caps, GstBuffer ** buffer)
 905 {
 906   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
 907   GstFlowReturn ret = GST_FLOW_WRONG_STATE;
 908   GstPad *allocpad;
 909
 910   GST_OBJECT_LOCK (render);
 911   allocpad = render->srcpad ? gst_object_ref (render->srcpad) : NULL;
 912   GST_OBJECT_UNLOCK (render);
 913
 914   if (allocpad) {
 915     ret = gst_pad_alloc_buffer (allocpad, offset, size, caps, buffer);
 916     gst_object_unref (allocpad);
 917   }
 918
 919   gst_object_unref (render);
 920
 921   return ret;
 922 }
 923
 924 static GstFlowReturn
 925 gst_ass_render_chain_video (GstPad * pad, GstBuffer * buffer)
 926 {
 927   GstAssRender *render = GST_ASS_RENDER (GST_PAD_PARENT (pad));
 928   GstFlowReturn ret = GST_FLOW_OK;
 929   gboolean in_seg = FALSE;
 930   gint64 start, stop, clip_start = 0, clip_stop = 0;
 931   ASS_Image *ass_image;
 932
 933   if (!GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {
 934     GST_WARNING_OBJECT (render, "buffer without timestamp, discarding");
 935     gst_buffer_unref (buffer);
 936     return GST_FLOW_OK;
 937   }
 938
 939   /* ignore buffers that are outside of the current segment */
 940   start = GST_BUFFER_TIMESTAMP (buffer);
 941
 942   if (!GST_BUFFER_DURATION_IS_VALID (buffer)) {
 943     stop = GST_CLOCK_TIME_NONE;
 944   } else {
 945     stop = start + GST_BUFFER_DURATION (buffer);
 946   }
 947
 948   /* segment_clip() will adjust start unconditionally to segment_start if
 949    * no stop time is provided, so handle this ourselves */
 950   if (stop == GST_CLOCK_TIME_NONE && start < render->video_segment.start)
 951     goto out_of_segment;
 952
 953   in_seg =
 954       gst_segment_clip (&render->video_segment, GST_FORMAT_TIME, start, stop,
 955       &clip_start, &clip_stop);
 956
 957   if (!in_seg)
 958     goto out_of_segment;
 959
 960   /* if the buffer is only partially in the segment, fix up stamps */
 961   if (clip_start != start || (stop != -1 && clip_stop != stop)) {
 962     GST_DEBUG_OBJECT (render, "clipping buffer timestamp/duration to segment");
 963     buffer = gst_buffer_make_metadata_writable (buffer);
 964     GST_BUFFER_TIMESTAMP (buffer) = clip_start;
 965     if (stop != -1)
 966       GST_BUFFER_DURATION (buffer) = clip_stop - clip_start;
 967   }
 968
 969   gst_segment_set_last_stop (&render->video_segment, GST_FORMAT_TIME,
 970       clip_start);
 971
 972   g_mutex_lock (render->subtitle_mutex);
 973   if (render->subtitle_pending) {
 974     GstClockTime sub_running_time, vid_running_time;
 975     GstClockTime sub_running_time_end, vid_running_time_end;
 976
 977     sub_running_time =
 978         gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME,
 979         GST_BUFFER_TIMESTAMP (render->subtitle_pending));
 980     sub_running_time_end =
 981         gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME,
 982         GST_BUFFER_TIMESTAMP (render->subtitle_pending) +
 983         GST_BUFFER_DURATION (render->subtitle_pending));
 984     vid_running_time =
 985         gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
 986         GST_BUFFER_TIMESTAMP (buffer));
 987     vid_running_time_end =
 988         gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
 989         GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer));
 990
 991     if (sub_running_time_end < vid_running_time) {
 992       gst_buffer_unref (render->subtitle_pending);
 993       GST_DEBUG_OBJECT (render,
 994           "Too late text buffer, dropping (%" GST_TIME_FORMAT " < %"
 995           GST_TIME_FORMAT, GST_TIME_ARGS (sub_running_time_end),
 996           GST_TIME_ARGS (vid_running_time));
 997       render->subtitle_pending = NULL;
 998       g_cond_signal (render->subtitle_cond);
 999     } else if (sub_running_time <= vid_running_time_end + GST_SECOND / 2) {
1000       gst_ass_render_process_text (render, render->subtitle_pending,
1001           sub_running_time, sub_running_time_end - sub_running_time);
1002       render->subtitle_pending = NULL;
1003       g_cond_signal (render->subtitle_cond);
1004     }
1005   }
1006   g_mutex_unlock (render->subtitle_mutex);
1007
1008   /* now start rendering subtitles, if all conditions are met */
1009   if (render->renderer_init_ok && render->track_init_ok && render->enable) {
1010     GstClockTime running_time;
1011     gdouble timestamp;
1012 #ifndef GST_DISABLE_GST_DEBUG
1013     gdouble step;
1014 #endif
1015
1016     running_time =
1017         gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
1018         GST_BUFFER_TIMESTAMP (buffer));
1019     GST_DEBUG_OBJECT (render,
1020         "rendering frame for running time %" GST_TIME_FORMAT,
1021         GST_TIME_ARGS (running_time));
1022     /* libass needs timestamps in ms */
1023     timestamp = running_time / GST_MSECOND;
1024
1025     g_mutex_lock (render->ass_mutex);
1026 #ifndef GST_DISABLE_GST_DEBUG
1027     /* only for testing right now. could possibly be used for optimizations? */
1028     step = ass_step_sub (render->ass_track, timestamp, 1);
1029     GST_DEBUG_OBJECT (render, "Current running time: %" GST_TIME_FORMAT
1030         " // Next event: %" GST_TIME_FORMAT,
1031         GST_TIME_ARGS (running_time), GST_TIME_ARGS (step * GST_MSECOND));
1032 #endif
1033
1034     /* not sure what the last parameter to this call is for (detect_change) */
1035     ass_image = ass_render_frame (render->ass_renderer, render->ass_track,
1036         timestamp, NULL);
1037     g_mutex_unlock (render->ass_mutex);
1038
1039     if (ass_image != NULL) {
1040       buffer = gst_buffer_make_writable (buffer);
1041       render->blit (render, ass_image, buffer);
1042     } else {
1043       GST_LOG_OBJECT (render, "nothing to render right now");
1044     }
1045   } else {
1046     GST_LOG_OBJECT (render, "rendering disabled, doing buffer passthrough");
1047   }
1048
1049   ret = gst_pad_push (render->srcpad, buffer);
1050
1051   return ret;
1052
1053 out_of_segment:
1054   {
1055     GST_DEBUG_OBJECT (render, "buffer out of segment, discarding");
1056     gst_buffer_unref (buffer);
1057     return GST_FLOW_OK;
1058   }
1059 }
1060
1061 static GstFlowReturn
1062 gst_ass_render_chain_text (GstPad * pad, GstBuffer * buffer)
1063 {
1064   GstFlowReturn ret = GST_FLOW_OK;
1065   GstAssRender *render = GST_ASS_RENDER (GST_PAD_PARENT (pad));
1066   GstClockTime timestamp, duration;
1067   GstClockTime sub_running_time, vid_running_time;
1068   GstClockTime sub_running_time_end;
1069   gint64 cstart, cstop;
1070   gboolean in_seg;
1071
1072   if (render->subtitle_flushing) {
1073     gst_buffer_unref (buffer);
1074     return GST_FLOW_WRONG_STATE;
1075   }
1076
1077   timestamp = GST_BUFFER_TIMESTAMP (buffer);
1078   duration = GST_BUFFER_DURATION (buffer);
1079
1080   if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (timestamp)
1081           || !GST_CLOCK_TIME_IS_VALID (duration))) {
1082     GST_WARNING_OBJECT (render,
1083         "Text buffer without valid timestamp" " or duration, dropping");
1084     gst_buffer_unref (buffer);
1085     return GST_FLOW_OK;
1086   }
1087
1088   in_seg =
1089       gst_segment_clip (&render->subtitle_segment, GST_FORMAT_TIME, timestamp,
1090       timestamp + duration, &cstart, &cstop);
1091   if (!in_seg) {
1092     GST_DEBUG_OBJECT (render,
1093         "Text buffer before segment start (%" GST_TIME_FORMAT " < %"
1094         GST_TIME_FORMAT ")", GST_TIME_ARGS (timestamp),
1095         GST_TIME_ARGS (render->subtitle_segment.start));
1096     gst_buffer_unref (buffer);
1097     return GST_FLOW_OK;
1098   }
1099
1100   GST_BUFFER_TIMESTAMP (buffer) = timestamp = cstart;
1101   GST_BUFFER_DURATION (buffer) = duration = cstop - cstart;
1102
1103   gst_segment_set_last_stop (&render->subtitle_segment, GST_FORMAT_TIME,
1104       GST_BUFFER_TIMESTAMP (buffer));
1105
1106   sub_running_time =
1107       gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME,
1108       timestamp);
1109   sub_running_time_end =
1110       gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME,
1111       timestamp + duration);
1112   vid_running_time =
1113       gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
1114       render->video_segment.last_stop);
1115
1116   if (render->fps_n && render->fps_d)
1117     vid_running_time +=
1118         gst_util_uint64_scale (GST_SECOND, render->fps_d, render->fps_n);
1119
1120   if (sub_running_time > vid_running_time + GST_SECOND / 2) {
1121     g_assert (render->subtitle_pending == NULL);
1122     g_mutex_lock (render->subtitle_mutex);
1123     if (G_UNLIKELY (render->subtitle_flushing)) {
1124       GST_DEBUG_OBJECT (render, "Text pad flushing");
1125       gst_object_unref (buffer);
1126       g_mutex_unlock (render->subtitle_mutex);
1127       return GST_FLOW_WRONG_STATE;
1128     }
1129     GST_DEBUG_OBJECT (render,
1130         "Too early text buffer, waiting (%" GST_TIME_FORMAT " > %"
1131         GST_TIME_FORMAT, GST_TIME_ARGS (sub_running_time),
1132         GST_TIME_ARGS (vid_running_time));
1133     render->subtitle_pending = buffer;
1134     g_cond_wait (render->subtitle_cond, render->subtitle_mutex);
1135     g_mutex_unlock (render->subtitle_mutex);
1136   } else if (sub_running_time_end < vid_running_time) {
1137     GST_DEBUG_OBJECT (render,
1138         "Too late text buffer, dropping (%" GST_TIME_FORMAT " < %"
1139         GST_TIME_FORMAT, GST_TIME_ARGS (sub_running_time_end),
1140         GST_TIME_ARGS (vid_running_time));
1141     gst_buffer_unref (buffer);
1142     ret = GST_FLOW_OK;
1143   } else {
1144     gst_ass_render_process_text (render, buffer, sub_running_time,
1145         sub_running_time_end - sub_running_time);
1146     ret = GST_FLOW_OK;
1147   }
1148
1149   GST_DEBUG_OBJECT (render,
1150       "processed text packet with timestamp %" GST_TIME_FORMAT
1151       " and duration %" GST_TIME_FORMAT,
1152       GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration));
1153
1154   return ret;
1155 }
1156
1157 static void
1158 gst_ass_render_handle_tags (GstAssRender * render, GstTagList * taglist)
1159 {
1160   static const gchar *mimetypes[] = {
1161     "application/x-font-ttf",
1162     "application/x-font-otf",
1163     "application/x-truetype-font"
1164   };
1165   static const gchar *extensions[] = {
1166     ".otf",
1167     ".ttf"
1168   };
1169   guint tag_size;
1170   guint index;
1171
1172   if (!taglist)
1173     return;
1174
1175   tag_size = gst_tag_list_get_tag_size (taglist, GST_TAG_ATTACHMENT);
1176   if (tag_size > 0 && render->embeddedfonts) {
1177     const GValue *value;
1178     GstBuffer *buf;
1179     GstCaps *caps;
1180     GstStructure *structure;
1181     gboolean valid_mimetype, valid_extension;
1182     guint j;
1183     const gchar *filename;
1184
1185     GST_DEBUG_OBJECT (render, "TAG event has attachments");
1186
1187     for (index = 0; index < tag_size; index++) {
1188       value = gst_tag_list_get_value_index (taglist, GST_TAG_ATTACHMENT, index);
1189       buf = gst_value_get_buffer (value);
1190       if (!buf || !GST_BUFFER_CAPS (buf))
1191         continue;
1192
1193       caps = GST_BUFFER_CAPS (buf);
1194       structure = gst_caps_get_structure (caps, 0);
1195
1196       valid_mimetype = FALSE;
1197       valid_extension = FALSE;
1198
1199       for (j = 0; j < G_N_ELEMENTS (mimetypes); j++) {
1200         if (gst_structure_has_name (structure, mimetypes[j])) {
1201           valid_mimetype = TRUE;
1202           break;
1203         }
1204       }
1205       filename = gst_structure_get_string (structure, "filename");
1206       if (!filename)
1207         continue;
1208
1209       if (!valid_mimetype) {
1210         guint len = strlen (filename);
1211         const gchar *extension = filename + len - 4;
1212         for (j = 0; j < G_N_ELEMENTS (extensions); j++) {
1213           if (g_ascii_strcasecmp (extension, extensions[j]) == 0) {
1214             valid_extension = TRUE;
1215             break;
1216           }
1217         }
1218       }
1219
1220       if (valid_mimetype || valid_extension) {
1221         g_mutex_lock (render->ass_mutex);
1222         ass_add_font (render->ass_library, (gchar *) filename,
1223             (gchar *) GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
1224         GST_DEBUG_OBJECT (render, "registered new font %s", filename);
1225         g_mutex_unlock (render->ass_mutex);
1226       }
1227     }
1228   }
1229 }
1230
1231 static gboolean
1232 gst_ass_render_event_video (GstPad * pad, GstEvent * event)
1233 {
1234   gboolean ret = FALSE;
1235   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
1236
1237   GST_DEBUG_OBJECT (pad, "received video event %s",
1238       GST_EVENT_TYPE_NAME (event));
1239
1240   switch (GST_EVENT_TYPE (event)) {
1241     case GST_EVENT_NEWSEGMENT:
1242     {
1243       GstFormat format;
1244       gdouble rate;
1245       gint64 start, stop, time;
1246       gboolean update;
1247
1248       GST_DEBUG_OBJECT (render, "received new segment");
1249
1250       gst_event_parse_new_segment (event, &update, &rate, &format, &start,
1251           &stop, &time);
1252
1253       if (format == GST_FORMAT_TIME) {
1254         GST_DEBUG_OBJECT (render, "VIDEO SEGMENT now: %" GST_SEGMENT_FORMAT,
1255             &render->video_segment);
1256
1257         gst_segment_set_newsegment (&render->video_segment, update, rate,
1258             format, start, stop, time);
1259
1260         GST_DEBUG_OBJECT (render, "VIDEO SEGMENT after: %" GST_SEGMENT_FORMAT,
1261             &render->video_segment);
1262         ret = gst_pad_push_event (render->srcpad, event);
1263       } else {
1264         GST_ELEMENT_WARNING (render, STREAM, MUX, (NULL),
1265             ("received non-TIME newsegment event on video input"));
1266         ret = FALSE;
1267         gst_event_unref (event);
1268       }
1269       break;
1270     }
1271     case GST_EVENT_TAG:
1272     {
1273       GstTagList *taglist = NULL;
1274
1275       /* tag events may contain attachments which might be fonts */
1276       GST_DEBUG_OBJECT (render, "got TAG event");
1277
1278       gst_event_parse_tag (event, &taglist);
1279       gst_ass_render_handle_tags (render, taglist);
1280       ret = gst_pad_push_event (render->srcpad, event);
1281       break;
1282     }
1283     case GST_EVENT_FLUSH_STOP:
1284       gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
1285     default:
1286       ret = gst_pad_push_event (render->srcpad, event);
1287       break;
1288   }
1289
1290   gst_object_unref (render);
1291
1292   return ret;
1293 }
1294
1295 static gboolean
1296 gst_ass_render_event_text (GstPad * pad, GstEvent * event)
1297 {
1298   gint i;
1299   gboolean ret = FALSE;
1300   GstAssRender *render = GST_ASS_RENDER (gst_pad_get_parent (pad));
1301
1302   GST_DEBUG_OBJECT (pad, "received text event %s", GST_EVENT_TYPE_NAME (event));
1303
1304   switch (GST_EVENT_TYPE (event)) {
1305     case GST_EVENT_NEWSEGMENT:
1306     {
1307       GstFormat format;
1308       gdouble rate;
1309       gint64 start, stop, time;
1310       gboolean update;
1311
1312       GST_DEBUG_OBJECT (render, "received new segment");
1313
1314       gst_event_parse_new_segment (event, &update, &rate, &format, &start,
1315           &stop, &time);
1316
1317       if (format == GST_FORMAT_TIME) {
1318         GST_DEBUG_OBJECT (render, "SUBTITLE SEGMENT now: %" GST_SEGMENT_FORMAT,
1319             &render->subtitle_segment);
1320
1321         gst_segment_set_newsegment (&render->subtitle_segment, update, rate,
1322             format, start, stop, time);
1323
1324         GST_DEBUG_OBJECT (render,
1325             "SUBTITLE SEGMENT after: %" GST_SEGMENT_FORMAT,
1326             &render->subtitle_segment);
1327         ret = TRUE;
1328         gst_event_unref (event);
1329       } else {
1330         GST_ELEMENT_WARNING (render, STREAM, MUX, (NULL),
1331             ("received non-TIME newsegment event on subtitle input"));
1332         ret = FALSE;
1333         gst_event_unref (event);
1334       }
1335       break;
1336     }
1337     case GST_EVENT_FLUSH_STOP:
1338       gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
1339       render->subtitle_flushing = FALSE;
1340       gst_event_unref (event);
1341       ret = TRUE;
1342       break;
1343     case GST_EVENT_FLUSH_START:
1344       GST_DEBUG_OBJECT (render, "begin flushing");
1345       g_mutex_lock (render->ass_mutex);
1346       if (render->ass_track) {
1347         /* delete any events on the ass_track */
1348         for (i = 0; i < render->ass_track->n_events; i++) {
1349           GST_DEBUG_OBJECT (render, "deleted event with eid %i", i);
1350           ass_free_event (render->ass_track, i);
1351         }
1352         render->ass_track->n_events = 0;
1353         GST_DEBUG_OBJECT (render, "done flushing");
1354       }
1355       g_mutex_unlock (render->ass_mutex);
1356       g_mutex_lock (render->subtitle_mutex);
1357       if (render->subtitle_pending)
1358         gst_buffer_unref (render->subtitle_pending);
1359       render->subtitle_pending = NULL;
1360       render->subtitle_flushing = TRUE;
1361       g_cond_signal (render->subtitle_cond);
1362       g_mutex_unlock (render->subtitle_mutex);
1363       gst_event_unref (event);
1364       ret = TRUE;
1365       break;
1366     case GST_EVENT_EOS:
1367       GST_OBJECT_LOCK (render);
1368       GST_INFO_OBJECT (render, "text EOS");
1369       GST_OBJECT_UNLOCK (render);
1370       gst_event_unref (event);
1371       ret = TRUE;
1372       break;
1373     case GST_EVENT_TAG:
1374     {
1375       GstTagList *taglist = NULL;
1376
1377       /* tag events may contain attachments which might be fonts */
1378       GST_DEBUG_OBJECT (render, "got TAG event");
1379
1380       gst_event_parse_tag (event, &taglist);
1381       gst_ass_render_handle_tags (render, taglist);
1382       ret = gst_pad_push_event (render->srcpad, event);
1383       break;
1384     }
1385     default:
1386       ret = gst_pad_push_event (render->srcpad, event);
1387       break;
1388   }
1389
1390   gst_object_unref (render);
1391
1392   return ret;
1393 }
1394
1395 static gboolean
1396 plugin_init (GstPlugin * plugin)
1397 {
1398   GST_DEBUG_CATEGORY_INIT (gst_ass_render_debug, "assrender",
1399       0, "ASS/SSA subtitle renderer");
1400   GST_DEBUG_CATEGORY_INIT (gst_ass_render_lib_debug, "assrender_library",
1401       0, "ASS/SSA subtitle renderer library");
1402
1403   return gst_element_register (plugin, "assrender",
1404       GST_RANK_PRIMARY, GST_TYPE_ASS_RENDER);
1405 }
1406
1407 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1408     GST_VERSION_MINOR,
1409     "assrender",
1410     "ASS/SSA subtitle renderer",
1411     plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)