2 * X11 video grab interface
4 * This file is part of FFmpeg.
7 * Copyright (C) 2006 Clemens Fruhwirth <clemens@endorphin.org>
8 * Edouard Gomez <ed.gomez@free.fr>
10 * This file contains code from grab.c:
11 * Copyright (c) 2000-2001 Fabrice Bellard
13 * This file contains code from the xvidcap project:
14 * Copyright (C) 1997-1998 Rasca, Berlin
15 * 2003-2004 Karl H. Beckers, Frankfurt
17 * FFmpeg is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
22 * FFmpeg is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with FFmpeg; if not, write to the Free Software
29 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34 * X11 frame device demuxer
35 * @author Clemens Fruhwirth <clemens@endorphin.org>
36 * @author Edouard Gomez <ed.gomez@free.fr>
44 #include <X11/cursorfont.h>
47 #include <X11/Xlibint.h>
48 #include <X11/Xproto.h>
49 #include <X11/Xutil.h>
51 #include <X11/extensions/shape.h>
52 #include <X11/extensions/Xfixes.h>
53 #include <X11/extensions/XShm.h>
57 #include "libavutil/log.h"
58 #include "libavutil/opt.h"
59 #include "libavutil/parseutils.h"
60 #include "libavutil/time.h"
62 #include "libavformat/internal.h"
64 /** X11 device demuxer context */
65 typedef struct X11GrabContext
{
66 const AVClass
*class; /**< Class for private options. */
67 int frame_size
; /**< Size in bytes of a grabbed frame */
68 AVRational time_base
; /**< Time base */
69 int64_t time_frame
; /**< Current time */
71 int width
; /**< Width of the grab frame */
72 int height
; /**< Height of the grab frame */
73 int x_off
; /**< Horizontal top-left corner coordinate */
74 int y_off
; /**< Vertical top-left corner coordinate */
76 Display
*dpy
; /**< X11 display from which x11grab grabs frames */
77 XImage
*image
; /**< X11 image holding the grab */
78 int use_shm
; /**< !0 when using XShm extension */
79 XShmSegmentInfo shminfo
; /**< When using XShm, keeps track of XShm infos */
80 int draw_mouse
; /**< Set by a private option. */
81 int follow_mouse
; /**< Set by a private option. */
82 int show_region
; /**< set by a private option. */
83 AVRational framerate
; /**< Set by a private option. */
85 uint32_t palette
[256];
88 Window region_win
; /**< This is used by show_region option. */
91 #define REGION_WIN_BORDER 3
94 * Draw grabbing region window
96 * @param s x11grab context
98 static void x11grab_draw_region_win(X11GrabContext
*s
)
100 Display
*dpy
= s
->dpy
;
101 Window win
= s
->region_win
;
102 int screen
= DefaultScreen(dpy
);
103 GC gc
= XCreateGC(dpy
, win
, 0, 0);
105 XSetForeground(dpy
, gc
, WhitePixel(dpy
, screen
));
106 XSetBackground(dpy
, gc
, BlackPixel(dpy
, screen
));
107 XSetLineAttributes(dpy
, gc
, REGION_WIN_BORDER
, LineDoubleDash
, 0, 0);
108 XDrawRectangle(dpy
, win
, gc
, 1, 1,
109 (s
->width
+ REGION_WIN_BORDER
* 2) - 1 * 2 - 1,
110 (s
->height
+ REGION_WIN_BORDER
* 2) - 1 * 2 - 1);
115 * Initialize grabbing region window
117 * @param s x11grab context
119 static void x11grab_region_win_init(X11GrabContext
*s
)
121 Display
*dpy
= s
->dpy
;
123 XSetWindowAttributes attribs
= { .override_redirect
= True
};
124 int screen
= DefaultScreen(dpy
);
126 s
->region_win
= XCreateWindow(dpy
, RootWindow(dpy
, screen
),
127 s
->x_off
- REGION_WIN_BORDER
,
128 s
->y_off
- REGION_WIN_BORDER
,
129 s
->width
+ REGION_WIN_BORDER
* 2,
130 s
->height
+ REGION_WIN_BORDER
* 2,
132 InputOutput
, CopyFromParent
,
133 CWOverrideRedirect
, &attribs
);
136 rect
.width
= s
->width
;
137 rect
.height
= s
->height
;
138 XShapeCombineRectangles(dpy
, s
->region_win
,
139 ShapeBounding
, REGION_WIN_BORDER
, REGION_WIN_BORDER
,
140 &rect
, 1, ShapeSubtract
, 0);
141 XMapWindow(dpy
, s
->region_win
);
142 XSelectInput(dpy
, s
->region_win
, ExposureMask
| StructureNotifyMask
);
143 x11grab_draw_region_win(s
);
146 static int setup_shm(AVFormatContext
*s
, Display
*dpy
, XImage
**image
)
148 X11GrabContext
*g
= s
->priv_data
;
149 int scr
= XDefaultScreen(dpy
);
150 XImage
*img
= XShmCreateImage(dpy
, DefaultVisual(dpy
, scr
),
151 DefaultDepth(dpy
, scr
), ZPixmap
, NULL
,
152 &g
->shminfo
, g
->width
, g
->height
);
154 g
->shminfo
.shmid
= shmget(IPC_PRIVATE
, img
->bytes_per_line
* img
->height
,
157 if (g
->shminfo
.shmid
== -1) {
158 av_log(s
, AV_LOG_ERROR
, "Cannot get shared memory!\n");
159 return AVERROR(ENOMEM
);
162 g
->shminfo
.shmaddr
= img
->data
= shmat(g
->shminfo
.shmid
, 0, 0);
163 g
->shminfo
.readOnly
= False
;
165 if (!XShmAttach(dpy
, &g
->shminfo
)) {
166 av_log(s
, AV_LOG_ERROR
, "Failed to attach shared memory!\n");
167 /* needs some better error subroutine :) */
175 static int pixfmt_from_image(AVFormatContext
*s
, XImage
*image
, int *pix_fmt
)
177 av_log(s
, AV_LOG_DEBUG
,
178 "Image r 0x%.6lx g 0x%.6lx b 0x%.6lx and depth %i\n",
182 image
->bits_per_pixel
);
184 *pix_fmt
= AV_PIX_FMT_NONE
;
186 switch (image
->bits_per_pixel
) {
188 *pix_fmt
= AV_PIX_FMT_PAL8
;
191 if (image
->red_mask
== 0xf800 &&
192 image
->green_mask
== 0x07e0 &&
193 image
->blue_mask
== 0x001f) {
194 *pix_fmt
= AV_PIX_FMT_RGB565
;
195 } else if (image
->red_mask
== 0x7c00 &&
196 image
->green_mask
== 0x03e0 &&
197 image
->blue_mask
== 0x001f) {
198 *pix_fmt
= AV_PIX_FMT_RGB555
;
202 if (image
->red_mask
== 0xff0000 &&
203 image
->green_mask
== 0x00ff00 &&
204 image
->blue_mask
== 0x0000ff) {
205 *pix_fmt
= AV_PIX_FMT_BGR24
;
206 } else if (image
->red_mask
== 0x0000ff &&
207 image
->green_mask
== 0x00ff00 &&
208 image
->blue_mask
== 0xff0000) {
209 *pix_fmt
= AV_PIX_FMT_RGB24
;
213 if (image
->red_mask
== 0xff0000 &&
214 image
->green_mask
== 0x00ff00 &&
215 image
->blue_mask
== 0x0000ff ) {
216 *pix_fmt
= AV_PIX_FMT_0RGB32
;
220 if (*pix_fmt
== AV_PIX_FMT_NONE
) {
221 av_log(s
, AV_LOG_ERROR
,
222 "XImages with RGB mask 0x%.6lx 0x%.6lx 0x%.6lx and depth %i "
223 "are currently not supported.\n",
227 image
->bits_per_pixel
);
229 return AVERROR_PATCHWELCOME
;
236 * Initialize the x11 grab device demuxer (public device demuxer API).
238 * @param s1 Context from avformat core
240 * <li>AVERROR(ENOMEM) no memory left</li>
241 * <li>AVERROR(EIO) other failure case</li>
245 static int x11grab_read_header(AVFormatContext
*s1
)
247 X11GrabContext
*x11grab
= s1
->priv_data
;
251 int x_off
= 0, y_off
= 0, ret
= 0, screen
, use_shm
= 0;
252 char *dpyname
, *offset
;
257 dpyname
= av_strdup(s1
->filename
);
261 offset
= strchr(dpyname
, '+');
263 sscanf(offset
, "%d,%d", &x_off
, &y_off
);
264 if (strstr(offset
, "nomouse")) {
265 av_log(s1
, AV_LOG_WARNING
,
266 "'nomouse' specification in argument is deprecated: "
267 "use 'draw_mouse' option with value 0 instead\n");
268 x11grab
->draw_mouse
= 0;
273 av_log(s1
, AV_LOG_INFO
,
274 "device: %s -> display: %s x: %d y: %d width: %d height: %d\n",
275 s1
->filename
, dpyname
, x_off
, y_off
, x11grab
->width
, x11grab
->height
);
277 dpy
= XOpenDisplay(dpyname
);
280 av_log(s1
, AV_LOG_ERROR
, "Could not open X display.\n");
285 st
= avformat_new_stream(s1
, NULL
);
287 ret
= AVERROR(ENOMEM
);
290 avpriv_set_pts_info(st
, 64, 1, 1000000); /* 64 bits pts in us */
292 screen
= DefaultScreen(dpy
);
294 if (x11grab
->follow_mouse
) {
295 int screen_w
, screen_h
;
298 screen_w
= DisplayWidth(dpy
, screen
);
299 screen_h
= DisplayHeight(dpy
, screen
);
300 XQueryPointer(dpy
, RootWindow(dpy
, screen
), &w
, &w
, &x_off
, &y_off
,
302 x_off
-= x11grab
->width
/ 2;
303 y_off
-= x11grab
->height
/ 2;
304 x_off
= FFMIN(FFMAX(x_off
, 0), screen_w
- x11grab
->width
);
305 y_off
= FFMIN(FFMAX(y_off
, 0), screen_h
- x11grab
->height
);
306 av_log(s1
, AV_LOG_INFO
,
307 "followmouse is enabled, resetting grabbing region to x: %d y: %d\n",
311 if (x11grab
->use_shm
) {
312 use_shm
= XShmQueryExtension(dpy
);
313 av_log(s1
, AV_LOG_INFO
,
314 "shared memory extension %sfound\n", use_shm
? "" : "not ");
317 if (use_shm
&& setup_shm(s1
, dpy
, &image
) < 0) {
318 av_log(s1
, AV_LOG_WARNING
, "Falling back to XGetImage\n");
323 image
= XGetImage(dpy
, RootWindow(dpy
, screen
),
325 x11grab
->width
, x11grab
->height
,
329 x11grab
->frame_size
= x11grab
->width
* x11grab
->height
* image
->bits_per_pixel
/ 8;
331 x11grab
->time_base
= av_inv_q(x11grab
->framerate
);
332 x11grab
->time_frame
= av_gettime() / av_q2d(x11grab
->time_base
);
333 x11grab
->x_off
= x_off
;
334 x11grab
->y_off
= y_off
;
335 x11grab
->image
= image
;
336 x11grab
->use_shm
= use_shm
;
338 ret
= pixfmt_from_image(s1
, image
, &st
->codec
->pix_fmt
);
342 if (st
->codec
->pix_fmt
== AV_PIX_FMT_PAL8
) {
343 color_map
= DefaultColormap(dpy
, screen
);
344 for (i
= 0; i
< 256; ++i
)
346 XQueryColors(dpy
, color_map
, color
, 256);
347 for (i
= 0; i
< 256; ++i
)
348 x11grab
->palette
[i
] = (color
[i
].red
& 0xFF00) << 8 |
349 (color
[i
].green
& 0xFF00) |
350 (color
[i
].blue
& 0xFF00) >> 8;
351 x11grab
->palette_changed
= 1;
355 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
356 st
->codec
->codec_id
= AV_CODEC_ID_RAWVIDEO
;
357 st
->codec
->width
= x11grab
->width
;
358 st
->codec
->height
= x11grab
->height
;
359 st
->codec
->time_base
= x11grab
->time_base
;
360 st
->codec
->bit_rate
= x11grab
->frame_size
* 1 / av_q2d(x11grab
->time_base
) * 8;
368 * Paint a mouse pointer in an X11 image.
370 * @param image image to paint the mouse pointer to
371 * @param s context used to retrieve original grabbing rectangle
374 static void paint_mouse_pointer(XImage
*image
, AVFormatContext
*s1
)
376 X11GrabContext
*s
= s1
->priv_data
;
377 int x_off
= s
->x_off
;
378 int y_off
= s
->y_off
;
379 int width
= s
->width
;
380 int height
= s
->height
;
381 Display
*dpy
= s
->dpy
;
382 XFixesCursorImage
*xcim
;
385 int to_line
, to_column
;
386 int pixstride
= image
->bits_per_pixel
>> 3;
387 /* Warning: in its insanity, xlib provides unsigned image data through a
388 * char* pointer, so we have to make it uint8_t to make things not break.
389 * Anyone who performs further investigation of the xlib API likely risks
390 * permanent brain damage. */
391 uint8_t *pix
= image
->data
;
393 XSetWindowAttributes attr
;
394 Bool pointer_on_screen
;
398 root
= DefaultRootWindow(dpy
);
399 pointer_on_screen
= XQueryPointer(dpy
, root
, &w
, &w
, &_
, &_
, &_
, &_
, &_
);
400 if (!pointer_on_screen
)
403 /* Code doesn't currently support 16-bit or PAL8 */
404 if (image
->bits_per_pixel
!= 24 && image
->bits_per_pixel
!= 32)
408 s
->c
= XCreateFontCursor(dpy
, XC_left_ptr
);
410 XChangeWindowAttributes(dpy
, root
, CWCursor
, &attr
);
412 xcim
= XFixesGetCursorImage(dpy
);
414 av_log(s1
, AV_LOG_WARNING
,
415 "XFixes extension not available, impossible to draw cursor\n");
420 x
= xcim
->x
- xcim
->xhot
;
421 y
= xcim
->y
- xcim
->yhot
;
423 to_line
= FFMIN((y
+ xcim
->height
), (height
+ y_off
));
424 to_column
= FFMIN((x
+ xcim
->width
), (width
+ x_off
));
426 for (line
= FFMAX(y
, y_off
); line
< to_line
; line
++) {
427 for (column
= FFMAX(x
, x_off
); column
< to_column
; column
++) {
428 int xcim_addr
= (line
- y
) * xcim
->width
+ column
- x
;
429 int image_addr
= ((line
- y_off
) * width
+ column
- x_off
) * pixstride
;
430 int r
= (uint8_t)(xcim
->pixels
[xcim_addr
] >> 0);
431 int g
= (uint8_t)(xcim
->pixels
[xcim_addr
] >> 8);
432 int b
= (uint8_t)(xcim
->pixels
[xcim_addr
] >> 16);
433 int a
= (uint8_t)(xcim
->pixels
[xcim_addr
] >> 24);
436 pix
[image_addr
+ 0] = r
;
437 pix
[image_addr
+ 1] = g
;
438 pix
[image_addr
+ 2] = b
;
440 /* pixel values from XFixesGetCursorImage come premultiplied by alpha */
441 pix
[image_addr
+ 0] = r
+ (pix
[image_addr
+ 0] * (255 - a
) + 255 / 2) / 255;
442 pix
[image_addr
+ 1] = g
+ (pix
[image_addr
+ 1] * (255 - a
) + 255 / 2) / 255;
443 pix
[image_addr
+ 2] = b
+ (pix
[image_addr
+ 2] * (255 - a
) + 255 / 2) / 255;
453 * Read new data in the image structure.
455 * @param dpy X11 display to grab from
457 * @param image Image where the grab will be put
458 * @param x Top-Left grabbing rectangle horizontal coordinate
459 * @param y Top-Left grabbing rectangle vertical coordinate
460 * @return 0 if error, !0 if successful
462 static int xget_zpixmap(Display
*dpy
, Drawable d
, XImage
*image
, int x
, int y
)
472 GetReq(GetImage
, req
);
474 /* First set up the standard stuff in the request */
478 req
->width
= image
->width
;
479 req
->height
= image
->height
;
480 req
->planeMask
= (unsigned int)AllPlanes
;
481 req
->format
= ZPixmap
;
483 if (!_XReply(dpy
, (xReply
*)&rep
, 0, xFalse
) || !rep
.length
) {
489 nbytes
= (long)rep
.length
<< 2;
490 _XReadPad(dpy
, image
->data
, nbytes
);
498 * Grab a frame from x11 (public device demuxer API).
500 * @param s1 Context from avformat core
501 * @param pkt Packet holding the brabbed frame
502 * @return frame size in bytes
504 static int x11grab_read_packet(AVFormatContext
*s1
, AVPacket
*pkt
)
506 X11GrabContext
*s
= s1
->priv_data
;
507 Display
*dpy
= s
->dpy
;
508 XImage
*image
= s
->image
;
509 int x_off
= s
->x_off
;
510 int y_off
= s
->y_off
;
511 int follow_mouse
= s
->follow_mouse
;
514 int64_t curtime
, delay
;
517 /* Calculate the time of the next frame */
518 s
->time_frame
+= INT64_C(1000000);
520 /* wait based on the frame rate */
522 curtime
= av_gettime();
523 delay
= s
->time_frame
* av_q2d(s
->time_base
) - curtime
;
525 if (delay
< INT64_C(-1000000) * av_q2d(s
->time_base
))
526 s
->time_frame
+= INT64_C(1000000);
529 ts
.tv_sec
= delay
/ 1000000;
530 ts
.tv_nsec
= (delay
% 1000000) * 1000;
531 nanosleep(&ts
, NULL
);
535 pkt
->data
= image
->data
;
536 pkt
->size
= s
->frame_size
;
538 if (s
->palette_changed
) {
539 uint8_t *pal
= av_packet_new_side_data(pkt
, AV_PKT_DATA_PALETTE
,
542 av_log(s
, AV_LOG_ERROR
, "Cannot append palette to packet\n");
544 memcpy(pal
, s
->palette
, AVPALETTE_SIZE
);
545 s
->palette_changed
= 0;
549 screen
= DefaultScreen(dpy
);
550 root
= RootWindow(dpy
, screen
);
552 int screen_w
, screen_h
;
553 int pointer_x
, pointer_y
, _
;
556 screen_w
= DisplayWidth(dpy
, screen
);
557 screen_h
= DisplayHeight(dpy
, screen
);
558 XQueryPointer(dpy
, root
, &w
, &w
, &pointer_x
, &pointer_y
, &_
, &_
, &_
);
559 if (follow_mouse
== -1) {
560 // follow the mouse, put it at center of grabbing region
561 x_off
+= pointer_x
- s
->width
/ 2 - x_off
;
562 y_off
+= pointer_y
- s
->height
/ 2 - y_off
;
564 // follow the mouse, but only move the grabbing region when mouse
565 // reaches within certain pixels to the edge.
566 if (pointer_x
> x_off
+ s
->width
- follow_mouse
)
567 x_off
+= pointer_x
- (x_off
+ s
->width
- follow_mouse
);
568 else if (pointer_x
< x_off
+ follow_mouse
)
569 x_off
-= (x_off
+ follow_mouse
) - pointer_x
;
570 if (pointer_y
> y_off
+ s
->height
- follow_mouse
)
571 y_off
+= pointer_y
- (y_off
+ s
->height
- follow_mouse
);
572 else if (pointer_y
< y_off
+ follow_mouse
)
573 y_off
-= (y_off
+ follow_mouse
) - pointer_y
;
575 // adjust grabbing region position if it goes out of screen.
576 s
->x_off
= x_off
= FFMIN(FFMAX(x_off
, 0), screen_w
- s
->width
);
577 s
->y_off
= y_off
= FFMIN(FFMAX(y_off
, 0), screen_h
- s
->height
);
579 if (s
->show_region
&& s
->region_win
)
580 XMoveWindow(dpy
, s
->region_win
,
581 s
->x_off
- REGION_WIN_BORDER
,
582 s
->y_off
- REGION_WIN_BORDER
);
585 if (s
->show_region
) {
587 XEvent evt
= { .type
= NoEventMask
};
588 // Clean up the events, and do the initial draw or redraw.
589 while (XCheckMaskEvent(dpy
, ExposureMask
| StructureNotifyMask
,
593 x11grab_draw_region_win(s
);
595 x11grab_region_win_init(s
);
600 if (!XShmGetImage(dpy
, root
, image
, x_off
, y_off
, AllPlanes
))
601 av_log(s1
, AV_LOG_INFO
, "XShmGetImage() failed\n");
603 if (!xget_zpixmap(dpy
, root
, image
, x_off
, y_off
))
604 av_log(s1
, AV_LOG_INFO
, "XGetZPixmap() failed\n");
608 paint_mouse_pointer(image
, s1
);
610 return s
->frame_size
;
614 * Close x11 frame grabber (public device demuxer API).
616 * @param s1 Context from avformat core
617 * @return 0 success, !0 failure
619 static int x11grab_read_close(AVFormatContext
*s1
)
621 X11GrabContext
*x11grab
= s1
->priv_data
;
623 /* Detach cleanly from shared mem */
624 if (x11grab
->use_shm
) {
625 XShmDetach(x11grab
->dpy
, &x11grab
->shminfo
);
626 shmdt(x11grab
->shminfo
.shmaddr
);
627 shmctl(x11grab
->shminfo
.shmid
, IPC_RMID
, NULL
);
630 /* Destroy X11 image */
631 if (x11grab
->image
) {
632 XDestroyImage(x11grab
->image
);
633 x11grab
->image
= NULL
;
636 if (x11grab
->region_win
)
637 XDestroyWindow(x11grab
->dpy
, x11grab
->region_win
);
639 /* Free X11 display */
640 XCloseDisplay(x11grab
->dpy
);
644 #define OFFSET(x) offsetof(X11GrabContext, x)
645 #define DEC AV_OPT_FLAG_DECODING_PARAM
646 static const AVOption options
[] = {
647 { "draw_mouse", "draw the mouse pointer", OFFSET(draw_mouse
), AV_OPT_TYPE_INT
, {.i64
= 1}, 0, 1, DEC
},
649 { "follow_mouse", "move the grabbing region when the mouse pointer reaches within specified amount of pixels to the edge of region",
650 OFFSET(follow_mouse
), AV_OPT_TYPE_INT
, {.i64
= 0}, -1, INT_MAX
, DEC
, "follow_mouse" },
651 { "centered", "keep the mouse pointer at the center of grabbing region when following",
652 0, AV_OPT_TYPE_CONST
, {.i64
= -1}, INT_MIN
, INT_MAX
, DEC
, "follow_mouse" },
654 { "framerate", "set video frame rate", OFFSET(framerate
), AV_OPT_TYPE_VIDEO_RATE
, {.str
= "ntsc"}, 0, 0, DEC
},
655 { "show_region", "show the grabbing region", OFFSET(show_region
), AV_OPT_TYPE_INT
, {.i64
= 0}, 0, 1, DEC
},
656 { "video_size", "set video frame size", OFFSET(width
), AV_OPT_TYPE_IMAGE_SIZE
, {.str
= "vga"}, 0, 0, DEC
},
657 { "use_shm", "use MIT-SHM extension", OFFSET(use_shm
), AV_OPT_TYPE_INT
, {.i64
= 1}, 0, 1, DEC
},
661 static const AVClass x11_class
= {
662 .class_name
= "X11grab indev",
663 .item_name
= av_default_item_name
,
665 .version
= LIBAVUTIL_VERSION_INT
,
666 .category
= AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
,
669 /** x11 grabber device demuxer declaration */
670 AVInputFormat ff_x11grab_demuxer
= {
672 .long_name
= NULL_IF_CONFIG_SMALL("X11grab"),
673 .priv_data_size
= sizeof(X11GrabContext
),
674 .read_header
= x11grab_read_header
,
675 .read_packet
= x11grab_read_packet
,
676 .read_close
= x11grab_read_close
,
677 .flags
= AVFMT_NOFILE
,
678 .priv_class
= &x11_class
,