sys/ximage/gstximagesrc.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2006 Zaheer Merali <zaheerabbas at merali dot org>
   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., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-ximagesrc
  23  *
  24  * This element captures your X Display and creates raw RGB video.  It uses
  25  * the XDamage extension if available to only capture areas of the screen that
  26  * have changed since the last frame.  It uses the XFixes extension if
  27  * available to also capture your mouse pointer.  By default it will fixate to
  28  * 25 frames per second.
  29  *
  30  * <refsect2>
  31  * <title>Example pipelines</title>
  32  * |[
  33  * gst-launch-1.0 ximagesrc ! video/x-raw,framerate=5/1 ! videoconvert ! theoraenc ! oggmux ! filesink location=desktop.ogg
  34  * ]| Encodes your X display to an Ogg theora video at 5 frames per second.
  35  * </refsect2>
  36  */
  37
  38 #ifdef HAVE_CONFIG_H
  39 #include "config.h"
  40 #endif
  41 #include "gstximagesrc.h"
  42
  43 #include <string.h>
  44 #include <stdlib.h>
  45
  46 #include <X11/Xlib.h>
  47 #include <X11/Xutil.h>
  48
  49 #include <gst/gst.h>
  50 #include <gst/gst-i18n-plugin.h>
  51 #include <gst/video/video.h>
  52
  53 #include "gst/glib-compat-private.h"
  54
  55 GST_DEBUG_CATEGORY_STATIC (gst_debug_ximage_src);
  56 #define GST_CAT_DEFAULT gst_debug_ximage_src
  57
  58 static GstStaticPadTemplate t =
  59 GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
  60     GST_STATIC_CAPS ("video/x-raw, "
  61         "framerate = (fraction) [ 0, MAX ], "
  62         "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ], "
  63         "pixel-aspect-ratio = (fraction) [ 0, MAX ]"));
  64
  65 enum
  66 {
  67   PROP_0,
  68   PROP_DISPLAY_NAME,
  69   PROP_SHOW_POINTER,
  70   PROP_USE_DAMAGE,
  71   PROP_STARTX,
  72   PROP_STARTY,
  73   PROP_ENDX,
  74   PROP_ENDY,
  75   PROP_REMOTE,
  76   PROP_XID,
  77   PROP_XNAME,
  78 };
  79
  80 #define gst_ximage_src_parent_class parent_class
  81 G_DEFINE_TYPE (GstXImageSrc, gst_ximage_src, GST_TYPE_PUSH_SRC);
  82
  83 static GstCaps *gst_ximage_src_fixate (GstBaseSrc * bsrc, GstCaps * caps);
  84 static void gst_ximage_src_clear_bufpool (GstXImageSrc * ximagesrc);
  85
  86 /* Called when a buffer is returned from the pipeline */
  87 static gboolean
  88 gst_ximage_src_return_buf (GstXImageSrc * ximagesrc, GstBuffer * ximage)
  89 {
  90   GstMetaXImage *meta = GST_META_XIMAGE_GET (ximage);
  91   /* True will make dispose free the buffer, while false will keep it */
  92   gboolean ret = TRUE;
  93
  94   /* If our geometry changed we can't reuse that image. */
  95   if ((meta->width != ximagesrc->width) || (meta->height != ximagesrc->height)) {
  96     GST_DEBUG_OBJECT (ximagesrc,
  97         "destroy image %p as its size changed %dx%d vs current %dx%d",
  98         ximage, meta->width, meta->height, ximagesrc->width, ximagesrc->height);
  99     g_mutex_lock (&ximagesrc->x_lock);
 100     gst_ximageutil_ximage_destroy (ximagesrc->xcontext, ximage);
 101     g_mutex_unlock (&ximagesrc->x_lock);
 102   } else {
 103     /* In that case we can reuse the image and add it to our image pool. */
 104     GST_LOG_OBJECT (ximagesrc, "recycling image %p in pool", ximage);
 105     /* need to increment the refcount again to recycle */
 106     gst_buffer_ref (ximage);
 107     g_mutex_lock (&ximagesrc->pool_lock);
 108     GST_BUFFER_FLAGS (GST_BUFFER (ximage)) = 0; /* clear out any flags from the previous use */
 109     ximagesrc->buffer_pool = g_slist_prepend (ximagesrc->buffer_pool, ximage);
 110     g_mutex_unlock (&ximagesrc->pool_lock);
 111     ret = FALSE;
 112   }
 113
 114   return ret;
 115 }
 116
 117 static Window
 118 gst_ximage_src_find_window (GstXImageSrc * src, Window root, const char *name)
 119 {
 120   Window *children;
 121   Window window = 0, root_return, parent_return;
 122   unsigned int nchildren;
 123   char *tmpname;
 124   int n, status;
 125
 126   status = XFetchName (src->xcontext->disp, root, &tmpname);
 127   if (status && !strcmp (name, tmpname))
 128     return root;
 129
 130   status =
 131       XQueryTree (src->xcontext->disp, root, &root_return, &parent_return,
 132       &children, &nchildren);
 133   if (!status || !children)
 134     return (Window) 0;
 135
 136   for (n = 0; n < nchildren; ++n) {
 137     window = gst_ximage_src_find_window (src, children[n], name);
 138     if (window != 0)
 139       break;
 140   }
 141
 142   XFree (children);
 143   return window;
 144 }
 145
 146 static gboolean
 147 gst_ximage_src_open_display (GstXImageSrc * s, const gchar * name)
 148 {
 149   g_return_val_if_fail (GST_IS_XIMAGE_SRC (s), FALSE);
 150
 151   if (s->xcontext != NULL)
 152     return TRUE;
 153
 154   g_mutex_lock (&s->x_lock);
 155   s->xcontext = ximageutil_xcontext_get (GST_ELEMENT (s), name);
 156   if (s->xcontext == NULL) {
 157     g_mutex_unlock (&s->x_lock);
 158     GST_ELEMENT_ERROR (s, RESOURCE, OPEN_READ,
 159         ("Could not open X display for reading"),
 160         ("NULL returned from getting xcontext"));
 161     return FALSE;
 162   }
 163   s->width = s->xcontext->width;
 164   s->height = s->xcontext->height;
 165
 166   s->xwindow = s->xcontext->root;
 167   if (s->xid != 0 || s->xname) {
 168     int status;
 169     XWindowAttributes attrs;
 170     Window window;
 171     int x, y;
 172     Window child;
 173     Bool coord_translated;
 174
 175     if (s->xid != 0) {
 176       status = XGetWindowAttributes (s->xcontext->disp, s->xid, &attrs);
 177       if (status) {
 178         GST_DEBUG_OBJECT (s, "Found window XID %" G_GUINT64_FORMAT, s->xid);
 179         s->xwindow = s->xid;
 180         goto window_found;
 181       } else {
 182         GST_WARNING_OBJECT (s, "Failed to get window %" G_GUINT64_FORMAT
 183             " attributes", s->xid);
 184       }
 185     }
 186
 187     if (s->xname) {
 188       GST_DEBUG_OBJECT (s, "Looking for window %s", s->xname);
 189       window = gst_ximage_src_find_window (s, s->xcontext->root, s->xname);
 190       if (window != 0) {
 191         GST_DEBUG_OBJECT (s, "Found window named %s, ", s->xname);
 192         status = XGetWindowAttributes (s->xcontext->disp, window, &attrs);
 193         if (status) {
 194           s->xwindow = window;
 195           goto window_found;
 196         } else {
 197           GST_WARNING_OBJECT (s, "Failed to get window attributes for "
 198               "window named %s", s->xname);
 199         }
 200       }
 201     }
 202
 203     GST_INFO_OBJECT (s, "Using root window");
 204     goto use_root_window;
 205
 206   window_found:
 207     g_assert (s->xwindow != 0);
 208     s->width = attrs.width;
 209     s->height = attrs.height;
 210
 211     coord_translated = XTranslateCoordinates (s->xcontext->disp, s->xwindow,
 212         s->xcontext->root, 0, 0, &x, &y, &child);
 213     if (coord_translated) {
 214       s->x = x;
 215       s->y = y;
 216     } else {
 217       s->x = 0;
 218       s->y = 0;
 219     }
 220
 221     GST_INFO_OBJECT (s, "Using default window size of %dx%d at location %d,%d",
 222         s->width, s->height, s->x, s->y);
 223   }
 224 use_root_window:
 225
 226 #ifdef HAVE_XFIXES
 227   /* check if xfixes supported */
 228   {
 229     int error_base;
 230
 231     if (XFixesQueryExtension (s->xcontext->disp, &s->fixes_event_base,
 232             &error_base)) {
 233       s->have_xfixes = TRUE;
 234       GST_DEBUG_OBJECT (s, "X Server supports XFixes");
 235     } else {
 236
 237       GST_DEBUG_OBJECT (s, "X Server does not support XFixes");
 238     }
 239   }
 240
 241 #ifdef HAVE_XDAMAGE
 242   /* check if xdamage is supported */
 243   {
 244     int error_base;
 245     long evmask = NoEventMask;
 246
 247     s->have_xdamage = FALSE;
 248     s->damage = None;
 249     s->damage_copy_gc = None;
 250     s->damage_region = None;
 251
 252     if (XDamageQueryExtension (s->xcontext->disp, &s->damage_event_base,
 253             &error_base)) {
 254       s->damage =
 255           XDamageCreate (s->xcontext->disp, s->xwindow, XDamageReportNonEmpty);
 256       if (s->damage != None) {
 257         s->damage_region = XFixesCreateRegion (s->xcontext->disp, NULL, 0);
 258         if (s->damage_region != None) {
 259           XGCValues values;
 260
 261           GST_DEBUG_OBJECT (s, "Using XDamage extension");
 262           values.subwindow_mode = IncludeInferiors;
 263           s->damage_copy_gc = XCreateGC (s->xcontext->disp,
 264               s->xwindow, GCSubwindowMode, &values);
 265           XSelectInput (s->xcontext->disp, s->xwindow, evmask);
 266
 267           s->have_xdamage = TRUE;
 268         } else {
 269           XDamageDestroy (s->xcontext->disp, s->damage);
 270           s->damage = None;
 271         }
 272       } else
 273         GST_DEBUG_OBJECT (s, "Could not attach to XDamage");
 274     } else {
 275       GST_DEBUG_OBJECT (s, "X Server does not have XDamage extension");
 276     }
 277   }
 278 #endif
 279 #endif
 280
 281   g_mutex_unlock (&s->x_lock);
 282
 283   if (s->xcontext == NULL)
 284     return FALSE;
 285
 286   return TRUE;
 287 }
 288
 289 static gboolean
 290 gst_ximage_src_start (GstBaseSrc * basesrc)
 291 {
 292   GstXImageSrc *s = GST_XIMAGE_SRC (basesrc);
 293
 294   s->last_frame_no = -1;
 295 #ifdef HAVE_XDAMAGE
 296   if (s->last_ximage)
 297     gst_buffer_unref (GST_BUFFER_CAST (s->last_ximage));
 298   s->last_ximage = NULL;
 299 #endif
 300   return gst_ximage_src_open_display (s, s->display_name);
 301 }
 302
 303 static gboolean
 304 gst_ximage_src_stop (GstBaseSrc * basesrc)
 305 {
 306   GstXImageSrc *src = GST_XIMAGE_SRC (basesrc);
 307
 308 #ifdef HAVE_XDAMAGE
 309   if (src->last_ximage)
 310     gst_buffer_unref (GST_BUFFER_CAST (src->last_ximage));
 311   src->last_ximage = NULL;
 312 #endif
 313
 314   gst_ximage_src_clear_bufpool (src);
 315
 316 #ifdef HAVE_XFIXES
 317   if (src->cursor_image)
 318     XFree (src->cursor_image);
 319   src->cursor_image = NULL;
 320 #endif
 321
 322   if (src->xcontext) {
 323     g_mutex_lock (&src->x_lock);
 324
 325 #ifdef HAVE_XDAMAGE
 326     if (src->damage_copy_gc != None) {
 327       XFreeGC (src->xcontext->disp, src->damage_copy_gc);
 328       src->damage_copy_gc = None;
 329     }
 330     if (src->damage_region != None) {
 331       XFixesDestroyRegion (src->xcontext->disp, src->damage_region);
 332       src->damage_region = None;
 333     }
 334     if (src->damage != None) {
 335       XDamageDestroy (src->xcontext->disp, src->damage);
 336       src->damage = None;
 337     }
 338 #endif
 339
 340     ximageutil_xcontext_clear (src->xcontext);
 341     src->xcontext = NULL;
 342     g_mutex_unlock (&src->x_lock);
 343   }
 344
 345   return TRUE;
 346 }
 347
 348 static gboolean
 349 gst_ximage_src_unlock (GstBaseSrc * basesrc)
 350 {
 351   GstXImageSrc *src = GST_XIMAGE_SRC (basesrc);
 352
 353   /* Awaken the create() func if it's waiting on the clock */
 354   GST_OBJECT_LOCK (src);
 355   if (src->clock_id) {
 356     GST_DEBUG_OBJECT (src, "Waking up waiting clock");
 357     gst_clock_id_unschedule (src->clock_id);
 358   }
 359   GST_OBJECT_UNLOCK (src);
 360
 361   return TRUE;
 362 }
 363
 364 static gboolean
 365 gst_ximage_src_recalc (GstXImageSrc * src)
 366 {
 367   if (!src->xcontext)
 368     return FALSE;
 369
 370   /* Maybe later we can check the display hasn't changed size */
 371   /* We could use XQueryPointer to get only the current window. */
 372   return TRUE;
 373 }
 374
 375 #ifdef HAVE_XFIXES
 376 static gboolean
 377 gst_ximage_is_pointer_in_region (GstXImageSrc * src)
 378 {
 379   Window window_returned;
 380   int root_x, root_y;
 381   int win_x, win_y;
 382   unsigned int mask_return;
 383   Bool on_window;
 384
 385   on_window = XQueryPointer (src->xcontext->disp, src->xwindow,
 386       &window_returned, &window_returned, &root_x, &root_y, &win_x, &win_y,
 387       &mask_return);
 388
 389   return (on_window && (win_x >= src->startx) && (win_y >= src->starty) &&
 390       (win_x < src->endx) && (win_y < src->endy));
 391 }
 392 #endif
 393
 394 #ifdef HAVE_XFIXES
 395 static void
 396 composite_pixel (GstXContext * xcontext, guchar * dest, guchar * src)
 397 {
 398   guint8 r = src[2];
 399   guint8 g = src[1];
 400   guint8 b = src[0];
 401   guint8 a = src[3];
 402   guint8 dr, dg, db;
 403   guint32 color;
 404   gint r_shift, r_max, r_shift_out;
 405   gint g_shift, g_max, g_shift_out;
 406   gint b_shift, b_max, b_shift_out;
 407
 408   switch (xcontext->bpp) {
 409     case 8:
 410       color = *dest;
 411       break;
 412     case 16:
 413       color = GUINT16_FROM_LE (*(guint16 *) (dest));
 414       break;
 415     case 32:
 416       color = GUINT32_FROM_LE (*(guint32 *) (dest));
 417       break;
 418     default:
 419       /* Should not reach here */
 420       g_return_if_reached ();
 421   }
 422
 423   /* possible optimisation:
 424    * move the code that finds shift and max in the _link function */
 425   for (r_shift = 0; !(xcontext->visual->red_mask & (1 << r_shift)); r_shift++);
 426   for (g_shift = 0; !(xcontext->visual->green_mask & (1 << g_shift));
 427       g_shift++);
 428   for (b_shift = 0; !(xcontext->visual->blue_mask & (1 << b_shift)); b_shift++);
 429
 430   for (r_shift_out = 0; !(xcontext->visual->red_mask & (1 << r_shift_out));
 431       r_shift_out++);
 432   for (g_shift_out = 0; !(xcontext->visual->green_mask & (1 << g_shift_out));
 433       g_shift_out++);
 434   for (b_shift_out = 0; !(xcontext->visual->blue_mask & (1 << b_shift_out));
 435       b_shift_out++);
 436
 437
 438   r_max = (xcontext->visual->red_mask >> r_shift);
 439   b_max = (xcontext->visual->blue_mask >> b_shift);
 440   g_max = (xcontext->visual->green_mask >> g_shift);
 441
 442 #define RGBXXX_R(x)  (((x)>>r_shift) & (r_max))
 443 #define RGBXXX_G(x)  (((x)>>g_shift) & (g_max))
 444 #define RGBXXX_B(x)  (((x)>>b_shift) & (b_max))
 445
 446   dr = (RGBXXX_R (color) * 255) / r_max;
 447   dg = (RGBXXX_G (color) * 255) / g_max;
 448   db = (RGBXXX_B (color) * 255) / b_max;
 449
 450   dr = (r * a + (0xff - a) * dr) / 0xff;
 451   dg = (g * a + (0xff - a) * dg) / 0xff;
 452   db = (b * a + (0xff - a) * db) / 0xff;
 453
 454   color = (((dr * r_max) / 255) << r_shift_out) +
 455       (((dg * g_max) / 255) << g_shift_out) +
 456       (((db * b_max) / 255) << b_shift_out);
 457
 458   switch (xcontext->bpp) {
 459     case 8:
 460       *dest = color;
 461       break;
 462     case 16:
 463       *(guint16 *) (dest) = color;
 464       break;
 465     case 32:
 466       *(guint32 *) (dest) = color;
 467       break;
 468     default:
 469       g_warning ("bpp %d not supported\n", xcontext->bpp);
 470   }
 471 }
 472 #endif
 473
 474 #ifdef HAVE_XDAMAGE
 475 static void
 476 copy_buffer (GstBuffer * dest, GstBuffer * src)
 477 {
 478   GstMapInfo map;
 479
 480   gst_buffer_map (src, &map, GST_MAP_READ);
 481   gst_buffer_fill (dest, 0, map.data, map.size);
 482   gst_buffer_unmap (src, &map);
 483 }
 484 #endif
 485
 486 /* Retrieve an XImageSrcBuffer, preferably from our
 487  * pool of existing images and populate it from the window */
 488 static GstBuffer *
 489 gst_ximage_src_ximage_get (GstXImageSrc * ximagesrc)
 490 {
 491   GstBuffer *ximage = NULL;
 492   GstMetaXImage *meta;
 493
 494   g_mutex_lock (&ximagesrc->pool_lock);
 495   while (ximagesrc->buffer_pool != NULL) {
 496     ximage = ximagesrc->buffer_pool->data;
 497
 498     meta = GST_META_XIMAGE_GET (ximage);
 499
 500     ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool,
 501         ximagesrc->buffer_pool);
 502
 503     if ((meta->width == ximagesrc->width) ||
 504         (meta->height == ximagesrc->height))
 505       break;
 506
 507     gst_ximage_buffer_free (ximage);
 508     ximage = NULL;
 509   }
 510   g_mutex_unlock (&ximagesrc->pool_lock);
 511
 512   if (ximage == NULL) {
 513     GST_DEBUG_OBJECT (ximagesrc, "creating image (%dx%d)",
 514         ximagesrc->width, ximagesrc->height);
 515
 516     g_mutex_lock (&ximagesrc->x_lock);
 517     ximage = gst_ximageutil_ximage_new (ximagesrc->xcontext,
 518         GST_ELEMENT (ximagesrc), ximagesrc->width, ximagesrc->height,
 519         (BufferReturnFunc) (gst_ximage_src_return_buf));
 520     if (ximage == NULL) {
 521       GST_ELEMENT_ERROR (ximagesrc, RESOURCE, WRITE, (NULL),
 522           ("could not create a %dx%d ximage", ximagesrc->width,
 523               ximagesrc->height));
 524       g_mutex_unlock (&ximagesrc->x_lock);
 525       return NULL;
 526     }
 527
 528     g_mutex_unlock (&ximagesrc->x_lock);
 529   }
 530
 531   g_return_val_if_fail (GST_IS_XIMAGE_SRC (ximagesrc), NULL);
 532
 533   meta = GST_META_XIMAGE_GET (ximage);
 534
 535 #ifdef HAVE_XDAMAGE
 536   if (ximagesrc->have_xdamage && ximagesrc->use_damage &&
 537       ximagesrc->last_ximage != NULL) {
 538     XEvent ev;
 539     gboolean have_damage = FALSE;
 540
 541     /* have_frame is TRUE when either the entire screen has been
 542      * grabbed or when the last image has been copied */
 543     gboolean have_frame = FALSE;
 544
 545     GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XDamage");
 546
 547     do {
 548       XDamageNotifyEvent *damage_ev = (XDamageNotifyEvent *) (&ev);
 549
 550       XNextEvent (ximagesrc->xcontext->disp, &ev);
 551
 552       if (ev.type == ximagesrc->damage_event_base + XDamageNotify &&
 553           damage_ev->level == XDamageReportNonEmpty) {
 554
 555         XDamageSubtract (ximagesrc->xcontext->disp, ximagesrc->damage, None,
 556             ximagesrc->damage_region);
 557         have_damage = TRUE;
 558       }
 559     } while (XPending (ximagesrc->xcontext->disp));
 560
 561     if (have_damage) {
 562       XRectangle *rects;
 563       int nrects;
 564
 565       /* Now copy out all of the damaged rectangles. */
 566       rects =
 567           XFixesFetchRegion (ximagesrc->xcontext->disp,
 568           ximagesrc->damage_region, &nrects);
 569       if (rects != NULL) {
 570         int i;
 571
 572         if (!have_frame) {
 573           GST_LOG_OBJECT (ximagesrc,
 574               "Copying from last frame ximage->size: %" G_GSIZE_FORMAT,
 575               gst_buffer_get_size (ximage));
 576           copy_buffer (ximage, ximagesrc->last_ximage);
 577           have_frame = TRUE;
 578         }
 579         for (i = 0; i < nrects; i++) {
 580           GST_LOG_OBJECT (ximagesrc,
 581               "Damaged sub-region @ %d,%d size %dx%d reported",
 582               rects[i].x, rects[i].y, rects[i].width, rects[i].height);
 583
 584           /* if we only want a small area, clip this damage region to
 585            * area we want */
 586           if (ximagesrc->endx > ximagesrc->startx &&
 587               ximagesrc->endy > ximagesrc->starty) {
 588             /* see if damage area intersects */
 589             if (rects[i].x + rects[i].width - 1 < ximagesrc->startx ||
 590                 rects[i].x > ximagesrc->endx) {
 591               /* trivial reject */
 592             } else if (rects[i].y + rects[i].height - 1 < ximagesrc->starty ||
 593                 rects[i].y > ximagesrc->endy) {
 594               /* trivial reject */
 595             } else {
 596               /* find intersect region */
 597               int startx, starty, width, height;
 598
 599               startx = (rects[i].x < ximagesrc->startx) ? ximagesrc->startx :
 600                   rects[i].x;
 601               starty = (rects[i].y < ximagesrc->starty) ? ximagesrc->starty :
 602                   rects[i].y;
 603               width = (rects[i].x + rects[i].width - 1 < ximagesrc->endx) ?
 604                   rects[i].x + rects[i].width - startx :
 605                   ximagesrc->endx - startx + 1;
 606               height = (rects[i].y + rects[i].height - 1 < ximagesrc->endy) ?
 607                   rects[i].y + rects[i].height - starty : ximagesrc->endy -
 608                   starty + 1;
 609
 610               GST_LOG_OBJECT (ximagesrc,
 611                   "Retrieving damaged sub-region @ %d,%d size %dx%d as intersect region",
 612                   startx, starty, width, height);
 613               XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
 614                   startx, starty, width, height, AllPlanes, ZPixmap,
 615                   meta->ximage, startx - ximagesrc->startx,
 616                   starty - ximagesrc->starty);
 617             }
 618           } else {
 619
 620             GST_LOG_OBJECT (ximagesrc,
 621                 "Retrieving damaged sub-region @ %d,%d size %dx%d",
 622                 rects[i].x, rects[i].y, rects[i].width, rects[i].height);
 623
 624             XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
 625                 rects[i].x, rects[i].y,
 626                 rects[i].width, rects[i].height,
 627                 AllPlanes, ZPixmap, meta->ximage, rects[i].x, rects[i].y);
 628           }
 629         }
 630         XFree (rects);
 631       }
 632     }
 633     if (!have_frame) {
 634       GST_LOG_OBJECT (ximagesrc,
 635           "Copying from last frame ximage->size: %" G_GSIZE_FORMAT,
 636           gst_buffer_get_size (ximage));
 637       copy_buffer (ximage, ximagesrc->last_ximage);
 638     }
 639 #ifdef HAVE_XFIXES
 640     /* re-get area where last mouse pointer was  but only if in our clipping
 641      * bounds */
 642     if (ximagesrc->cursor_image) {
 643       gint x, y, width, height;
 644
 645       x = ximagesrc->cursor_image->x - ximagesrc->cursor_image->xhot -
 646           ximagesrc->x;
 647       y = ximagesrc->cursor_image->y - ximagesrc->cursor_image->yhot -
 648           ximagesrc->y;
 649       width = ximagesrc->cursor_image->width;
 650       height = ximagesrc->cursor_image->height;
 651
 652       /* bounds checking */
 653       if (x < 0)
 654         x = 0;
 655       if (y < 0)
 656         y = 0;
 657       if (x + width > ximagesrc->xcontext->width)
 658         width = ximagesrc->xcontext->width - x;
 659       if (y + height > ximagesrc->xcontext->height)
 660         height = ximagesrc->xcontext->height - y;
 661       g_assert (x >= 0);
 662       g_assert (y >= 0);
 663       GST_DEBUG_OBJECT (ximagesrc,
 664           "Cursor was at (%d,%d) width: %d, height: %d and our range is: (%d,%d) - (%d,%d)",
 665           x, y, width, height, ximagesrc->startx, ximagesrc->starty,
 666           ximagesrc->endx, ximagesrc->endy);
 667       /* only get where cursor last was, if it is in our range */
 668       if (ximagesrc->endx > ximagesrc->startx &&
 669           ximagesrc->endy > ximagesrc->starty) {
 670         /* check bounds */
 671         if (x + width < ximagesrc->startx || x > ximagesrc->endx) {
 672           /* trivial reject */
 673         } else if (y + height < ximagesrc->starty || y > ximagesrc->endy) {
 674           /* trivial reject */
 675         } else {
 676           /* find intersect region */
 677           int startx, starty, iwidth, iheight;
 678
 679           startx = (x < ximagesrc->startx) ? ximagesrc->startx : x;
 680           starty = (y < ximagesrc->starty) ? ximagesrc->starty : y;
 681           iwidth = (x + width < ximagesrc->endx) ?
 682               x + width - startx : ximagesrc->endx - startx;
 683           iheight = (y + height < ximagesrc->endy) ?
 684               y + height - starty : ximagesrc->endy - starty;
 685           GST_DEBUG_OBJECT (ximagesrc, "Removing cursor from %d,%d", x, y);
 686           XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
 687               startx, starty, iwidth, iheight, AllPlanes, ZPixmap,
 688               meta->ximage, startx - ximagesrc->startx,
 689               starty - ximagesrc->starty);
 690         }
 691       } else {
 692
 693         GST_DEBUG_OBJECT (ximagesrc, "Removing cursor from %d,%d", x, y);
 694         XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
 695             x, y, width, height, AllPlanes, ZPixmap, meta->ximage, x, y);
 696       }
 697     }
 698 #endif
 699
 700
 701   } else {
 702 #endif
 703
 704 #ifdef HAVE_XSHM
 705     if (ximagesrc->xcontext->use_xshm) {
 706       GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XShm");
 707       XShmGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
 708           meta->ximage, ximagesrc->startx, ximagesrc->starty, AllPlanes);
 709
 710     } else
 711 #endif /* HAVE_XSHM */
 712     {
 713       GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XGetImage");
 714       if (ximagesrc->remote) {
 715         XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
 716             ximagesrc->startx, ximagesrc->starty, ximagesrc->width,
 717             ximagesrc->height, AllPlanes, ZPixmap, meta->ximage, 0, 0);
 718       } else {
 719         meta->ximage =
 720             XGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
 721             ximagesrc->startx, ximagesrc->starty, ximagesrc->width,
 722             ximagesrc->height, AllPlanes, ZPixmap);
 723       }
 724     }
 725 #ifdef HAVE_XDAMAGE
 726   }
 727 #endif
 728
 729 #ifdef HAVE_XFIXES
 730   if (ximagesrc->show_pointer && ximagesrc->have_xfixes
 731       && gst_ximage_is_pointer_in_region (ximagesrc)) {
 732
 733     GST_DEBUG_OBJECT (ximagesrc, "Using XFixes to draw cursor");
 734     /* get cursor */
 735     if (ximagesrc->cursor_image)
 736       XFree (ximagesrc->cursor_image);
 737     ximagesrc->cursor_image = XFixesGetCursorImage (ximagesrc->xcontext->disp);
 738     if (ximagesrc->cursor_image != NULL) {
 739       int cx, cy, i, j, count;
 740       int startx, starty, iwidth, iheight;
 741       gboolean cursor_in_image = TRUE;
 742
 743       cx = ximagesrc->cursor_image->x - ximagesrc->cursor_image->xhot -
 744           ximagesrc->x;
 745       cy = ximagesrc->cursor_image->y - ximagesrc->cursor_image->yhot -
 746           ximagesrc->y;
 747       count = ximagesrc->cursor_image->width * ximagesrc->cursor_image->height;
 748
 749       /* only get where cursor last was, if it is in our range */
 750       if (ximagesrc->endx > ximagesrc->startx &&
 751           ximagesrc->endy > ximagesrc->starty) {
 752         /* check bounds */
 753         if (cx + ximagesrc->cursor_image->width < (int) ximagesrc->startx ||
 754             cx > (int) ximagesrc->endx) {
 755           /* trivial reject */
 756           cursor_in_image = FALSE;
 757         } else if (cy + ximagesrc->cursor_image->height <
 758             (int) ximagesrc->starty || cy > (int) ximagesrc->endy) {
 759           /* trivial reject */
 760           cursor_in_image = FALSE;
 761         } else {
 762           /* find intersect region */
 763
 764           startx = (cx < (int) ximagesrc->startx) ? ximagesrc->startx : cx;
 765           starty = (cy < (int) ximagesrc->starty) ? ximagesrc->starty : cy;
 766           iwidth = (cx + ximagesrc->cursor_image->width < ximagesrc->endx) ?
 767               cx + ximagesrc->cursor_image->width - startx :
 768               ximagesrc->endx - startx;
 769           iheight =
 770               (cy + ximagesrc->cursor_image->height <
 771               ximagesrc->endy) ? cy + ximagesrc->cursor_image->height -
 772               starty : ximagesrc->endy - starty;
 773         }
 774       } else {
 775         startx = cx;
 776         starty = cy;
 777         iwidth = ximagesrc->cursor_image->width;
 778         iheight = ximagesrc->cursor_image->height;
 779       }
 780
 781       if (cursor_in_image) {
 782         GST_DEBUG_OBJECT (ximagesrc, "Cursor is in image so trying to draw it");
 783         for (i = 0; i < count; i++)
 784           ximagesrc->cursor_image->pixels[i] =
 785               GUINT_TO_LE (ximagesrc->cursor_image->pixels[i]);
 786         /* copy those pixels across */
 787         for (j = starty;
 788             j < starty + iheight
 789             && j < ximagesrc->starty + ximagesrc->height; j++) {
 790           for (i = startx;
 791               i < startx + iwidth
 792               && i < ximagesrc->startx + ximagesrc->width; i++) {
 793             guint8 *src, *dest;
 794
 795             src =
 796                 (guint8 *) & (ximagesrc->cursor_image->pixels[((j -
 797                             cy) * ximagesrc->cursor_image->width + (i - cx))]);
 798             dest =
 799                 (guint8 *) & (meta->ximage->data[((j -
 800                             ximagesrc->starty) * ximagesrc->width + (i -
 801                             ximagesrc->startx)) *
 802                     (ximagesrc->xcontext->bpp / 8)]);
 803
 804             composite_pixel (ximagesrc->xcontext, (guint8 *) dest,
 805                 (guint8 *) src);
 806           }
 807         }
 808       }
 809     }
 810   }
 811 #endif
 812 #ifdef HAVE_XDAMAGE
 813   if (ximagesrc->have_xdamage && ximagesrc->use_damage) {
 814     /* need to ref ximage to put in last_ximage */
 815     gst_buffer_ref (ximage);
 816     if (ximagesrc->last_ximage) {
 817       gst_buffer_unref (ximagesrc->last_ximage);
 818     }
 819     ximagesrc->last_ximage = ximage;
 820     GST_LOG_OBJECT (ximagesrc, "reffing current buffer for last_ximage");
 821   }
 822 #endif
 823   return ximage;
 824 }
 825
 826 static GstFlowReturn
 827 gst_ximage_src_create (GstPushSrc * bs, GstBuffer ** buf)
 828 {
 829   GstXImageSrc *s = GST_XIMAGE_SRC (bs);
 830   GstBuffer *image;
 831   GstClockTime base_time;
 832   GstClockTime next_capture_ts;
 833   GstClockTime dur;
 834   gint64 next_frame_no;
 835
 836   if (!gst_ximage_src_recalc (s)) {
 837     GST_ELEMENT_ERROR (s, RESOURCE, FAILED,
 838         (_("Changing resolution at runtime is not yet supported.")), (NULL));
 839     return GST_FLOW_ERROR;
 840   }
 841
 842   if (s->fps_n <= 0 || s->fps_d <= 0)
 843     return GST_FLOW_NOT_NEGOTIATED;     /* FPS must be > 0 */
 844
 845   /* Now, we might need to wait for the next multiple of the fps
 846    * before capturing */
 847
 848   GST_OBJECT_LOCK (s);
 849   if (GST_ELEMENT_CLOCK (s) == NULL) {
 850     GST_OBJECT_UNLOCK (s);
 851     GST_ELEMENT_ERROR (s, RESOURCE, FAILED,
 852         (_("Cannot operate without a clock")), (NULL));
 853     return GST_FLOW_ERROR;
 854   }
 855
 856   base_time = GST_ELEMENT_CAST (s)->base_time;
 857   next_capture_ts = gst_clock_get_time (GST_ELEMENT_CLOCK (s));
 858   next_capture_ts -= base_time;
 859
 860   /* Figure out which 'frame number' position we're at, based on the cur time
 861    * and frame rate */
 862   next_frame_no = gst_util_uint64_scale (next_capture_ts,
 863       s->fps_n, GST_SECOND * s->fps_d);
 864   if (next_frame_no == s->last_frame_no) {
 865     GstClockID id;
 866     GstClockReturn ret;
 867
 868     /* Need to wait for the next frame */
 869     next_frame_no += 1;
 870
 871     /* Figure out what the next frame time is */
 872     next_capture_ts = gst_util_uint64_scale (next_frame_no,
 873         s->fps_d * GST_SECOND, s->fps_n);
 874
 875     id = gst_clock_new_single_shot_id (GST_ELEMENT_CLOCK (s),
 876         next_capture_ts + base_time);
 877     s->clock_id = id;
 878
 879     /* release the object lock while waiting */
 880     GST_OBJECT_UNLOCK (s);
 881
 882     GST_DEBUG_OBJECT (s, "Waiting for next frame time %" G_GUINT64_FORMAT,
 883         next_capture_ts);
 884     ret = gst_clock_id_wait (id, NULL);
 885     GST_OBJECT_LOCK (s);
 886
 887     gst_clock_id_unref (id);
 888     s->clock_id = NULL;
 889     if (ret == GST_CLOCK_UNSCHEDULED) {
 890       /* Got woken up by the unlock function */
 891       GST_OBJECT_UNLOCK (s);
 892       return GST_FLOW_FLUSHING;
 893     }
 894     /* Duration is a complete 1/fps frame duration */
 895     dur = gst_util_uint64_scale_int (GST_SECOND, s->fps_d, s->fps_n);
 896   } else {
 897     GstClockTime next_frame_ts;
 898
 899     GST_DEBUG_OBJECT (s, "No need to wait for next frame time %"
 900         G_GUINT64_FORMAT " next frame = %" G_GINT64_FORMAT " prev = %"
 901         G_GINT64_FORMAT, next_capture_ts, next_frame_no, s->last_frame_no);
 902     next_frame_ts = gst_util_uint64_scale (next_frame_no + 1,
 903         s->fps_d * GST_SECOND, s->fps_n);
 904     /* Frame duration is from now until the next expected capture time */
 905     dur = next_frame_ts - next_capture_ts;
 906   }
 907   s->last_frame_no = next_frame_no;
 908   GST_OBJECT_UNLOCK (s);
 909
 910   image = gst_ximage_src_ximage_get (s);
 911   if (!image)
 912     return GST_FLOW_ERROR;
 913
 914   *buf = image;
 915   GST_BUFFER_DTS (*buf) = GST_CLOCK_TIME_NONE;
 916   GST_BUFFER_PTS (*buf) = next_capture_ts;
 917   GST_BUFFER_DURATION (*buf) = dur;
 918
 919   return GST_FLOW_OK;
 920 }
 921
 922 static void
 923 gst_ximage_src_set_property (GObject * object, guint prop_id,
 924     const GValue * value, GParamSpec * pspec)
 925 {
 926   GstXImageSrc *src = GST_XIMAGE_SRC (object);
 927
 928   switch (prop_id) {
 929     case PROP_DISPLAY_NAME:
 930
 931       g_free (src->display_name);
 932       src->display_name = g_strdup (g_value_get_string (value));
 933       break;
 934     case PROP_SHOW_POINTER:
 935       src->show_pointer = g_value_get_boolean (value);
 936       break;
 937     case PROP_USE_DAMAGE:
 938       src->use_damage = g_value_get_boolean (value);
 939       break;
 940     case PROP_STARTX:
 941       src->startx = g_value_get_uint (value);
 942       break;
 943     case PROP_STARTY:
 944       src->starty = g_value_get_uint (value);
 945       break;
 946     case PROP_ENDX:
 947       src->endx = g_value_get_uint (value);
 948       break;
 949     case PROP_ENDY:
 950       src->endy = g_value_get_uint (value);
 951       break;
 952     case PROP_REMOTE:
 953       src->remote = g_value_get_boolean (value);
 954       break;
 955     case PROP_XID:
 956       if (src->xcontext != NULL) {
 957         g_warning ("ximagesrc window ID must be set before opening display");
 958         break;
 959       }
 960       src->xid = g_value_get_uint64 (value);
 961       break;
 962     case PROP_XNAME:
 963       if (src->xcontext != NULL) {
 964         g_warning ("ximagesrc window name must be set before opening display");
 965         break;
 966       }
 967       g_free (src->xname);
 968       src->xname = g_strdup (g_value_get_string (value));
 969       break;
 970     default:
 971       break;
 972   }
 973 }
 974
 975 static void
 976 gst_ximage_src_get_property (GObject * object, guint prop_id,
 977     GValue * value, GParamSpec * pspec)
 978 {
 979   GstXImageSrc *src = GST_XIMAGE_SRC (object);
 980
 981   switch (prop_id) {
 982     case PROP_DISPLAY_NAME:
 983       if (src->xcontext)
 984         g_value_set_string (value, DisplayString (src->xcontext->disp));
 985       else
 986         g_value_set_string (value, src->display_name);
 987
 988       break;
 989     case PROP_SHOW_POINTER:
 990       g_value_set_boolean (value, src->show_pointer);
 991       break;
 992     case PROP_USE_DAMAGE:
 993       g_value_set_boolean (value, src->use_damage);
 994       break;
 995     case PROP_STARTX:
 996       g_value_set_uint (value, src->startx);
 997       break;
 998     case PROP_STARTY:
 999       g_value_set_uint (value, src->starty);
1000       break;
1001     case PROP_ENDX:
1002       g_value_set_uint (value, src->endx);
1003       break;
1004     case PROP_ENDY:
1005       g_value_set_uint (value, src->endy);
1006       break;
1007     case PROP_REMOTE:
1008       g_value_set_boolean (value, src->remote);
1009       break;
1010     case PROP_XID:
1011       g_value_set_uint64 (value, src->xid);
1012       break;
1013     case PROP_XNAME:
1014       g_value_set_string (value, src->xname);
1015       break;
1016     default:
1017       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1018       break;
1019   }
1020 }
1021
1022 static void
1023 gst_ximage_src_clear_bufpool (GstXImageSrc * ximagesrc)
1024 {
1025   g_mutex_lock (&ximagesrc->pool_lock);
1026   while (ximagesrc->buffer_pool != NULL) {
1027     GstBuffer *ximage = ximagesrc->buffer_pool->data;
1028
1029     gst_ximage_buffer_free (ximage);
1030
1031     ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool,
1032         ximagesrc->buffer_pool);
1033   }
1034   g_mutex_unlock (&ximagesrc->pool_lock);
1035 }
1036
1037 static void
1038 gst_ximage_src_dispose (GObject * object)
1039 {
1040   /* Drop references in the buffer_pool */
1041   gst_ximage_src_clear_bufpool (GST_XIMAGE_SRC (object));
1042
1043   G_OBJECT_CLASS (parent_class)->dispose (object);
1044 }
1045
1046 static void
1047 gst_ximage_src_finalize (GObject * object)
1048 {
1049   GstXImageSrc *src = GST_XIMAGE_SRC (object);
1050
1051   if (src->xcontext)
1052     ximageutil_xcontext_clear (src->xcontext);
1053
1054   g_free (src->xname);
1055   g_mutex_clear (&src->pool_lock);
1056   g_mutex_clear (&src->x_lock);
1057
1058   G_OBJECT_CLASS (parent_class)->finalize (object);
1059 }
1060
1061 static GstCaps *
1062 gst_ximage_src_get_caps (GstBaseSrc * bs, GstCaps * filter)
1063 {
1064   GstXImageSrc *s = GST_XIMAGE_SRC (bs);
1065   GstXContext *xcontext;
1066   gint width, height;
1067   GstVideoFormat format;
1068   guint32 alpha_mask;
1069
1070   if ((!s->xcontext) && (!gst_ximage_src_open_display (s, s->display_name)))
1071     return gst_pad_get_pad_template_caps (GST_BASE_SRC (s)->srcpad);
1072
1073   if (!gst_ximage_src_recalc (s))
1074     return gst_pad_get_pad_template_caps (GST_BASE_SRC (s)->srcpad);
1075
1076   xcontext = s->xcontext;
1077   width = s->xcontext->width;
1078   height = s->xcontext->height;
1079   if (s->xwindow != 0) {
1080     XWindowAttributes attrs;
1081     int status = XGetWindowAttributes (s->xcontext->disp, s->xwindow, &attrs);
1082     if (status) {
1083       width = attrs.width;
1084       height = attrs.height;
1085     }
1086   }
1087
1088   /* property comments say 0 means right/bottom, means we can't capture
1089      the top left pixel alone */
1090   if (s->endx == 0)
1091     s->endx = width - 1;
1092   if (s->endy == 0)
1093     s->endy = height - 1;
1094
1095   if (s->endx >= s->startx && s->endy >= s->starty) {
1096     /* this means user has put in values */
1097     if (s->startx < xcontext->width && s->endx < xcontext->width &&
1098         s->starty < xcontext->height && s->endy < xcontext->height) {
1099       /* values are fine */
1100       s->width = width = s->endx - s->startx + 1;
1101       s->height = height = s->endy - s->starty + 1;
1102     } else {
1103       GST_WARNING
1104           ("User put in co-ordinates overshooting the X resolution, setting to full screen");
1105       s->startx = 0;
1106       s->starty = 0;
1107       s->endx = width - 1;
1108       s->endy = height - 1;
1109     }
1110   } else {
1111     GST_WARNING ("User put in bogus co-ordinates, setting to full screen");
1112     s->startx = 0;
1113     s->starty = 0;
1114     s->endx = width - 1;
1115     s->endy = height - 1;
1116   }
1117   GST_DEBUG ("width = %d, height=%d", width, height);
1118
1119   /* extrapolate alpha mask */
1120   if (xcontext->depth == 32) {
1121     alpha_mask = ~(xcontext->r_mask_output
1122         | xcontext->g_mask_output | xcontext->b_mask_output);
1123   } else {
1124     alpha_mask = 0;
1125   }
1126
1127   format =
1128       gst_video_format_from_masks (xcontext->depth, xcontext->bpp,
1129       xcontext->endianness, xcontext->r_mask_output,
1130       xcontext->g_mask_output, xcontext->b_mask_output, alpha_mask);
1131
1132   return gst_caps_new_simple ("video/x-raw",
1133       "format", G_TYPE_STRING, gst_video_format_to_string (format),
1134       "width", G_TYPE_INT, width,
1135       "height", G_TYPE_INT, height,
1136       "framerate", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1,
1137       "pixel-aspect-ratio", GST_TYPE_FRACTION, xcontext->par_n,
1138       xcontext->par_d, NULL);
1139 }
1140
1141 static gboolean
1142 gst_ximage_src_set_caps (GstBaseSrc * bs, GstCaps * caps)
1143 {
1144   GstXImageSrc *s = GST_XIMAGE_SRC (bs);
1145   GstStructure *structure;
1146   const GValue *new_fps;
1147
1148   /* If not yet opened, disallow setcaps until later */
1149   if (!s->xcontext)
1150     return FALSE;
1151
1152   /* The only thing that can change is the framerate downstream wants */
1153   structure = gst_caps_get_structure (caps, 0);
1154   new_fps = gst_structure_get_value (structure, "framerate");
1155   if (!new_fps)
1156     return FALSE;
1157
1158   /* Store this FPS for use when generating buffers */
1159   s->fps_n = gst_value_get_fraction_numerator (new_fps);
1160   s->fps_d = gst_value_get_fraction_denominator (new_fps);
1161
1162   GST_DEBUG_OBJECT (s, "peer wants %d/%d fps", s->fps_n, s->fps_d);
1163
1164   return TRUE;
1165 }
1166
1167 static GstCaps *
1168 gst_ximage_src_fixate (GstBaseSrc * bsrc, GstCaps * caps)
1169 {
1170   gint i;
1171   GstStructure *structure;
1172
1173   caps = gst_caps_make_writable (caps);
1174
1175   for (i = 0; i < gst_caps_get_size (caps); ++i) {
1176     structure = gst_caps_get_structure (caps, i);
1177
1178     gst_structure_fixate_field_nearest_fraction (structure, "framerate", 25, 1);
1179   }
1180   caps = GST_BASE_SRC_CLASS (parent_class)->fixate (bsrc, caps);
1181
1182   return caps;
1183 }
1184
1185 static void
1186 gst_ximage_src_class_init (GstXImageSrcClass * klass)
1187 {
1188   GObjectClass *gc = G_OBJECT_CLASS (klass);
1189   GstElementClass *ec = GST_ELEMENT_CLASS (klass);
1190   GstBaseSrcClass *bc = GST_BASE_SRC_CLASS (klass);
1191   GstPushSrcClass *push_class = GST_PUSH_SRC_CLASS (klass);
1192
1193   gc->set_property = gst_ximage_src_set_property;
1194   gc->get_property = gst_ximage_src_get_property;
1195   gc->dispose = gst_ximage_src_dispose;
1196   gc->finalize = gst_ximage_src_finalize;
1197
1198   g_object_class_install_property (gc, PROP_DISPLAY_NAME,
1199       g_param_spec_string ("display-name", "Display", "X Display Name",
1200           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1201   g_object_class_install_property (gc, PROP_SHOW_POINTER,
1202       g_param_spec_boolean ("show-pointer", "Show Mouse Pointer",
1203           "Show mouse pointer (if XFixes extension enabled)", TRUE,
1204           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1205   /**
1206    * GstXImageSrc:use-damage:
1207    *
1208    * Use XDamage (if the XDamage extension is enabled)
1209    */
1210   g_object_class_install_property (gc, PROP_USE_DAMAGE,
1211       g_param_spec_boolean ("use-damage", "Use XDamage",
1212           "Use XDamage (if XDamage extension enabled)", TRUE,
1213           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1214   /**
1215    * GstXImageSrc:startx:
1216    *
1217    * X coordinate of top left corner of area to be recorded
1218    * (0 for top left of screen)
1219    */
1220   g_object_class_install_property (gc, PROP_STARTX,
1221       g_param_spec_uint ("startx", "Start X co-ordinate",
1222           "X coordinate of top left corner of area to be recorded (0 for top left of screen)",
1223           0, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1224   /**
1225    * GstXImageSrc:starty:
1226    *
1227    * Y coordinate of top left corner of area to be recorded
1228    * (0 for top left of screen)
1229    */
1230   g_object_class_install_property (gc, PROP_STARTY,
1231       g_param_spec_uint ("starty", "Start Y co-ordinate",
1232           "Y coordinate of top left corner of area to be recorded (0 for top left of screen)",
1233           0, G_MAXINT, 0, G_PARAM_READWRITE));
1234   /**
1235    * GstXImageSrc:endx:
1236    *
1237    * X coordinate of bottom right corner of area to be recorded
1238    * (0 for bottom right of screen)
1239    */
1240   g_object_class_install_property (gc, PROP_ENDX,
1241       g_param_spec_uint ("endx", "End X",
1242           "X coordinate of bottom right corner of area to be recorded (0 for bottom right of screen)",
1243           0, G_MAXINT, 0, G_PARAM_READWRITE));
1244   /**
1245    * GstXImageSrc:endy:
1246    *
1247    * Y coordinate of bottom right corner of area to be recorded
1248    * (0 for bottom right of screen)
1249    */
1250   g_object_class_install_property (gc, PROP_ENDY,
1251       g_param_spec_uint ("endy", "End Y",
1252           "Y coordinate of bottom right corner of area to be recorded (0 for bottom right of screen)",
1253           0, G_MAXINT, 0, G_PARAM_READWRITE));
1254
1255   /**
1256    * GstXImageSrc:remote:
1257    *
1258    * Whether the X display is remote. The element will try to use alternate calls
1259    * known to work better with remote displays.
1260    */
1261   g_object_class_install_property (gc, PROP_REMOTE,
1262       g_param_spec_boolean ("remote", "Remote dispay",
1263           "Whether the display is remote", FALSE,
1264           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1265   /**
1266    * GstXImageSrc:xid:
1267    *
1268    * The XID of the window to capture. 0 for the root window (default).
1269    */
1270   g_object_class_install_property (gc, PROP_XID,
1271       g_param_spec_uint64 ("xid", "Window XID",
1272           "Window XID to capture from", 0, G_MAXUINT64, 0,
1273           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1274   /**
1275    * GstXImageSrc:xname:
1276    *
1277    * The name of the window to capture, if any.
1278    */
1279   g_object_class_install_property (gc, PROP_XNAME,
1280       g_param_spec_string ("xname", "Window name",
1281           "Window name to capture from", NULL,
1282           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1283
1284   gst_element_class_set_static_metadata (ec, "Ximage video source",
1285       "Source/Video",
1286       "Creates a screenshot video stream",
1287       "Lutz Mueller <lutz@users.sourceforge.net>, "
1288       "Jan Schmidt <thaytan@mad.scientist.com>, "
1289       "Zaheer Merali <zaheerabbas at merali dot org>");
1290   gst_element_class_add_static_pad_template (ec, &t);
1291
1292   bc->fixate = gst_ximage_src_fixate;
1293   bc->get_caps = gst_ximage_src_get_caps;
1294   bc->set_caps = gst_ximage_src_set_caps;
1295   bc->start = gst_ximage_src_start;
1296   bc->stop = gst_ximage_src_stop;
1297   bc->unlock = gst_ximage_src_unlock;
1298   push_class->create = gst_ximage_src_create;
1299 }
1300
1301 static void
1302 gst_ximage_src_init (GstXImageSrc * ximagesrc)
1303 {
1304   gst_base_src_set_format (GST_BASE_SRC (ximagesrc), GST_FORMAT_TIME);
1305   gst_base_src_set_live (GST_BASE_SRC (ximagesrc), TRUE);
1306
1307   g_mutex_init (&ximagesrc->pool_lock);
1308   g_mutex_init (&ximagesrc->x_lock);
1309   ximagesrc->show_pointer = TRUE;
1310   ximagesrc->use_damage = TRUE;
1311   ximagesrc->startx = 0;
1312   ximagesrc->starty = 0;
1313   ximagesrc->endx = 0;
1314   ximagesrc->endy = 0;
1315   ximagesrc->remote = FALSE;
1316 }
1317
1318 static gboolean
1319 plugin_init (GstPlugin * plugin)
1320 {
1321   gboolean ret;
1322
1323   GST_DEBUG_CATEGORY_INIT (gst_debug_ximage_src, "ximagesrc", 0,
1324       "ximagesrc element debug");
1325
1326   ret = gst_element_register (plugin, "ximagesrc", GST_RANK_NONE,
1327       GST_TYPE_XIMAGE_SRC);
1328
1329   return ret;
1330 }
1331
1332 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1333     GST_VERSION_MINOR,
1334     ximagesrc,
1335     "X11 video input plugin using standard Xlib calls",
1336     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);