4b237f6c263f1e864ebddfa8e616fd887e572164
[ffmpeg.git] / libavformat / x11grab.c
1 /*
2  * X11 video grab interface
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg integration:
7  * Copyright (C) 2006 Clemens Fruhwirth <clemens@endorphin.org>
8  *                    Edouard Gomez <ed.gomez@free.fr>
9  *
10  * This file contains code from grab.c:
11  * Copyright (c) 2000-2001 Fabrice Bellard
12  *
13  * This file contains code from the xvidcap project:
14  * Copyright (C) 1997-1998 Rasca, Berlin
15  *               2003-2004 Karl H. Beckers, Frankfurt
16  *
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.
21  *
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.
26  *
27  * You should have received a copy of the GNU General Public License along
28  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
29  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
30  */
31
32 /**
33  * @file x11grab.c
34  * X11 frame device demuxer by Clemens Fruhwirth <clemens@endorphin.org>
35  * and Edouard Gomez <ed.gomez@free.fr>.
36  */
37
38 #include "avformat.h"
39 #include <unistd.h>
40 #include <fcntl.h>
41 #include <sys/ioctl.h>
42 #include <sys/mman.h>
43 #include <sys/time.h>
44 #define _LINUX_TIME_H 1
45 #include <time.h>
46 #include <X11/X.h>
47 #include <X11/Xlib.h>
48 #include <X11/Xlibint.h>
49 #include <X11/Xproto.h>
50 #include <X11/Xutil.h>
51 #include <sys/ipc.h>
52 #include <sys/shm.h>
53 #include <X11/extensions/XShm.h>
54
55 /**
56  * X11 Device Demuxer context
57  */
58 typedef struct x11_grab_s
59 {
60     int frame_size;          /**< Size in bytes of a grabbed frame */
61     AVRational time_base;    /**< Time base */
62     int64_t time_frame;      /**< Current time */
63
64     int height;              /**< Height of the grab frame */
65     int width;               /**< Width of the grab frame */
66     int x_off;               /**< Horizontal top-left corner coordinate */
67     int y_off;               /**< Vertical top-left corner coordinate */
68
69     Display *dpy;            /**< X11 display from which x11grab grabs frames */
70     XImage *image;           /**< X11 image holding the grab */
71     int use_shm;             /**< !0 when using XShm extension */
72     XShmSegmentInfo shminfo; /**< When using XShm, keeps track of XShm infos */
73 } x11_grab_t;
74
75 /**
76  * Initializes the x11 grab device demuxer (public device demuxer API).
77  *
78  * @param s1 Context from avformat core
79  * @param ap Parameters from avformat core
80  * @return <ul>
81  *          <li>ENOMEM no memory left</li>
82  *          <li>AVERROR_IO other failure case</li>
83  *          <li>0 success</li>
84  *         </ul>
85  */
86 static int
87 x11grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
88 {
89     x11_grab_t *x11grab = s1->priv_data;
90     Display *dpy;
91     AVStream *st = NULL;
92     int input_pixfmt;
93     XImage *image;
94     int x_off = 0;
95     int y_off = 0;
96     int use_shm;
97
98     dpy = XOpenDisplay(NULL);
99     if(!dpy) {
100         av_free(st);
101         return AVERROR_IO;
102     }
103
104     if (!ap->device) {
105         av_log(s1, AV_LOG_ERROR, "AVParameters don't specify any device. Use -vd.\n");
106         return AVERROR_IO;
107     }
108
109     sscanf(ap->device, "x11:%d,%d", &x_off, &y_off);
110     av_log(s1, AV_LOG_INFO, "device: %s -> x: %d y: %d width: %d height: %d\n", ap->device, x_off, y_off, ap->width, ap->height);
111
112     if (!ap || ap->width <= 0 || ap->height <= 0 || ap->time_base.den <= 0) {
113         av_log(s1, AV_LOG_ERROR, "AVParameters don't have any video size. Use -s.\n");
114         return AVERROR_IO;
115     }
116
117     st = av_new_stream(s1, 0);
118     if (!st) {
119         return -ENOMEM;
120     }
121     av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
122
123     use_shm = XShmQueryExtension(dpy);
124     av_log(s1, AV_LOG_INFO, "shared memory extension %s found\n", use_shm ? "" : "not");
125
126     if(use_shm) {
127         int scr = XDefaultScreen(dpy);
128         image = XShmCreateImage(dpy,
129                                 DefaultVisual(dpy, scr),
130                                 DefaultDepth(dpy, scr),
131                                 ZPixmap,
132                                 NULL,
133                                 &x11grab->shminfo,
134                                 ap->width, ap->height);
135         x11grab->shminfo.shmid = shmget(IPC_PRIVATE,
136                                         image->bytes_per_line * image->height,
137                                         IPC_CREAT|0777);
138         if (x11grab->shminfo.shmid == -1) {
139             av_log(s1, AV_LOG_ERROR, "Fatal: Can't get shared memory!\n");
140             return -ENOMEM;
141         }
142         x11grab->shminfo.shmaddr = image->data = shmat(x11grab->shminfo.shmid, 0, 0);
143         x11grab->shminfo.readOnly = False;
144
145         if (!XShmAttach(dpy, &x11grab->shminfo)) {
146             av_log(s1, AV_LOG_ERROR, "Fatal: Failed to attach shared memory!\n");
147             /* needs some better error subroutine :) */
148             return AVERROR_IO;
149         }
150     } else {
151         image = XGetImage(dpy, RootWindow(dpy, DefaultScreen(dpy)),
152                           x_off,y_off,
153                           ap->width,ap->height,
154                           AllPlanes, ZPixmap);
155     }
156
157     switch (image->bits_per_pixel) {
158     case 8:
159         av_log (s1, AV_LOG_DEBUG, "8 bit pallete\n");
160         input_pixfmt = PIX_FMT_PAL8;
161         break;
162     case 16:
163         if (       image->red_mask   == 0xf800 &&
164                    image->green_mask == 0x07e0 &&
165                    image->blue_mask  == 0x001f ) {
166             av_log (s1, AV_LOG_DEBUG, "16 bit RGB565\n");
167             input_pixfmt = PIX_FMT_RGB565;
168         } else if (image->red_mask   == 0x7c00 &&
169                    image->green_mask == 0x03e0 &&
170                    image->blue_mask  == 0x001f ) {
171             av_log(s1, AV_LOG_DEBUG, "16 bit RGB555\n");
172             input_pixfmt = PIX_FMT_RGB555;
173         } else {
174             av_log(s1, AV_LOG_ERROR, "RGB ordering at image depth %i not supported ... aborting\n", image->bits_per_pixel);
175             av_log(s1, AV_LOG_ERROR, "color masks: r 0x%.6lx g 0x%.6lx b 0x%.6lx\n", image->red_mask, image->green_mask, image->blue_mask);
176             return AVERROR_IO;
177         }
178         break;
179     case 24:
180         if (        image->red_mask   == 0xff0000 &&
181                     image->green_mask == 0x00ff00 &&
182                     image->blue_mask  == 0x0000ff ) {
183             input_pixfmt = PIX_FMT_BGR24;
184         } else if ( image->red_mask   == 0x0000ff &&
185                     image->green_mask == 0x00ff00 &&
186                     image->blue_mask  == 0xff0000 ) {
187             input_pixfmt = PIX_FMT_RGB24;
188         } else {
189             av_log(s1, AV_LOG_ERROR,"rgb ordering at image depth %i not supported ... aborting\n", image->bits_per_pixel);
190             av_log(s1, AV_LOG_ERROR, "color masks: r 0x%.6lx g 0x%.6lx b 0x%.6lx\n", image->red_mask, image->green_mask, image->blue_mask);
191             return AVERROR_IO;
192         }
193         break;
194     case 32:
195 #if 0
196         GetColorInfo (image, &c_info);
197         if ( c_info.alpha_mask == 0xff000000 && image->green_mask == 0x0000ff00) {
198             /* byte order is relevant here, not endianness
199              * endianness is handled by avcodec, but atm no such thing
200              * as having ABGR, instead of ARGB in a word. Since we
201              * need this for Solaris/SPARC, but need to do the conversion
202              * for every frame we do it outside of this loop, cf. below
203              * this matches both ARGB32 and ABGR32 */
204             input_pixfmt = PIX_FMT_ARGB32;
205         }  else {
206             av_log(s1, AV_LOG_ERROR,"image depth %i not supported ... aborting\n", image->bits_per_pixel);
207             return AVERROR_IO;
208         }
209 #endif
210         input_pixfmt = PIX_FMT_RGBA32;
211         break;
212     default:
213         av_log(s1, AV_LOG_ERROR, "image depth %i not supported ... aborting\n", image->bits_per_pixel);
214         return -1;
215     }
216
217     x11grab->frame_size = ap->width * ap->height * image->bits_per_pixel/8;
218     x11grab->dpy = dpy;
219     x11grab->width = ap->width;
220     x11grab->height = ap->height;
221     x11grab->time_base  = ap->time_base;
222     x11grab->time_frame = av_gettime() / av_q2d(ap->time_base);
223     x11grab->x_off = x_off;
224     x11grab->y_off = y_off;
225     x11grab->image = image;
226     x11grab->use_shm = use_shm;
227
228     st->codec->codec_type = CODEC_TYPE_VIDEO;
229     st->codec->codec_id = CODEC_ID_RAWVIDEO;
230     st->codec->width = ap->width;
231     st->codec->height = ap->height;
232     st->codec->pix_fmt = input_pixfmt;
233     st->codec->time_base = ap->time_base;
234     st->codec->bit_rate = x11grab->frame_size * 1/av_q2d(ap->time_base) * 8;
235
236     return 0;
237 }
238
239 /**
240  * Get pointer coordinates from X11.
241  *
242  * @param x Integer where horizontal coordinate will be returned
243  * @param y Integer where vertical coordinate will be returned
244  * @param dpy X11 display from where pointer coordinates are retrieved
245  * @param s1 Context used for logging errors if necessary
246  */
247 static void
248 get_pointer_coordinates(int *x, int *y, Display *dpy, AVFormatContext *s1)
249 {
250     Window mrootwindow, childwindow;
251     int dummy;
252
253     mrootwindow = DefaultRootWindow(dpy);
254
255     if (XQueryPointer(dpy, mrootwindow, &mrootwindow, &childwindow,
256                       x, y, &dummy, &dummy, (unsigned int*)&dummy)) {
257     } else {
258         av_log(s1, AV_LOG_INFO, "couldn't find mouse pointer\n");
259         *x = -1;
260         *y = -1;
261     }
262 }
263
264 /**
265  * Mouse painting helper function that applies an 'and' and 'or' mask pair to
266  * '*dst' pixel. It actually draws a mouse pointer pixel to grabbed frame.
267  *
268  * @param dst Destination pixel
269  * @param and Part of the mask that must be applied using a bitwise 'and'
270  *            operator
271  * @param or  Part of the mask that must be applied using a bitwise 'or'
272  *            operator
273  * @param bits_per_pixel Bits per pixel used in the grabbed image
274  */
275 static void inline
276 apply_masks(uint8_t *dst, int and, int or, int bits_per_pixel)
277 {
278     switch (bits_per_pixel) {
279     case 32:
280         *(uint32_t*)dst = (*(uint32_t*)dst & and) | or;
281         break;
282     case 16:
283         *(uint16_t*)dst = (*(uint16_t*)dst & and) | or;
284         break;
285     case 8:
286         *dst = !!or;
287         break;
288     }
289 }
290
291 /**
292  * Paints a mouse pointer in an X11 image.
293  *
294  * @param image Image where to paint the mouse pointer
295  * @param s context used to retrieve original grabbing rectangle
296  *          coordinates
297  * @param x Mouse pointer coordinate
298  * @param y Mouse pointer coordinate
299  */
300 static void
301 paint_mouse_pointer(XImage *image, x11_grab_t *s, int x, int y)
302 {
303     /* 16x20x1bpp bitmap for the black channel of the mouse pointer */
304     static const uint16_t const mousePointerBlack[] =
305         {
306             0x0000, 0x0003, 0x0005, 0x0009, 0x0011,
307             0x0021, 0x0041, 0x0081, 0x0101, 0x0201,
308             0x03c1, 0x0049, 0x0095, 0x0093, 0x0120,
309             0x0120, 0x0240, 0x0240, 0x0380, 0x0000
310         };
311
312     /* 16x20x1bpp bitmap for the white channel of the mouse pointer */
313     static const uint16_t const mousePointerWhite[] =
314         {
315             0x0000, 0x0000, 0x0002, 0x0006, 0x000e,
316             0x001e, 0x003e, 0x007e, 0x00fe, 0x01fe,
317             0x003e, 0x0036, 0x0062, 0x0060, 0x00c0,
318             0x00c0, 0x0180, 0x0180, 0x0000, 0x0000
319         };
320
321     int x_off = s->x_off;
322     int y_off = s->y_off;
323     int width = s->width;
324     int height = s->height;
325
326     if (   x - x_off >= 0 && x < width + x_off
327         && y - y_off >= 0 && y < height + y_off) {
328         uint8_t *im_data = (uint8_t*)image->data;
329         int bytes_per_pixel;
330         int line;
331         int masks;
332
333         /* Select correct masks and pixel size */
334         if (image->bits_per_pixel == 8) {
335             masks = 1;
336         } else {
337             masks = (image->red_mask|image->green_mask|image->blue_mask);
338         }
339         bytes_per_pixel = image->bits_per_pixel>>3;
340
341         /* Shift to right line */
342         im_data += image->bytes_per_line * (y - y_off);
343         /* Shift to right pixel in the line */
344         im_data += bytes_per_pixel * (x - x_off);
345
346         /* Draw the cursor - proper loop */
347         for (line = 0; line < FFMIN(20, (y_off + height) - y); line++) {
348             uint8_t *cursor = im_data;
349             int column;
350             uint16_t bm_b;
351             uint16_t bm_w;
352
353             bm_b = mousePointerBlack[line];
354             bm_w = mousePointerWhite[line];
355
356             for (column = 0; column < FFMIN(16, (x_off + width) - x); column++) {
357                 apply_masks(cursor, ~(masks*(bm_b&1)), masks*(bm_w&1),
358                             image->bits_per_pixel);
359                 cursor += bytes_per_pixel;
360                 bm_b >>= 1;
361                 bm_w >>= 1;
362             }
363             im_data += image->bytes_per_line;
364         }
365     }
366 }
367
368
369 /**
370  * Reads new data in the image structure.
371  *
372  * @param dpy X11 display to grab from
373  * @param d
374  * @param image Image where the grab will be put
375  * @param x Top-Left grabbing rectangle horizontal coordinate
376  * @param y Top-Left grabbing rectangle vertical coordinate
377  * @return 0 if error, !0 if successful
378  */
379 static int
380 xget_zpixmap(Display *dpy, Drawable d, XImage *image, int x, int y)
381 {
382     xGetImageReply rep;
383     xGetImageReq *req;
384     long nbytes;
385
386     if (!image) {
387         return 0;
388     }
389
390     LockDisplay(dpy);
391     GetReq(GetImage, req);
392
393     /* First set up the standard stuff in the request */
394     req->drawable = d;
395     req->x = x;
396     req->y = y;
397     req->width = image->width;
398     req->height = image->height;
399     req->planeMask = (unsigned int)AllPlanes;
400     req->format = ZPixmap;
401
402     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.length) {
403         UnlockDisplay(dpy);
404         SyncHandle();
405         return 0;
406     }
407
408     nbytes = (long)rep.length << 2;
409     _XReadPad(dpy, image->data, nbytes);
410
411     UnlockDisplay(dpy);
412     SyncHandle();
413     return 1;
414 }
415
416 /**
417  * Grabs a frame from x11 (public device demuxer API).
418  *
419  * @param s1 Context from avformat core
420  * @param pkt Packet holding the brabbed frame
421  * @return frame size in bytes
422  */
423 static int
424 x11grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
425 {
426     x11_grab_t *s = s1->priv_data;
427     Display *dpy = s->dpy;
428     XImage *image = s->image;
429     int x_off = s->x_off;
430     int y_off = s->y_off;
431
432     int64_t curtime, delay;
433     struct timespec ts;
434
435     /* Calculate the time of the next frame */
436     s->time_frame += INT64_C(1000000);
437
438     /* wait based on the frame rate */
439     for(;;) {
440         curtime = av_gettime();
441         delay = s->time_frame * av_q2d(s->time_base) - curtime;
442         if (delay <= 0) {
443             if (delay < INT64_C(-1000000) * av_q2d(s->time_base)) {
444                 s->time_frame += INT64_C(1000000);
445             }
446             break;
447         }
448         ts.tv_sec = delay / 1000000;
449         ts.tv_nsec = (delay % 1000000) * 1000;
450         nanosleep(&ts, NULL);
451     }
452
453     if (av_new_packet(pkt, s->frame_size) < 0) {
454         return AVERROR_IO;
455     }
456
457     pkt->pts = curtime;
458
459     if(s->use_shm) {
460         if (!XShmGetImage(dpy, RootWindow(dpy, DefaultScreen(dpy)), image, x_off, y_off, AllPlanes)) {
461             av_log (s1, AV_LOG_INFO, "XShmGetImage() failed\n");
462         }
463     } else {
464         if (!xget_zpixmap(dpy, RootWindow(dpy, DefaultScreen(dpy)), image, x_off, y_off)) {
465             av_log (s1, AV_LOG_INFO, "XGetZPixmap() failed\n");
466         }
467     }
468
469     {
470         int pointer_x, pointer_y;
471         get_pointer_coordinates(&pointer_x, &pointer_y, dpy, s1);
472         paint_mouse_pointer(image, s, pointer_x, pointer_y);
473     }
474
475
476     /* XXX: avoid memcpy */
477     memcpy(pkt->data, image->data, s->frame_size);
478     return s->frame_size;
479 }
480
481 /**
482  * Closes x11 frame grabber (public device demuxer API).
483  *
484  * @param s1 Context from avformat core
485  * @return 0 success, !0 failure
486  */
487 static int
488 x11grab_read_close(AVFormatContext *s1)
489 {
490     x11_grab_t *x11grab = s1->priv_data;
491
492     /* Detach cleanly from shared mem */
493     if (x11grab->use_shm) {
494         XShmDetach(x11grab->dpy, &x11grab->shminfo);
495         shmdt(x11grab->shminfo.shmaddr);
496         shmctl(x11grab->shminfo.shmid, IPC_RMID, NULL);
497     }
498
499     /* Destroy X11 image */
500     if (x11grab->image) {
501         XDestroyImage(x11grab->image);
502         x11grab->image = NULL;
503     }
504
505     /* Free X11 display */
506     XCloseDisplay(x11grab->dpy);
507     return 0;
508 }
509
510 /** x11 grabber device demuxer declaration */
511 AVInputFormat x11_grab_device_demuxer =
512 {
513     "x11grab",
514     "X11grab",
515     sizeof(x11_grab_t),
516     NULL,
517     x11grab_read_header,
518     x11grab_read_packet,
519     x11grab_read_close,
520     .flags = AVFMT_NOFILE,
521 };