diff --git a/gst-libs/gst/video/video-blend.c b/gst-libs/gst/video/video-blend.c
index 9231464..89fd9ca 100644
--- a/gst-libs/gst/video/video-blend.c
+++ b/gst-libs/gst/video/video-blend.c
@@ -1333,12 +1333,15 @@ video_blend_scale_linear_RGBA (GstBlendVideoFormatInfo * src,
  * @dest
  * @x: The x offset in pixel where the @src image should be blended
  * @y: the y offset in pixel where the @src image should be blended
+ * @global_alpha: the global_alpha each per-pixel alpha value is multiplied
+ *                with
  *
  * Lets you blend the @src image into the @dest image
  */
 gboolean
 video_blend (GstBlendVideoFormatInfo * dest,
-    GstBlendVideoFormatInfo * src, guint x, guint y)
+    GstBlendVideoFormatInfo * src, guint x, guint y,
+    gfloat global_alpha)
 {
   guint i, j;
   guint8 alpha;
@@ -1349,6 +1352,7 @@ video_blend (GstBlendVideoFormatInfo * dest,
 
   g_return_val_if_fail (dest, FALSE);
   g_return_val_if_fail (src, FALSE);
+  g_return_val_if_fail (global_alpha >= 0 && global_alpha <= 1, FALSE);
 
   /* we do no support writing to premultiplied alpha, though that should
      just be a matter of adding blenders below (BLEND01 and BLEND11) */
@@ -1414,7 +1418,7 @@ video_blend (GstBlendVideoFormatInfo * dest,
 #define BLENDLOOP(blender)                                                        \
   do {                                                                            \
     for (j = 0; j < src->width * 4; j += 4) {                                     \
-      alpha = tmpsrcline[j];                                                      \
+      alpha = (guint8) tmpsrcline[j] * global_alpha;                              \
                                                                                   \
       blender (tmpdestline[j + 1], alpha, tmpsrcline[j + 1], tmpdestline[j + 1]); \
       blender (tmpdestline[j + 2], alpha, tmpsrcline[j + 2], tmpdestline[j + 2]); \
diff --git a/gst-libs/gst/video/video-blend.h b/gst-libs/gst/video/video-blend.h
index f3673a6..7e4c50f 100644
--- a/gst-libs/gst/video/video-blend.h
+++ b/gst-libs/gst/video/video-blend.h
@@ -71,6 +71,7 @@ void       video_blend_scale_linear_RGBA  (GstBlendVideoFormatInfo * src,
 
 gboolean   video_blend                    (GstBlendVideoFormatInfo * dest,
                                            GstBlendVideoFormatInfo * src,
-                                           guint x, guint y);
+                                           guint x, guint y,
+                                           gfloat global_alpha);
 
 #endif
diff --git a/gst-libs/gst/video/video-overlay-composition.c b/gst-libs/gst/video/video-overlay-composition.c
index 4633b6b..8f7be85 100644
--- a/gst-libs/gst/video/video-overlay-composition.c
+++ b/gst-libs/gst/video/video-overlay-composition.c
@@ -134,6 +134,14 @@ struct _GstVideoOverlayRectangle
    * rectangles have expired. */
   guint seq_num;
 
+  /* global alpha: global alpha value of the rectangle. Each each per-pixel
+   * alpha value of image-data will be multiplied with the global alpha value
+   * during blending.
+   * Can be used for efficient fading in/out of overlay rectangles.
+   * GstElements that render OverlayCompositions and don't support global alpha
+   * should simply ignore it.*/
+  gfloat global_alpha;
+
   /* FIXME: we may also need a (private) way to cache converted/scaled
    * pixel blobs */
 #if !GLIB_CHECK_VERSION (2, 31, 0)
@@ -530,7 +538,8 @@ gst_video_overlay_composition_blend (GstVideoOverlayComposition * comp,
           rect->render_width);
     }
 
-    ret = video_blend (&video_info, &rectangle_info, rect->x, rect->y);
+    ret = video_blend (&video_info, &rectangle_info, rect->x, rect->y,
+            rect->global_alpha);
     if (!ret) {
       GST_WARNING ("Could not blend overlay rectangle onto video buffer");
     }
@@ -738,6 +747,9 @@ gst_video_overlay_rectangle_is_same_alpha_type (GstVideoOverlayFormatFlags
  *     overlay rectangle should be rendered to
  * @render_width: the render width of this rectangle on the video
  * @render_height: the render height of this rectangle on the video
+ * @global_alpha: the global alpha value of the rectangle, will be multiplied
+ *                with each per-pixel alpha value; set to 1 if you don't want to
+ *                use it
  * @flags: flags
  *
  * Creates a new video overlay rectangle with ARGB pixel data. The layout
@@ -758,7 +770,8 @@ gst_video_overlay_rectangle_is_same_alpha_type (GstVideoOverlayFormatFlags
 GstVideoOverlayRectangle *
 gst_video_overlay_rectangle_new_argb (GstBuffer * pixels,
     guint width, guint height, guint stride, gint render_x, gint render_y,
-    guint render_width, guint render_height, GstVideoOverlayFormatFlags flags)
+    guint render_width, guint render_height, gfloat global_alpha,
+    GstVideoOverlayFormatFlags flags)
 {
   GstVideoOverlayRectangle *rect;
 
@@ -768,6 +781,7 @@ gst_video_overlay_rectangle_new_argb (GstBuffer * pixels,
   g_return_val_if_fail (stride >= (4 * width), NULL);
   g_return_val_if_fail (height > 0 && width > 0, NULL);
   g_return_val_if_fail (render_height > 0 && render_width > 0, NULL);
+  g_return_val_if_fail (global_alpha >= 0 && global_alpha <= 1, NULL);
   g_return_val_if_fail (gst_video_overlay_rectangle_check_flags (flags), NULL);
 
   rect = (GstVideoOverlayRectangle *)
@@ -790,6 +804,8 @@ gst_video_overlay_rectangle_new_argb (GstBuffer * pixels,
   rect->render_width = render_width;
   rect->render_height = render_height;
 
+  rect->global_alpha = global_alpha;
+
   rect->flags = flags;
 
   rect->seq_num = gst_video_overlay_get_seqnum ();
@@ -972,7 +988,8 @@ gst_video_overlay_rectangle_get_pixels_argb_internal (GstVideoOverlayRectangle *
 
   scaled_rect = gst_video_overlay_rectangle_new_argb (buf,
       wanted_width, wanted_height, info.stride[0],
-      0, 0, wanted_width, wanted_height, rectangle->flags);
+      0, 0, wanted_width, wanted_height, rectangle->global_alpha,
+      rectangle->flags);
 
   gst_buffer_unref (buf);
 
@@ -1072,6 +1089,44 @@ gst_video_overlay_rectangle_get_flags (GstVideoOverlayRectangle * rectangle)
 }
 
 /**
+ * gst_video_overlay_rectangle_get_global_alpha:
+ * @rectangle: a #GstVideoOverlayRectangle
+ *
+ * Retrieves the global-alpha value associated with a #GstVideoOverlayRectangle.
+ *
+ * Returns: the global-alpha value associated with the rectangle.
+ *
+ * Since: 0.10.36
+ */
+gfloat
+gst_video_overlay_rectangle_get_global_alpha (GstVideoOverlayRectangle * rectangle)
+{
+  g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), -1);
+
+  return rectangle->global_alpha;
+}
+
+/**
+ * gst_video_overlay_rectangle_set_global_alpha:
+ * @rectangle: a #GstVideoOverlayRectangle
+ *
+ * Sets the global alpha value associated with a #GstVideoOverlayRectangle. Per-
+ * pixel alpha values are multiplied with this value. Valid
+ * values: 0 <= global_alpha <= 1; 1 to deactivate.
+ *
+ * Since: 0.10.36
+ */
+void
+gst_video_overlay_rectangle_set_global_alpha (GstVideoOverlayRectangle * rectangle,
+        gfloat global_alpha)
+{
+  g_return_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle));
+  g_return_if_fail (global_alpha >= 0 && global_alpha <=1);
+
+  rectangle->global_alpha = global_alpha;
+}
+
+/**
  * gst_video_overlay_rectangle_copy:
  * @rectangle: (transfer none): a #GstVideoOverlayRectangle to copy
  *
@@ -1095,7 +1150,8 @@ gst_video_overlay_rectangle_copy (GstVideoOverlayRectangle * rectangle)
   copy = gst_video_overlay_rectangle_new_argb (rectangle->pixels,
       rectangle->width, rectangle->height, rectangle->stride,
       rectangle->x, rectangle->y,
-      rectangle->render_width, rectangle->render_height, rectangle->flags);
+      rectangle->render_width, rectangle->render_height,
+      rectangle->global_alpha, rectangle->flags);
 
   return copy;
 }
diff --git a/gst-libs/gst/video/video-overlay-composition.h b/gst-libs/gst/video/video-overlay-composition.h
index b91404b..4c4dbb8 100644
--- a/gst-libs/gst/video/video-overlay-composition.h
+++ b/gst-libs/gst/video/video-overlay-composition.h
@@ -112,6 +112,7 @@ GstVideoOverlayRectangle *   gst_video_overlay_rectangle_new_argb (GstBuffer * p
                                                                    guint width, guint height, guint stride,
                                                                    gint  render_x, gint render_y,
                                                                    guint render_width, guint render_height,
+                                                                   gfloat global_alpha,
                                                                    GstVideoOverlayFormatFlags flags);
 
 GstVideoOverlayRectangle *   gst_video_overlay_rectangle_copy     (GstVideoOverlayRectangle * rectangle);
@@ -142,6 +143,10 @@ GstBuffer *                  gst_video_overlay_rectangle_get_pixels_unscaled_arg
 
 GstVideoOverlayFormatFlags   gst_video_overlay_rectangle_get_flags                (GstVideoOverlayRectangle  * rectangle);
 
+gfloat                       gst_video_overlay_rectangle_get_global_alpha         (GstVideoOverlayRectangle  * rectangle);
+void                         gst_video_overlay_rectangle_set_global_alpha         (GstVideoOverlayRectangle  * rectangle,
+                                                                                   gfloat                      global_alpha);
+
 /**
  * GstVideoOverlayComposition:
  *
