sys/winscreencap/gstgdiscreencapsrc.c

   1 /* GStreamer
   2  * Copyright (C) 2007 Haakon Sporsheim <hakon.sporsheim@tandberg.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:element-gdiscreencapsrc
  22  *
  23  * This element uses GDI to capture the desktop or a portion of it.
  24  * The default is capturing the whole desktop, but #GstGDIScreenCapSrc:x,
  25  * #GstGDIScreenCapSrc:y, #GstGDIScreenCapSrc:width and
  26  * #GstGDIScreenCapSrc:height can be used to select a particular region.
  27  * Use #GstGDIScreenCapSrc:monitor for changing which monitor to capture
  28  * from.
  29  *
  30  * Set #GstGDIScreenCapSrc:cursor to TRUE to include the mouse cursor.
  31  *
  32  * <refsect2>
  33  * <title>Example pipelines</title>
  34  * |[
  35  * gst-launch gdiscreencapsrc ! ffmpegcolorspace ! dshowvideosink
  36  * ]| Capture the desktop and display it.
  37  * |[
  38  * gst-launch gdiscreencapsrc x=100 y=100 width=320 height=240 cursor=TRUE
  39  * ! ffmpegcolorspace ! dshowvideosink
  40  * ]| Capture a portion of the desktop, including the mouse cursor, and
  41  * display it.
  42  * </refsect2>
  43  */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include "config.h"
  47 #endif
  48
  49 #include "gstgdiscreencapsrc.h"
  50 #include <gst/video/video.h>
  51
  52 GST_DEBUG_CATEGORY_STATIC (gdiscreencapsrc_debug);
  53
  54 static GstStaticPadTemplate src_template =
  55 GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
  56     GST_STATIC_CAPS (GST_VIDEO_CAPS_BGR));
  57
  58 GST_BOILERPLATE (GstGDIScreenCapSrc, gst_gdiscreencapsrc,
  59     GstPushSrc, GST_TYPE_PUSH_SRC);
  60
  61 enum
  62 {
  63   PROP_0,
  64   PROP_MONITOR,
  65   PROP_SHOW_CURSOR,
  66   PROP_X_POS,
  67   PROP_Y_POS,
  68   PROP_WIDTH,
  69   PROP_HEIGHT
  70 };
  71
  72 /* Fwd. decl. */
  73 static void gst_gdiscreencapsrc_dispose (GObject * object);
  74 static void gst_gdiscreencapsrc_set_property (GObject * object, guint prop_id,
  75     const GValue * value, GParamSpec * pspec);
  76 static void gst_gdiscreencapsrc_get_property (GObject * object, guint prop_id,
  77     GValue * value, GParamSpec * pspec);
  78
  79 static void gst_gdiscreencapsrc_fixate (GstPad * pad, GstCaps * caps);
  80 static gboolean gst_gdiscreencapsrc_set_caps (GstBaseSrc * bsrc,
  81     GstCaps * caps);
  82 static GstCaps *gst_gdiscreencapsrc_get_caps (GstBaseSrc * bsrc);
  83 static gboolean gst_gdiscreencapsrc_start (GstBaseSrc * bsrc);
  84 static gboolean gst_gdiscreencapsrc_stop (GstBaseSrc * bsrc);
  85
  86 static void gst_gdiscreencapsrc_get_times (GstBaseSrc * basesrc,
  87     GstBuffer * buffer, GstClockTime * start, GstClockTime * end);
  88 static GstFlowReturn gst_gdiscreencapsrc_create (GstPushSrc * src,
  89     GstBuffer ** buf);
  90
  91 static gboolean gst_gdiscreencapsrc_screen_capture (GstGDIScreenCapSrc * src,
  92     GstBuffer * buf);
  93
  94 /* Implementation. */
  95 static void
  96 gst_gdiscreencapsrc_base_init (gpointer klass)
  97 {
  98   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
  99
 100   gst_element_class_add_static_pad_template (element_class, &src_template);
 101   gst_element_class_set_details_simple (element_class,
 102       "GDI screen capture source", "Source/Video", "Captures screen",
 103       "Haakon Sporsheim <hakon.sporsheim@tandberg.com>");
 104 }
 105
 106 static void
 107 gst_gdiscreencapsrc_class_init (GstGDIScreenCapSrcClass * klass)
 108 {
 109   GObjectClass *go_class;
 110   GstBaseSrcClass *bs_class;
 111   GstPushSrcClass *ps_class;
 112
 113   go_class = (GObjectClass *) klass;
 114   bs_class = (GstBaseSrcClass *) klass;
 115   ps_class = (GstPushSrcClass *) klass;
 116
 117   go_class->dispose = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_dispose);
 118   go_class->set_property = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_set_property);
 119   go_class->get_property = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_get_property);
 120
 121   bs_class->get_times = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_get_times);
 122   bs_class->get_caps = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_get_caps);
 123   bs_class->set_caps = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_set_caps);
 124   bs_class->start = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_start);
 125   bs_class->stop = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_stop);
 126
 127   ps_class->create = GST_DEBUG_FUNCPTR (gst_gdiscreencapsrc_create);
 128
 129   g_object_class_install_property (go_class, PROP_MONITOR,
 130       g_param_spec_int ("monitor",
 131           "Monitor", "Which monitor to use (0 = 1st monitor and default)",
 132           0, G_MAXINT, 0, G_PARAM_READWRITE));
 133
 134   g_object_class_install_property (go_class, PROP_SHOW_CURSOR,
 135       g_param_spec_boolean ("cursor", "Show mouse cursor",
 136           "Whether to show mouse cursor (default off)",
 137           FALSE, G_PARAM_READWRITE));
 138
 139   g_object_class_install_property (go_class, PROP_X_POS,
 140       g_param_spec_int ("x", "X",
 141           "Horizontal coordinate of top left corner for the screen capture "
 142           "area", 0, G_MAXINT, 0, G_PARAM_READWRITE));
 143   g_object_class_install_property (go_class, PROP_Y_POS,
 144       g_param_spec_int ("y", "Y",
 145           "Vertical coordinate of top left corner for the screen capture "
 146           "area", 0, G_MAXINT, 0, G_PARAM_READWRITE));
 147
 148   g_object_class_install_property (go_class, PROP_WIDTH,
 149       g_param_spec_int ("width", "Width",
 150           "Width of screen capture area (0 = maximum)",
 151           0, G_MAXINT, 0, G_PARAM_READWRITE));
 152   g_object_class_install_property (go_class, PROP_HEIGHT,
 153       g_param_spec_int ("height", "Height",
 154           "Height of screen capture area (0 = maximum)",
 155           0, G_MAXINT, 0, G_PARAM_READWRITE));
 156
 157   GST_DEBUG_CATEGORY_INIT (gdiscreencapsrc_debug,
 158       "gdiscreencapsrc", 0, "GDI screen capture source");
 159 }
 160
 161 static void
 162 gst_gdiscreencapsrc_init (GstGDIScreenCapSrc * src,
 163     GstGDIScreenCapSrcClass * klass)
 164 {
 165   /* Set src element inital values... */
 166   GstPad *src_pad = GST_BASE_SRC_PAD (src);
 167   gst_pad_set_fixatecaps_function (src_pad, gst_gdiscreencapsrc_fixate);
 168
 169   src->frames = 0;
 170   src->dibMem = NULL;
 171   src->hBitmap = (HBITMAP) INVALID_HANDLE_VALUE;
 172   src->memDC = (HDC) INVALID_HANDLE_VALUE;
 173   src->capture_x = 0;
 174   src->capture_y = 0;
 175   src->capture_w = 0;
 176   src->capture_h = 0;
 177
 178   src->monitor = 0;
 179   src->show_cursor = FALSE;
 180
 181   gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);
 182   gst_base_src_set_live (GST_BASE_SRC (src), TRUE);
 183 }
 184
 185 static void
 186 gst_gdiscreencapsrc_dispose (GObject * object)
 187 {
 188   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (object);
 189
 190   if (src->hBitmap != INVALID_HANDLE_VALUE)
 191     DeleteObject (src->hBitmap);
 192
 193   if (src->memDC != INVALID_HANDLE_VALUE)
 194     DeleteDC (src->memDC);
 195
 196   src->hBitmap = (HBITMAP) INVALID_HANDLE_VALUE;
 197   src->memDC = (HDC) INVALID_HANDLE_VALUE;
 198   src->dibMem = NULL;
 199 }
 200
 201 static void
 202 gst_gdiscreencapsrc_set_property (GObject * object, guint prop_id,
 203     const GValue * value, GParamSpec * pspec)
 204 {
 205   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (object);
 206
 207   switch (prop_id) {
 208     case PROP_MONITOR:
 209       if (g_value_get_int (value) >= GetSystemMetrics (SM_CMONITORS)) {
 210         G_OBJECT_WARN_INVALID_PSPEC (object, "Monitor", prop_id, pspec);
 211         break;
 212       }
 213       src->monitor = g_value_get_int (value);
 214       break;
 215     case PROP_SHOW_CURSOR:
 216       src->show_cursor = g_value_get_boolean (value);
 217       break;
 218     case PROP_X_POS:
 219       src->capture_x = g_value_get_int (value);
 220       break;
 221     case PROP_Y_POS:
 222       src->capture_y = g_value_get_int (value);
 223       break;
 224     case PROP_WIDTH:
 225       src->capture_w = g_value_get_int (value);
 226       break;
 227     case PROP_HEIGHT:
 228       src->capture_h = g_value_get_int (value);
 229       break;
 230     default:
 231       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 232       break;
 233   };
 234 }
 235
 236 static void
 237 gst_gdiscreencapsrc_get_property (GObject * object, guint prop_id,
 238     GValue * value, GParamSpec * pspec)
 239 {
 240   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (object);
 241
 242   switch (prop_id) {
 243     case PROP_MONITOR:
 244       g_value_set_int (value, src->monitor);
 245       break;
 246     case PROP_SHOW_CURSOR:
 247       g_value_set_boolean (value, src->show_cursor);
 248       break;
 249     case PROP_X_POS:
 250       g_value_set_int (value, src->capture_x);
 251       break;
 252     case PROP_Y_POS:
 253       g_value_set_int (value, src->capture_y);
 254       break;
 255     case PROP_WIDTH:
 256       g_value_set_int (value, src->capture_w);
 257       break;
 258     case PROP_HEIGHT:
 259       g_value_set_int (value, src->capture_h);
 260       break;
 261     default:
 262       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 263       break;
 264   };
 265 }
 266
 267 static void
 268 gst_gdiscreencapsrc_fixate (GstPad * pad, GstCaps * caps)
 269 {
 270   GstStructure *structure;
 271
 272   structure = gst_caps_get_structure (caps, 0);
 273
 274   gst_structure_fixate_field_nearest_int (structure, "width", 640);
 275   gst_structure_fixate_field_nearest_int (structure, "height", 480);
 276   gst_structure_fixate_field_nearest_fraction (structure, "framerate", 30, 1);
 277 }
 278
 279 static gboolean
 280 gst_gdiscreencapsrc_set_caps (GstBaseSrc * bsrc, GstCaps * caps)
 281 {
 282   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (bsrc);
 283   HWND capture;
 284   HDC device;
 285   GstStructure *structure;
 286   const GValue *framerate;
 287   gint red_mask, green_mask, blue_mask;
 288   gint bpp;
 289
 290   structure = gst_caps_get_structure (caps, 0);
 291
 292   gst_structure_get_int (structure, "red_mask", &red_mask);
 293   gst_structure_get_int (structure, "green_mask", &green_mask);
 294   gst_structure_get_int (structure, "blue_mask", &blue_mask);
 295   if (blue_mask != GST_VIDEO_BYTE1_MASK_24_INT ||
 296       green_mask != GST_VIDEO_BYTE2_MASK_24_INT ||
 297       red_mask != GST_VIDEO_BYTE3_MASK_24_INT) {
 298     GST_ERROR ("Wrong red_,green_,blue_ mask provided. "
 299         "We only support RGB and BGR");
 300
 301     return FALSE;
 302   }
 303
 304   gst_structure_get_int (structure, "bpp", &bpp);
 305   if (bpp != 24) {
 306     GST_ERROR ("Wrong bpp provided %d. We only support 24 bpp", bpp);
 307     return FALSE;
 308   }
 309
 310   src->src_rect = src->screen_rect;
 311   if (src->capture_w && src->capture_h) {
 312     src->src_rect.left += src->capture_x;
 313     src->src_rect.top += src->capture_y;
 314     src->src_rect.right = src->src_rect.left + src->capture_w;
 315     src->src_rect.bottom = src->src_rect.top + src->capture_h;
 316   }
 317
 318   if (framerate = gst_structure_get_value (structure, "framerate")) {
 319     src->rate_numerator = gst_value_get_fraction_numerator (framerate);
 320     src->rate_denominator = gst_value_get_fraction_denominator (framerate);
 321   }
 322
 323   src->info.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
 324   src->info.bmiHeader.biWidth = src->src_rect.right - src->src_rect.left;
 325   src->info.bmiHeader.biHeight = src->src_rect.top - src->src_rect.bottom;
 326   src->info.bmiHeader.biPlanes = 1;
 327   src->info.bmiHeader.biBitCount = 24;
 328   src->info.bmiHeader.biCompression = BI_RGB;
 329   src->info.bmiHeader.biSizeImage = 0;
 330   src->info.bmiHeader.biXPelsPerMeter = 0;
 331   src->info.bmiHeader.biYPelsPerMeter = 0;
 332   src->info.bmiHeader.biClrUsed = 0;
 333   src->info.bmiHeader.biClrImportant = 0;
 334
 335   /* Cleanup first */
 336   if (src->hBitmap != INVALID_HANDLE_VALUE)
 337     DeleteObject (src->hBitmap);
 338
 339   if (src->memDC != INVALID_HANDLE_VALUE)
 340     DeleteDC (src->memDC);
 341
 342   /* Allocate */
 343   capture = GetDesktopWindow ();
 344   device = GetDC (capture);
 345   src->hBitmap = CreateDIBSection (device, &(src->info), DIB_RGB_COLORS,
 346       (void **) &(src->dibMem), 0, 0);
 347   src->memDC = CreateCompatibleDC (device);
 348   SelectObject (src->memDC, src->hBitmap);
 349   ReleaseDC (capture, device);
 350
 351   GST_DEBUG_OBJECT (src, "size %dx%d, %d/%d fps",
 352       src->info.bmiHeader.biWidth,
 353       -src->info.bmiHeader.biHeight,
 354       src->rate_numerator, src->rate_denominator);
 355
 356   return TRUE;
 357 }
 358
 359 static GstCaps *
 360 gst_gdiscreencapsrc_get_caps (GstBaseSrc * bsrc)
 361 {
 362   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (bsrc);
 363   RECT rect_dst;
 364
 365   src->screen_rect = rect_dst = gst_win32_get_monitor_rect (src->monitor);
 366
 367   if (src->capture_w && src->capture_h &&
 368       src->capture_x + src->capture_w < rect_dst.right - rect_dst.left &&
 369       src->capture_y + src->capture_h < rect_dst.bottom - rect_dst.top) {
 370     rect_dst.left = src->capture_x;
 371     rect_dst.top = src->capture_y;
 372     rect_dst.right = src->capture_x + src->capture_w;
 373     rect_dst.bottom = src->capture_y + src->capture_h;
 374   } else {
 375     /* Default values. */
 376     src->capture_x = src->capture_y = 0;
 377     src->capture_w = src->capture_h = 0;
 378   }
 379
 380   GST_DEBUG ("width = %d, height=%d",
 381       rect_dst.right - rect_dst.left, rect_dst.bottom - rect_dst.top);
 382
 383   return gst_caps_new_simple ("video/x-raw-rgb",
 384       "bpp", G_TYPE_INT, 24,
 385       "depth", G_TYPE_INT, 24,
 386       "endianness", G_TYPE_INT, G_BIG_ENDIAN,
 387       "red_mask", G_TYPE_INT, GST_VIDEO_BYTE3_MASK_24_INT,
 388       "green_mask", G_TYPE_INT, GST_VIDEO_BYTE2_MASK_24_INT,
 389       "blue_mask", G_TYPE_INT, GST_VIDEO_BYTE1_MASK_24_INT,
 390       "width", G_TYPE_INT, rect_dst.right - rect_dst.left,
 391       "height", G_TYPE_INT, rect_dst.bottom - rect_dst.top,
 392       "framerate", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1, NULL);
 393 }
 394
 395 static gboolean
 396 gst_gdiscreencapsrc_start (GstBaseSrc * bsrc)
 397 {
 398   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (bsrc);
 399
 400   src->frames = 0;
 401
 402   return TRUE;
 403 }
 404
 405 static gboolean
 406 gst_gdiscreencapsrc_stop (GstBaseSrc * bsrc)
 407 {
 408   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (bsrc);
 409
 410   src->frames = 0;
 411
 412   return TRUE;
 413 }
 414
 415 static void
 416 gst_gdiscreencapsrc_get_times (GstBaseSrc * basesrc, GstBuffer * buffer,
 417     GstClockTime * start, GstClockTime * end)
 418 {
 419   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (basesrc);
 420   GstClockTime timestamp;
 421
 422   timestamp = GST_BUFFER_TIMESTAMP (buffer);
 423
 424   if (GST_CLOCK_TIME_IS_VALID (timestamp)) {
 425     GstClockTime duration = GST_BUFFER_DURATION (buffer);
 426
 427     if (GST_CLOCK_TIME_IS_VALID (duration))
 428       *end = timestamp + duration;
 429     *start = timestamp;
 430   }
 431 }
 432
 433 static GstFlowReturn
 434 gst_gdiscreencapsrc_create (GstPushSrc * push_src, GstBuffer ** buf)
 435 {
 436   GstGDIScreenCapSrc *src = GST_GDISCREENCAPSRC (push_src);
 437   GstBuffer *new_buf;
 438   GstFlowReturn res;
 439   gint new_buf_size;
 440   GstClock *clock;
 441   GstClockTime time;
 442   GstClockTime base_time;
 443
 444   if (G_UNLIKELY (!src->info.bmiHeader.biWidth ||
 445           !src->info.bmiHeader.biHeight)) {
 446     GST_ELEMENT_ERROR (src, CORE, NEGOTIATION, (NULL),
 447         ("format wasn't negotiated before create function"));
 448     return GST_FLOW_NOT_NEGOTIATED;
 449   } else if (G_UNLIKELY (src->rate_numerator == 0 && src->frames == 1)) {
 450     GST_DEBUG_OBJECT (src, "eos: 0 framerate, frame %d", (gint) src->frames);
 451     return GST_FLOW_UNEXPECTED;
 452   }
 453
 454   new_buf_size = GST_ROUND_UP_4 (src->info.bmiHeader.biWidth * 3) *
 455       (-src->info.bmiHeader.biHeight);
 456
 457   GST_LOG_OBJECT (src,
 458       "creating buffer of %lu bytes with %dx%d image for frame %d",
 459       new_buf_size, src->info.bmiHeader.biWidth,
 460       -src->info.bmiHeader.biHeight, (gint) src->frames);
 461
 462   res =
 463       gst_pad_alloc_buffer_and_set_caps (GST_BASE_SRC_PAD (src),
 464       GST_BUFFER_OFFSET_NONE, new_buf_size,
 465       GST_PAD_CAPS (GST_BASE_SRC_PAD (push_src)), &new_buf);
 466   if (res != GST_FLOW_OK) {
 467     GST_DEBUG_OBJECT (src, "could not allocate buffer, reason %s",
 468         gst_flow_get_name (res));
 469     return res;
 470   }
 471
 472   clock = gst_element_get_clock (GST_ELEMENT (src));
 473   if (clock) {
 474     /* Calculate sync time. */
 475     GstClockTime frame_time =
 476         gst_util_uint64_scale_int (src->frames * GST_SECOND,
 477         src->rate_denominator, src->rate_numerator);
 478
 479     time = gst_clock_get_time (clock);
 480     base_time = gst_element_get_base_time (GST_ELEMENT (src));
 481     GST_BUFFER_TIMESTAMP (new_buf) = MAX (time - base_time, frame_time);
 482   } else {
 483     GST_BUFFER_TIMESTAMP (new_buf) = GST_CLOCK_TIME_NONE;
 484   }
 485
 486   /* Do screen capture and put it into buffer... */
 487   gst_gdiscreencapsrc_screen_capture (src, new_buf);
 488
 489   if (src->rate_numerator) {
 490     GST_BUFFER_DURATION (new_buf) =
 491         gst_util_uint64_scale_int (GST_SECOND,
 492         src->rate_denominator, src->rate_numerator);
 493     if (clock) {
 494       GST_BUFFER_DURATION (new_buf) =
 495           MAX (GST_BUFFER_DURATION (new_buf),
 496           gst_clock_get_time (clock) - time);
 497     }
 498   } else {
 499     /* NONE means forever */
 500     GST_BUFFER_DURATION (new_buf) = GST_CLOCK_TIME_NONE;
 501   }
 502
 503   GST_BUFFER_OFFSET (new_buf) = src->frames;
 504   src->frames++;
 505   GST_BUFFER_OFFSET_END (new_buf) = src->frames;
 506
 507   gst_object_unref (clock);
 508
 509   *buf = new_buf;
 510   return GST_FLOW_OK;
 511 }
 512
 513 static gboolean
 514 gst_gdiscreencapsrc_screen_capture (GstGDIScreenCapSrc * src, GstBuffer * buf)
 515 {
 516   HWND capture;
 517   HDC winDC;
 518   gint height, width;
 519
 520   if (G_UNLIKELY (!src->hBitmap || !src->dibMem))
 521     return FALSE;
 522
 523   width = src->info.bmiHeader.biWidth;
 524   height = -src->info.bmiHeader.biHeight;
 525
 526   /* Capture screen */
 527   capture = GetDesktopWindow ();
 528   winDC = GetWindowDC (capture);
 529
 530   BitBlt (src->memDC, 0, 0, width, height,
 531       winDC, src->src_rect.left, src->src_rect.top, SRCCOPY);
 532
 533   ReleaseDC (capture, winDC);
 534
 535   /* Capture mouse cursor */
 536   if (src->show_cursor) {
 537     CURSORINFO ci;
 538
 539     ci.cbSize = sizeof (CURSORINFO);
 540     GetCursorInfo (&ci);
 541     if (ci.flags & CURSOR_SHOWING) {
 542       ICONINFO ii;
 543
 544       GetIconInfo (ci.hCursor, &ii);
 545
 546       DrawIconEx (src->memDC,
 547           ci.ptScreenPos.x - src->src_rect.left - ii.xHotspot,
 548           ci.ptScreenPos.y - src->src_rect.top - ii.yHotspot, ci.hCursor, 0, 0,
 549           0, NULL, DI_DEFAULTSIZE | DI_NORMAL | DI_COMPAT);
 550
 551       DeleteObject (ii.hbmColor);
 552       DeleteObject (ii.hbmMask);
 553     }
 554   }
 555
 556   /* Copy DC bits to GST buffer */
 557   memcpy (GST_BUFFER_DATA (buf), src->dibMem, GST_BUFFER_SIZE (buf));
 558
 559   return TRUE;
 560 }