gst-plugins-good  1.20.3
About: GStreamer (Good Plugins) is a library for constructing of graphs of media-handling components. A set of good-quality plug-ins (under LGPL license).
  Fossies Dox: gst-plugins-good-1.20.3.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

gstximagesrc.c
Go to the documentation of this file.
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 * @title: ximagesrc
24 *
25 * This element captures your X Display and creates raw RGB video. It uses
26 * the XDamage extension if available to only capture areas of the screen that
27 * have changed since the last frame. It uses the XFixes extension if
28 * available to also capture your mouse pointer. By default it will fixate to
29 * 25 frames per second.
30 *
31 * ## Example pipelines
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 *
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
54
55GST_DEBUG_CATEGORY_STATIC (gst_debug_ximage_src);
56#define GST_CAT_DEFAULT gst_debug_ximage_src
57
58static GstStaticPadTemplate t =
59GST_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
65enum
66{
78};
79
80#define gst_ximage_src_parent_class parent_class
81G_DEFINE_TYPE (GstXImageSrc, gst_ximage_src, GST_TYPE_PUSH_SRC);
82
83static GstCaps *gst_ximage_src_fixate (GstBaseSrc * bsrc, GstCaps * caps);
84static void gst_ximage_src_clear_bufpool (GstXImageSrc * ximagesrc);
85
86/* Called when a buffer is returned from the pipeline */
87static gboolean
88gst_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
117static Window
118gst_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
146static gboolean
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 }
224use_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
289static gboolean
290gst_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
301}
302
303static gboolean
304gst_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
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
341 src->xcontext = NULL;
342 g_mutex_unlock (&src->x_lock);
343 }
344
345 return TRUE;
346}
347
348static gboolean
349gst_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
364static gboolean
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
376static gboolean
377gst_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
395static void
396composite_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
475static void
476copy_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 */
488static GstBuffer *
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,
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 if (XCheckTypedEvent (ximagesrc->xcontext->disp,
551 ximagesrc->damage_event_base + XDamageNotify, &ev) &&
552 damage_ev->level == XDamageReportNonEmpty) {
553
554 XDamageSubtract (ximagesrc->xcontext->disp, ximagesrc->damage, None,
555 ximagesrc->damage_region);
556 have_damage = TRUE;
557 }
558 } while (XPending (ximagesrc->xcontext->disp));
559
560 if (have_damage) {
561 XRectangle *rects;
562 int nrects;
563
564 /* Now copy out all of the damaged rectangles. */
565 rects =
566 XFixesFetchRegion (ximagesrc->xcontext->disp,
567 ximagesrc->damage_region, &nrects);
568 if (rects != NULL) {
569 int i;
570
571 if (!have_frame) {
572 GST_LOG_OBJECT (ximagesrc,
573 "Copying from last frame ximage->size: %" G_GSIZE_FORMAT,
574 gst_buffer_get_size (ximage));
575 copy_buffer (ximage, ximagesrc->last_ximage);
576 have_frame = TRUE;
577 }
578 for (i = 0; i < nrects; i++) {
579 GST_LOG_OBJECT (ximagesrc,
580 "Damaged sub-region @ %d,%d size %dx%d reported",
581 rects[i].x, rects[i].y, rects[i].width, rects[i].height);
582
583 /* if we only want a small area, clip this damage region to
584 * area we want */
585 if (ximagesrc->endx > ximagesrc->startx &&
586 ximagesrc->endy > ximagesrc->starty) {
587 /* see if damage area intersects */
588 if (rects[i].x + rects[i].width - 1 < ximagesrc->startx ||
589 rects[i].x > ximagesrc->endx) {
590 /* trivial reject */
591 } else if (rects[i].y + rects[i].height - 1 < ximagesrc->starty ||
592 rects[i].y > ximagesrc->endy) {
593 /* trivial reject */
594 } else {
595 /* find intersect region */
596 int startx, starty, width, height;
597
598 startx = (rects[i].x < ximagesrc->startx) ? ximagesrc->startx :
599 rects[i].x;
600 starty = (rects[i].y < ximagesrc->starty) ? ximagesrc->starty :
601 rects[i].y;
602 width = (rects[i].x + rects[i].width - 1 < ximagesrc->endx) ?
603 rects[i].x + rects[i].width - startx :
604 ximagesrc->endx - startx + 1;
605 height = (rects[i].y + rects[i].height - 1 < ximagesrc->endy) ?
606 rects[i].y + rects[i].height - starty : ximagesrc->endy -
607 starty + 1;
608
609 GST_LOG_OBJECT (ximagesrc,
610 "Retrieving damaged sub-region @ %d,%d size %dx%d as intersect region",
611 startx, starty, width, height);
612 XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
613 startx, starty, width, height, AllPlanes, ZPixmap,
614 meta->ximage, startx - ximagesrc->startx,
615 starty - ximagesrc->starty);
616 }
617 } else {
618
619 GST_LOG_OBJECT (ximagesrc,
620 "Retrieving damaged sub-region @ %d,%d size %dx%d",
621 rects[i].x, rects[i].y, rects[i].width, rects[i].height);
622
623 XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
624 rects[i].x, rects[i].y,
625 rects[i].width, rects[i].height,
626 AllPlanes, ZPixmap, meta->ximage, rects[i].x, rects[i].y);
627 }
628 }
629 XFree (rects);
630 }
631 }
632 if (!have_frame) {
633 GST_LOG_OBJECT (ximagesrc,
634 "Copying from last frame ximage->size: %" G_GSIZE_FORMAT,
635 gst_buffer_get_size (ximage));
636 copy_buffer (ximage, ximagesrc->last_ximage);
637 }
638#ifdef HAVE_XFIXES
639 /* re-get area where last mouse pointer was but only if in our clipping
640 * bounds */
641 if (ximagesrc->cursor_image) {
642 gint x, y, width, height;
643
644 x = ximagesrc->cursor_image->x - ximagesrc->cursor_image->xhot -
645 ximagesrc->x;
646 y = ximagesrc->cursor_image->y - ximagesrc->cursor_image->yhot -
647 ximagesrc->y;
648 width = ximagesrc->cursor_image->width;
649 height = ximagesrc->cursor_image->height;
650
651 /* bounds checking */
652 if (x < 0)
653 x = 0;
654 if (y < 0)
655 y = 0;
656 if (x + width > ximagesrc->xcontext->width)
657 width = ximagesrc->xcontext->width - x;
658 if (y + height > ximagesrc->xcontext->height)
659 height = ximagesrc->xcontext->height - y;
660 g_assert (x >= 0);
661 g_assert (y >= 0);
662 GST_DEBUG_OBJECT (ximagesrc,
663 "Cursor was at (%d,%d) width: %d, height: %d and our range is: (%d,%d) - (%d,%d)",
664 x, y, width, height, ximagesrc->startx, ximagesrc->starty,
665 ximagesrc->endx, ximagesrc->endy);
666 /* only get where cursor last was, if it is in our range */
667 if (ximagesrc->endx > ximagesrc->startx &&
668 ximagesrc->endy > ximagesrc->starty) {
669 /* check bounds */
670 if (x + width < ximagesrc->startx || x > ximagesrc->endx) {
671 /* trivial reject */
672 } else if (y + height < ximagesrc->starty || y > ximagesrc->endy) {
673 /* trivial reject */
674 } else {
675 /* find intersect region */
676 int startx, starty, iwidth, iheight;
677
678 startx = (x < ximagesrc->startx) ? ximagesrc->startx : x;
679 starty = (y < ximagesrc->starty) ? ximagesrc->starty : y;
680 iwidth = (x + width < ximagesrc->endx) ?
681 x + width - startx : ximagesrc->endx - startx;
682 iheight = (y + height < ximagesrc->endy) ?
683 y + height - starty : ximagesrc->endy - starty;
684 GST_DEBUG_OBJECT (ximagesrc, "Removing cursor from %d,%d", x, y);
685 XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
686 startx, starty, iwidth, iheight, AllPlanes, ZPixmap,
687 meta->ximage, startx - ximagesrc->startx,
688 starty - ximagesrc->starty);
689 }
690 } else {
691
692 GST_DEBUG_OBJECT (ximagesrc, "Removing cursor from %d,%d", x, y);
693 XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
694 x, y, width, height, AllPlanes, ZPixmap, meta->ximage, x, y);
695 }
696 }
697#endif
698
699
700 } else {
701#endif
702
703#ifdef HAVE_XSHM
704 if (ximagesrc->xcontext->use_xshm) {
705 GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XShm");
706 XShmGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
707 meta->ximage, ximagesrc->startx, ximagesrc->starty, AllPlanes);
708
709 } else
710#endif /* HAVE_XSHM */
711 {
712 GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XGetImage");
713 if (ximagesrc->remote) {
714 XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
715 ximagesrc->startx, ximagesrc->starty, ximagesrc->width,
716 ximagesrc->height, AllPlanes, ZPixmap, meta->ximage, 0, 0);
717 } else {
718 meta->ximage =
719 XGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
720 ximagesrc->startx, ximagesrc->starty, ximagesrc->width,
721 ximagesrc->height, AllPlanes, ZPixmap);
722 }
723 }
724#ifdef HAVE_XDAMAGE
725 }
726#endif
727
728#ifdef HAVE_XFIXES
729 if (ximagesrc->show_pointer && ximagesrc->have_xfixes
730 && gst_ximage_is_pointer_in_region (ximagesrc)) {
731
732 GST_DEBUG_OBJECT (ximagesrc, "Using XFixes to draw cursor");
733 /* get cursor */
734 if (ximagesrc->cursor_image)
735 XFree (ximagesrc->cursor_image);
736 ximagesrc->cursor_image = XFixesGetCursorImage (ximagesrc->xcontext->disp);
737 if (ximagesrc->cursor_image != NULL) {
738 int cx, cy, i, j, count;
739 int startx, starty, iwidth, iheight;
740 gboolean cursor_in_image = TRUE;
741
742 cx = ximagesrc->cursor_image->x - ximagesrc->cursor_image->xhot -
743 ximagesrc->x;
744 cy = ximagesrc->cursor_image->y - ximagesrc->cursor_image->yhot -
745 ximagesrc->y;
746 count = ximagesrc->cursor_image->width * ximagesrc->cursor_image->height;
747
748 /* only get where cursor last was, if it is in our range */
749 if (ximagesrc->endx > ximagesrc->startx &&
750 ximagesrc->endy > ximagesrc->starty) {
751 /* check bounds */
752 if (cx + ximagesrc->cursor_image->width < (int) ximagesrc->startx ||
753 cx > (int) ximagesrc->endx) {
754 /* trivial reject */
755 cursor_in_image = FALSE;
756 } else if (cy + ximagesrc->cursor_image->height <
757 (int) ximagesrc->starty || cy > (int) ximagesrc->endy) {
758 /* trivial reject */
759 cursor_in_image = FALSE;
760 } else {
761 /* find intersect region */
762
763 startx = (cx < (int) ximagesrc->startx) ? ximagesrc->startx : cx;
764 starty = (cy < (int) ximagesrc->starty) ? ximagesrc->starty : cy;
765 iwidth = (cx + ximagesrc->cursor_image->width < ximagesrc->endx) ?
766 cx + ximagesrc->cursor_image->width - startx :
767 ximagesrc->endx - startx;
768 iheight =
769 (cy + ximagesrc->cursor_image->height <
770 ximagesrc->endy) ? cy + ximagesrc->cursor_image->height -
771 starty : ximagesrc->endy - starty;
772 }
773 } else {
774 startx = cx;
775 starty = cy;
776 iwidth = ximagesrc->cursor_image->width;
777 iheight = ximagesrc->cursor_image->height;
778 }
779
780 if (cursor_in_image) {
781 GST_DEBUG_OBJECT (ximagesrc, "Cursor is in image so trying to draw it");
782 for (i = 0; i < count; i++)
783 ximagesrc->cursor_image->pixels[i] =
784 GUINT_TO_LE (ximagesrc->cursor_image->pixels[i]);
785 /* copy those pixels across */
786 for (j = starty;
787 j < starty + iheight
788 && j < ximagesrc->starty + ximagesrc->height; j++) {
789 for (i = startx;
790 i < startx + iwidth
791 && i < ximagesrc->startx + ximagesrc->width; i++) {
792 guint8 *src, *dest;
793
794 src =
795 (guint8 *) & (ximagesrc->cursor_image->pixels[((j -
796 cy) * ximagesrc->cursor_image->width + (i - cx))]);
797 dest =
798 (guint8 *) & (meta->ximage->data[((j -
799 ximagesrc->starty) * ximagesrc->width + (i -
800 ximagesrc->startx)) *
801 (ximagesrc->xcontext->bpp / 8)]);
802
803 composite_pixel (ximagesrc->xcontext, (guint8 *) dest,
804 (guint8 *) src);
805 }
806 }
807 }
808 }
809 }
810#endif
811#ifdef HAVE_XDAMAGE
812 if (ximagesrc->have_xdamage && ximagesrc->use_damage) {
813 /* need to ref ximage to put in last_ximage */
814 gst_buffer_ref (ximage);
815 if (ximagesrc->last_ximage) {
816 gst_buffer_unref (ximagesrc->last_ximage);
817 }
818 ximagesrc->last_ximage = ximage;
819 GST_LOG_OBJECT (ximagesrc, "reffing current buffer for last_ximage");
820 }
821#endif
822 return ximage;
823}
824
825static GstFlowReturn
826gst_ximage_src_create (GstPushSrc * bs, GstBuffer ** buf)
827{
829 GstBuffer *image;
830 GstClockTime base_time;
831 GstClockTime next_capture_ts;
832 GstClockTime dur;
833 gint64 next_frame_no;
834
835 if (!gst_ximage_src_recalc (s)) {
836 GST_ELEMENT_ERROR (s, RESOURCE, FAILED,
837 (_("Changing resolution at runtime is not yet supported.")), (NULL));
838 return GST_FLOW_ERROR;
839 }
840
841 if (s->fps_n <= 0 || s->fps_d <= 0)
842 return GST_FLOW_NOT_NEGOTIATED; /* FPS must be > 0 */
843
844 /* Now, we might need to wait for the next multiple of the fps
845 * before capturing */
846
847 GST_OBJECT_LOCK (s);
848 if (GST_ELEMENT_CLOCK (s) == NULL) {
849 GST_OBJECT_UNLOCK (s);
850 GST_ELEMENT_ERROR (s, RESOURCE, FAILED,
851 (_("Cannot operate without a clock")), (NULL));
852 return GST_FLOW_ERROR;
853 }
854
855 base_time = GST_ELEMENT_CAST (s)->base_time;
856 next_capture_ts = gst_clock_get_time (GST_ELEMENT_CLOCK (s));
857 next_capture_ts -= base_time;
858
859 /* Figure out which 'frame number' position we're at, based on the cur time
860 * and frame rate */
861 next_frame_no = gst_util_uint64_scale (next_capture_ts,
862 s->fps_n, GST_SECOND * s->fps_d);
863 if (next_frame_no == s->last_frame_no) {
864 GstClockID id;
865 GstClockReturn ret;
866
867 /* Need to wait for the next frame */
868 next_frame_no += 1;
869
870 /* Figure out what the next frame time is */
871 next_capture_ts = gst_util_uint64_scale (next_frame_no,
872 s->fps_d * GST_SECOND, s->fps_n);
873
874 id = gst_clock_new_single_shot_id (GST_ELEMENT_CLOCK (s),
875 next_capture_ts + base_time);
876 s->clock_id = id;
877
878 /* release the object lock while waiting */
879 GST_OBJECT_UNLOCK (s);
880
881 GST_DEBUG_OBJECT (s, "Waiting for next frame time %" G_GUINT64_FORMAT,
882 next_capture_ts);
883 ret = gst_clock_id_wait (id, NULL);
884 GST_OBJECT_LOCK (s);
885
886 gst_clock_id_unref (id);
887 s->clock_id = NULL;
888 if (ret == GST_CLOCK_UNSCHEDULED) {
889 /* Got woken up by the unlock function */
890 GST_OBJECT_UNLOCK (s);
891 return GST_FLOW_FLUSHING;
892 }
893 /* Duration is a complete 1/fps frame duration */
894 dur = gst_util_uint64_scale_int (GST_SECOND, s->fps_d, s->fps_n);
895 } else {
896 GstClockTime next_frame_ts;
897
898 GST_DEBUG_OBJECT (s, "No need to wait for next frame time %"
899 G_GUINT64_FORMAT " next frame = %" G_GINT64_FORMAT " prev = %"
900 G_GINT64_FORMAT, next_capture_ts, next_frame_no, s->last_frame_no);
901 next_frame_ts = gst_util_uint64_scale (next_frame_no + 1,
902 s->fps_d * GST_SECOND, s->fps_n);
903 /* Frame duration is from now until the next expected capture time */
904 dur = next_frame_ts - next_capture_ts;
905 }
906 s->last_frame_no = next_frame_no;
907 GST_OBJECT_UNLOCK (s);
908
909 image = gst_ximage_src_ximage_get (s);
910 if (!image)
911 return GST_FLOW_ERROR;
912
913 *buf = image;
914 GST_BUFFER_DTS (*buf) = GST_CLOCK_TIME_NONE;
915 GST_BUFFER_PTS (*buf) = next_capture_ts;
916 GST_BUFFER_DURATION (*buf) = dur;
917
918 return GST_FLOW_OK;
919}
920
921static void
922gst_ximage_src_set_property (GObject * object, guint prop_id,
923 const GValue * value, GParamSpec * pspec)
924{
925 GstXImageSrc *src = GST_XIMAGE_SRC (object);
926
927 switch (prop_id) {
929
930 g_free (src->display_name);
931 src->display_name = g_value_dup_string (value);
932 break;
934 src->show_pointer = g_value_get_boolean (value);
935 break;
936 case PROP_USE_DAMAGE:
937 src->use_damage = g_value_get_boolean (value);
938 break;
939 case PROP_STARTX:
940 src->startx = g_value_get_uint (value);
941 break;
942 case PROP_STARTY:
943 src->starty = g_value_get_uint (value);
944 break;
945 case PROP_ENDX:
946 src->endx = g_value_get_uint (value);
947 break;
948 case PROP_ENDY:
949 src->endy = g_value_get_uint (value);
950 break;
951 case PROP_REMOTE:
952 src->remote = g_value_get_boolean (value);
953 break;
954 case PROP_XID:
955 if (src->xcontext != NULL) {
956 g_warning ("ximagesrc window ID must be set before opening display");
957 break;
958 }
959 src->xid = g_value_get_uint64 (value);
960 break;
961 case PROP_XNAME:
962 if (src->xcontext != NULL) {
963 g_warning ("ximagesrc window name must be set before opening display");
964 break;
965 }
966 g_free (src->xname);
967 src->xname = g_value_dup_string (value);
968 break;
969 default:
970 break;
971 }
972}
973
974static void
975gst_ximage_src_get_property (GObject * object, guint prop_id,
976 GValue * value, GParamSpec * pspec)
977{
978 GstXImageSrc *src = GST_XIMAGE_SRC (object);
979
980 switch (prop_id) {
982 if (src->xcontext)
983 g_value_set_string (value, DisplayString (src->xcontext->disp));
984 else
985 g_value_set_string (value, src->display_name);
986
987 break;
989 g_value_set_boolean (value, src->show_pointer);
990 break;
991 case PROP_USE_DAMAGE:
992 g_value_set_boolean (value, src->use_damage);
993 break;
994 case PROP_STARTX:
995 g_value_set_uint (value, src->startx);
996 break;
997 case PROP_STARTY:
998 g_value_set_uint (value, src->starty);
999 break;
1000 case PROP_ENDX:
1001 g_value_set_uint (value, src->endx);
1002 break;
1003 case PROP_ENDY:
1004 g_value_set_uint (value, src->endy);
1005 break;
1006 case PROP_REMOTE:
1007 g_value_set_boolean (value, src->remote);
1008 break;
1009 case PROP_XID:
1010 g_value_set_uint64 (value, src->xid);
1011 break;
1012 case PROP_XNAME:
1013 g_value_set_string (value, src->xname);
1014 break;
1015 default:
1016 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1017 break;
1018 }
1019}
1020
1021static void
1023{
1024 g_mutex_lock (&ximagesrc->pool_lock);
1025 while (ximagesrc->buffer_pool != NULL) {
1026 GstBuffer *ximage = ximagesrc->buffer_pool->data;
1027
1028 gst_ximage_buffer_free (ximage);
1029
1030 ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool,
1031 ximagesrc->buffer_pool);
1032 }
1033 g_mutex_unlock (&ximagesrc->pool_lock);
1034}
1035
1036static void
1037gst_ximage_src_dispose (GObject * object)
1038{
1039 /* Drop references in the buffer_pool */
1041
1042 G_OBJECT_CLASS (parent_class)->dispose (object);
1043}
1044
1045static void
1046gst_ximage_src_finalize (GObject * object)
1047{
1048 GstXImageSrc *src = GST_XIMAGE_SRC (object);
1049
1050 if (src->xcontext)
1052
1053 g_free (src->xname);
1054 g_mutex_clear (&src->pool_lock);
1055 g_mutex_clear (&src->x_lock);
1056
1057 G_OBJECT_CLASS (parent_class)->finalize (object);
1058}
1059
1060static GstCaps *
1061gst_ximage_src_get_caps (GstBaseSrc * bs, GstCaps * filter)
1062{
1063 GstXImageSrc *s = GST_XIMAGE_SRC (bs);
1064 GstXContext *xcontext;
1065 gint width, height;
1066 GstVideoFormat format;
1067 guint32 alpha_mask;
1068
1069 if ((!s->xcontext) && (!gst_ximage_src_open_display (s, s->display_name)))
1070 return gst_pad_get_pad_template_caps (GST_BASE_SRC (s)->srcpad);
1071
1072 if (!gst_ximage_src_recalc (s))
1073 return gst_pad_get_pad_template_caps (GST_BASE_SRC (s)->srcpad);
1074
1075 xcontext = s->xcontext;
1076 width = s->xcontext->width;
1077 height = s->xcontext->height;
1078 if (s->xwindow != 0) {
1079 XWindowAttributes attrs;
1080 int status = XGetWindowAttributes (s->xcontext->disp, s->xwindow, &attrs);
1081 if (status) {
1082 width = attrs.width;
1083 height = attrs.height;
1084 }
1085 }
1086
1087 /* property comments say 0 means right/bottom, means we can't capture
1088 the top left pixel alone */
1089 if (s->endx == 0)
1090 s->endx = width - 1;
1091 if (s->endy == 0)
1092 s->endy = height - 1;
1093
1094 if (s->endx >= s->startx && s->endy >= s->starty) {
1095 /* this means user has put in values */
1096 if (s->startx < xcontext->width && s->endx < xcontext->width &&
1097 s->starty < xcontext->height && s->endy < xcontext->height) {
1098 /* values are fine */
1099 s->width = width = s->endx - s->startx + 1;
1100 s->height = height = s->endy - s->starty + 1;
1101 } else {
1102 GST_WARNING
1103 ("User put in co-ordinates overshooting the X resolution, setting to full screen");
1104 s->startx = 0;
1105 s->starty = 0;
1106 s->endx = width - 1;
1107 s->endy = height - 1;
1108 }
1109 } else {
1110 GST_WARNING ("User put in bogus co-ordinates, setting to full screen");
1111 s->startx = 0;
1112 s->starty = 0;
1113 s->endx = width - 1;
1114 s->endy = height - 1;
1115 }
1116 GST_DEBUG ("width = %d, height=%d", width, height);
1117
1118 /* extrapolate alpha mask */
1119 if (xcontext->depth == 32) {
1120 alpha_mask = ~(xcontext->r_mask_output
1121 | xcontext->g_mask_output | xcontext->b_mask_output);
1122 } else {
1123 alpha_mask = 0;
1124 }
1125
1126 format =
1127 gst_video_format_from_masks (xcontext->depth, xcontext->bpp,
1128 xcontext->endianness, xcontext->r_mask_output,
1129 xcontext->g_mask_output, xcontext->b_mask_output, alpha_mask);
1130
1131 return gst_caps_new_simple ("video/x-raw",
1132 "format", G_TYPE_STRING, gst_video_format_to_string (format),
1133 "width", G_TYPE_INT, width,
1134 "height", G_TYPE_INT, height,
1135 "framerate", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1,
1136 "pixel-aspect-ratio", GST_TYPE_FRACTION, xcontext->par_n,
1137 xcontext->par_d, NULL);
1138}
1139
1140static gboolean
1141gst_ximage_src_set_caps (GstBaseSrc * bs, GstCaps * caps)
1142{
1143 GstXImageSrc *s = GST_XIMAGE_SRC (bs);
1144 GstStructure *structure;
1145 const GValue *new_fps;
1146
1147 /* If not yet opened, disallow setcaps until later */
1148 if (!s->xcontext)
1149 return FALSE;
1150
1151 /* The only thing that can change is the framerate downstream wants */
1152 structure = gst_caps_get_structure (caps, 0);
1153 new_fps = gst_structure_get_value (structure, "framerate");
1154 if (!new_fps)
1155 return FALSE;
1156
1157 /* Store this FPS for use when generating buffers */
1158 s->fps_n = gst_value_get_fraction_numerator (new_fps);
1159 s->fps_d = gst_value_get_fraction_denominator (new_fps);
1160
1161 GST_DEBUG_OBJECT (s, "peer wants %d/%d fps", s->fps_n, s->fps_d);
1162
1163 return TRUE;
1164}
1165
1166static GstCaps *
1167gst_ximage_src_fixate (GstBaseSrc * bsrc, GstCaps * caps)
1168{
1169 gint i;
1170 GstStructure *structure;
1171
1172 caps = gst_caps_make_writable (caps);
1173
1174 for (i = 0; i < gst_caps_get_size (caps); ++i) {
1175 structure = gst_caps_get_structure (caps, i);
1176
1177 gst_structure_fixate_field_nearest_fraction (structure, "framerate", 25, 1);
1178 }
1179 caps = GST_BASE_SRC_CLASS (parent_class)->fixate (bsrc, caps);
1180
1181 return caps;
1182}
1183
1184static void
1186{
1187 GObjectClass *gc = G_OBJECT_CLASS (klass);
1188 GstElementClass *ec = GST_ELEMENT_CLASS (klass);
1189 GstBaseSrcClass *bc = GST_BASE_SRC_CLASS (klass);
1190 GstPushSrcClass *push_class = GST_PUSH_SRC_CLASS (klass);
1191
1192 gc->set_property = gst_ximage_src_set_property;
1193 gc->get_property = gst_ximage_src_get_property;
1194 gc->dispose = gst_ximage_src_dispose;
1195 gc->finalize = gst_ximage_src_finalize;
1196
1197 g_object_class_install_property (gc, PROP_DISPLAY_NAME,
1198 g_param_spec_string ("display-name", "Display", "X Display Name",
1199 NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1200 g_object_class_install_property (gc, PROP_SHOW_POINTER,
1201 g_param_spec_boolean ("show-pointer", "Show Mouse Pointer",
1202 "Show mouse pointer (if XFixes extension enabled)", TRUE,
1203 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1204 /**
1205 * GstXImageSrc:use-damage:
1206 *
1207 * Use XDamage (if the XDamage extension is enabled)
1208 */
1209 g_object_class_install_property (gc, PROP_USE_DAMAGE,
1210 g_param_spec_boolean ("use-damage", "Use XDamage",
1211 "Use XDamage (if XDamage extension enabled)", TRUE,
1212 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1213 /**
1214 * GstXImageSrc:startx:
1215 *
1216 * X coordinate of top left corner of area to be recorded
1217 * (0 for top left of screen)
1218 */
1219 g_object_class_install_property (gc, PROP_STARTX,
1220 g_param_spec_uint ("startx", "Start X co-ordinate",
1221 "X coordinate of top left corner of area to be recorded (0 for top left of screen)",
1222 0, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1223 /**
1224 * GstXImageSrc:starty:
1225 *
1226 * Y coordinate of top left corner of area to be recorded
1227 * (0 for top left of screen)
1228 */
1229 g_object_class_install_property (gc, PROP_STARTY,
1230 g_param_spec_uint ("starty", "Start Y co-ordinate",
1231 "Y coordinate of top left corner of area to be recorded (0 for top left of screen)",
1232 0, G_MAXINT, 0, G_PARAM_READWRITE));
1233 /**
1234 * GstXImageSrc:endx:
1235 *
1236 * X coordinate of bottom right corner of area to be recorded
1237 * (0 for bottom right of screen)
1238 */
1239 g_object_class_install_property (gc, PROP_ENDX,
1240 g_param_spec_uint ("endx", "End X",
1241 "X coordinate of bottom right corner of area to be recorded (0 for bottom right of screen)",
1242 0, G_MAXINT, 0, G_PARAM_READWRITE));
1243 /**
1244 * GstXImageSrc:endy:
1245 *
1246 * Y coordinate of bottom right corner of area to be recorded
1247 * (0 for bottom right of screen)
1248 */
1249 g_object_class_install_property (gc, PROP_ENDY,
1250 g_param_spec_uint ("endy", "End Y",
1251 "Y coordinate of bottom right corner of area to be recorded (0 for bottom right of screen)",
1252 0, G_MAXINT, 0, G_PARAM_READWRITE));
1253
1254 /**
1255 * GstXImageSrc:remote:
1256 *
1257 * Whether the X display is remote. The element will try to use alternate calls
1258 * known to work better with remote displays.
1259 */
1260 g_object_class_install_property (gc, PROP_REMOTE,
1261 g_param_spec_boolean ("remote", "Remote display",
1262 "Whether the display is remote", FALSE,
1263 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1264 /**
1265 * GstXImageSrc:xid:
1266 *
1267 * The XID of the window to capture. 0 for the root window (default).
1268 */
1269 g_object_class_install_property (gc, PROP_XID,
1270 g_param_spec_uint64 ("xid", "Window XID",
1271 "Window XID to capture from", 0, G_MAXUINT64, 0,
1272 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1273 /**
1274 * GstXImageSrc:xname:
1275 *
1276 * The name of the window to capture, if any.
1277 */
1278 g_object_class_install_property (gc, PROP_XNAME,
1279 g_param_spec_string ("xname", "Window name",
1280 "Window name to capture from", NULL,
1281 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1282
1283 gst_element_class_set_static_metadata (ec, "Ximage video source",
1284 "Source/Video",
1285 "Creates a screenshot video stream",
1286 "Lutz Mueller <lutz@users.sourceforge.net>, "
1287 "Jan Schmidt <thaytan@mad.scientist.com>, "
1288 "Zaheer Merali <zaheerabbas at merali dot org>");
1289 gst_element_class_add_static_pad_template (ec, &t);
1290
1291 bc->fixate = gst_ximage_src_fixate;
1292 bc->get_caps = gst_ximage_src_get_caps;
1293 bc->set_caps = gst_ximage_src_set_caps;
1294 bc->start = gst_ximage_src_start;
1295 bc->stop = gst_ximage_src_stop;
1296 bc->unlock = gst_ximage_src_unlock;
1297 push_class->create = gst_ximage_src_create;
1298}
1299
1300static void
1302{
1303 gst_base_src_set_format (GST_BASE_SRC (ximagesrc), GST_FORMAT_TIME);
1304 gst_base_src_set_live (GST_BASE_SRC (ximagesrc), TRUE);
1305
1306 g_mutex_init (&ximagesrc->pool_lock);
1307 g_mutex_init (&ximagesrc->x_lock);
1308 ximagesrc->show_pointer = TRUE;
1309 ximagesrc->use_damage = TRUE;
1310 ximagesrc->startx = 0;
1311 ximagesrc->starty = 0;
1312 ximagesrc->endx = 0;
1313 ximagesrc->endy = 0;
1314 ximagesrc->remote = FALSE;
1315}
1316
1317static gboolean
1318plugin_init (GstPlugin * plugin)
1319{
1320 gboolean ret;
1321
1322 GST_DEBUG_CATEGORY_INIT (gst_debug_ximage_src, "ximagesrc", 0,
1323 "ximagesrc element debug");
1324
1325 ret = gst_element_register (plugin, "ximagesrc", GST_RANK_NONE,
1327
1328 return ret;
1329}
1330
1331GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1332 GST_VERSION_MINOR,
1333 ximagesrc,
1334 "X11 video input plugin using standard Xlib calls",
1335 plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
char * format
Definition: RaspiStill.c:190
#define _(String)
#define parent_class
Definition: gstsbcparse.c:83
static gboolean gst_ximage_src_set_caps(GstBaseSrc *bs, GstCaps *caps)
static GstFlowReturn gst_ximage_src_create(GstPushSrc *bs, GstBuffer **buf)
Definition: gstximagesrc.c:826
static Window gst_ximage_src_find_window(GstXImageSrc *src, Window root, const char *name)
Definition: gstximagesrc.c:118
static gboolean plugin_init(GstPlugin *plugin)
static void gst_ximage_src_init(GstXImageSrc *ximagesrc)
static gboolean gst_ximage_src_return_buf(GstXImageSrc *ximagesrc, GstBuffer *ximage)
Definition: gstximagesrc.c:88
static void gst_ximage_src_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
Definition: gstximagesrc.c:922
static void gst_ximage_src_class_init(GstXImageSrcClass *klass)
GST_DEBUG_CATEGORY_STATIC(gst_debug_ximage_src)
static gboolean gst_ximage_src_start(GstBaseSrc *basesrc)
Definition: gstximagesrc.c:290
static gboolean gst_ximage_src_unlock(GstBaseSrc *basesrc)
Definition: gstximagesrc.c:349
static gboolean gst_ximage_src_stop(GstBaseSrc *basesrc)
Definition: gstximagesrc.c:304
G_DEFINE_TYPE(GstXImageSrc, gst_ximage_src, GST_TYPE_PUSH_SRC)
static gboolean gst_ximage_src_recalc(GstXImageSrc *src)
Definition: gstximagesrc.c:365
GST_PLUGIN_DEFINE(GST_VERSION_MAJOR, GST_VERSION_MINOR, ximagesrc, "X11 video input plugin using standard Xlib calls", plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
static void gst_ximage_src_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
Definition: gstximagesrc.c:975
static GstCaps * gst_ximage_src_fixate(GstBaseSrc *bsrc, GstCaps *caps)
static void gst_ximage_src_clear_bufpool(GstXImageSrc *ximagesrc)
@ PROP_XID
Definition: gstximagesrc.c:76
@ PROP_ENDY
Definition: gstximagesrc.c:74
@ PROP_ENDX
Definition: gstximagesrc.c:73
@ PROP_XNAME
Definition: gstximagesrc.c:77
@ PROP_SHOW_POINTER
Definition: gstximagesrc.c:69
@ PROP_STARTX
Definition: gstximagesrc.c:71
@ PROP_USE_DAMAGE
Definition: gstximagesrc.c:70
@ PROP_STARTY
Definition: gstximagesrc.c:72
@ PROP_0
Definition: gstximagesrc.c:67
@ PROP_DISPLAY_NAME
Definition: gstximagesrc.c:68
@ PROP_REMOTE
Definition: gstximagesrc.c:75
static GstStaticPadTemplate t
Definition: gstximagesrc.c:58
static GstBuffer * gst_ximage_src_ximage_get(GstXImageSrc *ximagesrc)
Definition: gstximagesrc.c:489
static GstCaps * gst_ximage_src_get_caps(GstBaseSrc *bs, GstCaps *filter)
static void gst_ximage_src_finalize(GObject *object)
static void gst_ximage_src_dispose(GObject *object)
static gboolean gst_ximage_src_open_display(GstXImageSrc *s, const gchar *name)
Definition: gstximagesrc.c:147
#define GST_XIMAGE_SRC(obj)
Definition: gstximagesrc.h:36
#define GST_IS_XIMAGE_SRC(obj)
Definition: gstximagesrc.h:38
#define GST_TYPE_XIMAGE_SRC
Definition: gstximagesrc.h:35
#define OPEN_READ
XImage * ximage
Definition: ximageutil.h:153
gchar * xname
Definition: gstximagesrc.h:62
gchar * display_name
Definition: gstximagesrc.h:58
GSList * buffer_pool
Definition: gstximagesrc.h:77
gboolean show_pointer
Definition: gstximagesrc.h:82
gboolean have_xdamage
Definition: gstximagesrc.h:81
GstXContext * xcontext
Definition: gstximagesrc.h:51
gint64 last_frame_no
Definition: gstximagesrc.h:70
gboolean use_damage
Definition: gstximagesrc.h:83
gboolean remote
Definition: gstximagesrc.h:92
gboolean have_xfixes
Definition: gstximagesrc.h:80
Window xwindow
Definition: gstximagesrc.h:57
GMutex pool_lock
Definition: gstximagesrc.h:76
GstClockID clock_id
Definition: gstximagesrc.h:69
GstXContext * ximageutil_xcontext_get(GstElement *parent, const gchar *display_name)
Definition: ximageutil.c:181
void gst_ximageutil_ximage_destroy(GstXContext *xcontext, GstBuffer *ximage)
Definition: ximageutil.c:461
GstBuffer * gst_ximageutil_ximage_new(GstXContext *xcontext, GstElement *parent, int width, int height, BufferReturnFunc return_func)
Definition: ximageutil.c:371
void ximageutil_xcontext_clear(GstXContext *xcontext)
Definition: ximageutil.c:271
void gst_ximage_buffer_free(GstBuffer *ximage)
Definition: ximageutil.c:357
typedefG_BEGIN_DECLS struct _GstXContext GstXContext
Definition: ximageutil.h:43
#define GST_META_XIMAGE_GET(buf)
Definition: ximageutil.h:167
gboolean(* BufferReturnFunc)(GstElement *parent, GstBuffer *buf)
Definition: ximageutil.h:135