2006-12-13 09:45:36 +01:00
/*
* X11 video grab interface
2006-12-13 09:46:31 +01:00
*
2011-03-18 18:35:10 +01:00
* This file is part of Libav .
2006-12-13 09:45:36 +01:00
*
2011-03-18 18:35:10 +01:00
* Libav integration :
2006-12-13 09:48:13 +01:00
* Copyright ( C ) 2006 Clemens Fruhwirth < clemens @ endorphin . org >
* Edouard Gomez < ed . gomez @ free . fr >
2006-12-13 09:45:36 +01:00
*
2006-12-13 09:48:13 +01:00
* This file contains code from grab . c :
2006-12-13 09:48:56 +01:00
* Copyright ( c ) 2000 - 2001 Fabrice Bellard
2006-12-13 09:45:36 +01:00
*
* This file contains code from the xvidcap project :
2006-12-13 09:48:13 +01:00
* Copyright ( C ) 1997 - 1998 Rasca , Berlin
* 2003 - 2004 Karl H . Beckers , Frankfurt
2006-12-13 09:45:36 +01:00
*
2011-03-18 18:35:10 +01:00
* Libav is free software ; you can redistribute it and / or modify
2006-12-13 09:45:36 +01:00
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 2 of the License , or
* ( at your option ) any later version .
*
2011-03-18 18:35:10 +01:00
* Libav is distributed in the hope that it will be useful ,
2006-12-13 09:45:36 +01:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
2007-07-05 12:40:25 +02:00
* You should have received a copy of the GNU General Public License
2011-03-18 18:35:10 +01:00
* along with Libav ; if not , write to the Free Software
2007-07-05 12:40:25 +02:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2006-12-13 09:45:36 +01:00
*/
2006-12-13 09:46:31 +01:00
2006-12-13 09:50:30 +01:00
/**
2010-04-20 16:45:34 +02:00
* @ file
2011-10-30 19:10:50 +01:00
* X11 frame device demuxer
* @ author Clemens Fruhwirth < clemens @ endorphin . org >
* @ author Edouard Gomez < ed . gomez @ free . fr >
2006-12-13 09:50:30 +01:00
*/
2008-03-20 20:07:24 +01:00
# include "config.h"
2014-08-27 04:43:47 +02:00
2006-12-13 09:45:36 +01:00
# include <time.h>
2014-08-27 04:43:47 +02:00
# include <sys/shm.h>
2006-12-13 09:45:36 +01:00
# include <X11/X.h>
# include <X11/Xlib.h>
# include <X11/Xlibint.h>
# include <X11/Xproto.h>
2006-12-13 09:48:13 +01:00
# include <X11/Xutil.h>
2014-08-27 04:43:47 +02:00
2011-07-30 13:13:43 +02:00
# include <X11/extensions/shape.h>
2009-11-27 18:58:48 +01:00
# include <X11/extensions/Xfixes.h>
2014-08-27 04:43:47 +02:00
# include <X11/extensions/XShm.h>
2006-12-13 09:45:36 +01:00
2014-08-27 04:43:47 +02:00
# include "libavutil/log.h"
# include "libavutil/opt.h"
# include "libavutil/parseutils.h"
# include "libavutil/time.h"
# include "libavformat/avformat.h"
# include "libavformat/internal.h"
/** X11 device demuxer context */
2014-08-27 04:43:50 +02:00
typedef struct X11GrabContext {
2011-05-24 07:43:01 +02:00
const AVClass * class ; /**< Class for private options. */
2006-12-13 09:50:30 +01:00
int frame_size ; /**< Size in bytes of a grabbed frame */
AVRational time_base ; /**< Time base */
int64_t time_frame ; /**< Current time */
2011-05-24 07:43:01 +02:00
char * video_size ; /**< String describing video size, set by a private option. */
2006-12-13 09:50:30 +01:00
int height ; /**< Height of the grab frame */
int width ; /**< Width of the grab frame */
int x_off ; /**< Horizontal top-left corner coordinate */
int y_off ; /**< Vertical top-left corner coordinate */
Display * dpy ; /**< X11 display from which x11grab grabs frames */
XImage * image ; /**< X11 image holding the grab */
int use_shm ; /**< !0 when using XShm extension */
XShmSegmentInfo shminfo ; /**< When using XShm, keeps track of XShm infos */
2014-08-27 04:43:47 +02:00
int draw_mouse ; /**< Set by a private option. */
int follow_mouse ; /**< Set by a private option. */
int show_region ; /**< set by a private option. */
2011-06-03 13:36:36 +02:00
char * framerate ; /**< Set by a private option. */
2011-07-30 13:13:43 +02:00
Window region_win ; /**< This is used by show_region option. */
2014-08-27 04:43:50 +02:00
} X11GrabContext ;
2006-12-13 09:50:30 +01:00
2011-07-30 13:13:43 +02:00
# define REGION_WIN_BORDER 3
2014-08-27 04:43:47 +02:00
2011-07-30 13:13:43 +02:00
/**
* Draw grabbing region window
*
2012-07-21 21:28:54 +02:00
* @ param s x11grab context
2011-07-30 13:13:43 +02:00
*/
2014-08-27 04:43:50 +02:00
static void x11grab_draw_region_win ( X11GrabContext * s )
2011-07-30 13:13:43 +02:00
{
Display * dpy = s - > dpy ;
2014-08-27 04:43:47 +02:00
Window win = s - > region_win ;
2014-08-27 04:43:48 +02:00
int screen = DefaultScreen ( dpy ) ;
GC gc = XCreateGC ( dpy , win , 0 , 0 ) ;
2011-07-30 13:13:43 +02:00
XSetForeground ( dpy , gc , WhitePixel ( dpy , screen ) ) ;
XSetBackground ( dpy , gc , BlackPixel ( dpy , screen ) ) ;
XSetLineAttributes ( dpy , gc , REGION_WIN_BORDER , LineDoubleDash , 0 , 0 ) ;
2014-08-27 04:43:47 +02:00
XDrawRectangle ( dpy , win , gc , 1 , 1 ,
2011-07-30 13:13:43 +02:00
( s - > width + REGION_WIN_BORDER * 2 ) - 1 * 2 - 1 ,
( s - > height + REGION_WIN_BORDER * 2 ) - 1 * 2 - 1 ) ;
XFreeGC ( dpy , gc ) ;
}
/**
* Initialize grabbing region window
*
2012-07-21 21:28:54 +02:00
* @ param s x11grab context
2011-07-30 13:13:43 +02:00
*/
2014-08-27 04:43:50 +02:00
static void x11grab_region_win_init ( X11GrabContext * s )
2011-07-30 13:13:43 +02:00
{
Display * dpy = s - > dpy ;
XRectangle rect ;
2014-08-27 04:43:48 +02:00
XSetWindowAttributes attribs = { . override_redirect = True } ;
int screen = DefaultScreen ( dpy ) ;
2011-07-30 13:13:43 +02:00
s - > region_win = XCreateWindow ( dpy , RootWindow ( dpy , screen ) ,
s - > x_off - REGION_WIN_BORDER ,
s - > y_off - REGION_WIN_BORDER ,
s - > width + REGION_WIN_BORDER * 2 ,
s - > height + REGION_WIN_BORDER * 2 ,
0 , CopyFromParent ,
InputOutput , CopyFromParent ,
CWOverrideRedirect , & attribs ) ;
2014-08-27 04:43:47 +02:00
rect . x = 0 ;
rect . y = 0 ;
2011-07-30 13:13:43 +02:00
rect . width = s - > width ;
rect . height = s - > height ;
XShapeCombineRectangles ( dpy , s - > region_win ,
ShapeBounding , REGION_WIN_BORDER , REGION_WIN_BORDER ,
& rect , 1 , ShapeSubtract , 0 ) ;
XMapWindow ( dpy , s - > region_win ) ;
XSelectInput ( dpy , s - > region_win , ExposureMask | StructureNotifyMask ) ;
x11grab_draw_region_win ( s ) ;
}
2014-08-09 21:37:02 +02:00
static int setup_shm ( AVFormatContext * s , Display * dpy , XImage * * image )
{
X11GrabContext * g = s - > priv_data ;
int scr = XDefaultScreen ( dpy ) ;
XImage * img = XShmCreateImage ( dpy , DefaultVisual ( dpy , scr ) ,
DefaultDepth ( dpy , scr ) , ZPixmap , NULL ,
& g - > shminfo , g - > width , g - > height ) ;
g - > shminfo . shmid = shmget ( IPC_PRIVATE , img - > bytes_per_line * img - > height ,
IPC_CREAT | 0777 ) ;
if ( g - > shminfo . shmid = = - 1 ) {
av_log ( s , AV_LOG_ERROR , " Cannot get shared memory! \n " ) ;
return AVERROR ( ENOMEM ) ;
}
g - > shminfo . shmaddr = img - > data = shmat ( g - > shminfo . shmid , 0 , 0 ) ;
g - > shminfo . readOnly = False ;
if ( ! XShmAttach ( dpy , & g - > shminfo ) ) {
av_log ( s , AV_LOG_ERROR , " Failed to attach shared memory! \n " ) ;
/* needs some better error subroutine :) */
return AVERROR ( EIO ) ;
}
* image = img ;
return 0 ;
}
2014-09-11 14:15:08 +02:00
static int setup_mouse ( Display * dpy , int screen )
{
int ev_ret , ev_err ;
if ( XFixesQueryExtension ( dpy , & ev_ret , & ev_err ) ) {
Window root = RootWindow ( dpy , screen ) ;
XFixesSelectCursorInput ( dpy , root , XFixesDisplayCursorNotifyMask ) ;
return 0 ;
}
return AVERROR ( ENOSYS ) ;
}
2014-08-10 17:32:18 +02:00
static int pixfmt_from_image ( AVFormatContext * s , XImage * image , int * pix_fmt )
{
av_log ( s , AV_LOG_DEBUG ,
" Image r 0x%.6lx g 0x%.6lx b 0x%.6lx and depth %i \n " ,
image - > red_mask ,
image - > green_mask ,
image - > blue_mask ,
image - > bits_per_pixel ) ;
switch ( image - > bits_per_pixel ) {
case 8 :
* pix_fmt = AV_PIX_FMT_PAL8 ;
break ;
case 16 :
if ( image - > red_mask = = 0xf800 & &
image - > green_mask = = 0x07e0 & &
image - > blue_mask = = 0x001f ) {
* pix_fmt = AV_PIX_FMT_RGB565 ;
} else if ( image - > red_mask = = 0x7c00 & &
image - > green_mask = = 0x03e0 & &
image - > blue_mask = = 0x001f ) {
* pix_fmt = AV_PIX_FMT_RGB555 ;
}
break ;
case 24 :
if ( image - > red_mask = = 0xff0000 & &
image - > green_mask = = 0x00ff00 & &
image - > blue_mask = = 0x0000ff ) {
* pix_fmt = AV_PIX_FMT_BGR24 ;
} else if ( image - > red_mask = = 0x0000ff & &
image - > green_mask = = 0x00ff00 & &
image - > blue_mask = = 0xff0000 ) {
* pix_fmt = AV_PIX_FMT_RGB24 ;
}
break ;
case 32 :
* pix_fmt = AV_PIX_FMT_RGB32 ;
break ;
default :
av_log ( s , AV_LOG_ERROR ,
" XImages with RGB mask 0x%.6lx 0x%.6lx 0x%.6lx and depth %i "
" are currently not supported. \n " ,
image - > red_mask ,
image - > green_mask ,
image - > blue_mask ,
image - > bits_per_pixel ) ;
return AVERROR_PATCHWELCOME ;
}
return 0 ;
}
2006-12-13 09:50:30 +01:00
/**
2010-06-30 17:38:06 +02:00
* Initialize the x11 grab device demuxer ( public device demuxer API ) .
2006-12-13 09:50:30 +01:00
*
* @ param s1 Context from avformat core
* @ return < ul >
2007-07-19 17:37:44 +02:00
* < li > AVERROR ( ENOMEM ) no memory left < / li >
2007-07-19 17:23:32 +02:00
* < li > AVERROR ( EIO ) other failure case < / li >
2006-12-13 09:50:30 +01:00
* < li > 0 success < / li >
* < / ul >
*/
2014-08-27 04:43:47 +02:00
static int x11grab_read_header ( AVFormatContext * s1 )
2006-12-13 09:45:36 +01:00
{
2014-08-27 04:43:50 +02:00
X11GrabContext * x11grab = s1 - > priv_data ;
2006-12-13 09:48:56 +01:00
Display * dpy ;
AVStream * st = NULL ;
XImage * image ;
2014-08-27 04:43:48 +02:00
int x_off = 0 , y_off = 0 , ret = 0 , screen , use_shm ;
2006-12-15 14:19:03 +01:00
char * param , * offset ;
2011-06-03 13:36:36 +02:00
AVRational framerate ;
2006-12-13 09:48:56 +01:00
2007-02-14 18:01:32 +01:00
param = av_strdup ( s1 - > filename ) ;
2012-03-16 22:23:34 +01:00
if ( ! param )
goto out ;
2006-12-15 14:19:03 +01:00
offset = strchr ( param , ' + ' ) ;
if ( offset ) {
sscanf ( offset , " %d,%d " , & x_off , & y_off ) ;
2011-06-20 12:42:36 +02:00
x11grab - > draw_mouse = ! strstr ( offset , " nomouse " ) ;
2014-08-27 04:43:47 +02:00
* offset = 0 ;
2006-12-15 14:19:03 +01:00
}
2014-08-27 04:43:48 +02:00
ret = av_parse_video_size ( & x11grab - > width , & x11grab - > height ,
x11grab - > video_size ) ;
if ( ret < 0 ) {
2011-05-24 07:43:01 +02:00
av_log ( s1 , AV_LOG_ERROR , " Couldn't parse video size. \n " ) ;
goto out ;
}
2014-08-27 04:43:48 +02:00
ret = av_parse_video_rate ( & framerate , x11grab - > framerate ) ;
if ( ret < 0 ) {
2014-08-27 04:43:47 +02:00
av_log ( s1 , AV_LOG_ERROR , " Could not parse framerate: %s. \n " ,
x11grab - > framerate ) ;
2011-06-03 13:36:36 +02:00
goto out ;
}
2014-08-27 04:43:47 +02:00
av_log ( s1 , AV_LOG_INFO ,
" device: %s -> display: %s x: %d y: %d width: %d height: %d \n " ,
2011-05-24 07:43:01 +02:00
s1 - > filename , param , x_off , y_off , x11grab - > width , x11grab - > height ) ;
2006-12-15 14:19:03 +01:00
dpy = XOpenDisplay ( param ) ;
2014-08-27 04:43:47 +02:00
if ( ! dpy ) {
2006-12-15 14:19:03 +01:00
av_log ( s1 , AV_LOG_ERROR , " Could not open X display. \n " ) ;
2011-05-26 21:17:05 +02:00
ret = AVERROR ( EIO ) ;
goto out ;
2006-12-15 14:19:03 +01:00
}
2006-12-13 09:48:56 +01:00
2011-06-18 11:43:24 +02:00
st = avformat_new_stream ( s1 , NULL ) ;
2006-12-13 09:48:56 +01:00
if ( ! st ) {
2011-05-26 21:17:05 +02:00
ret = AVERROR ( ENOMEM ) ;
goto out ;
2006-12-13 09:48:56 +01:00
}
2011-11-29 19:28:15 +01:00
avpriv_set_pts_info ( st , 64 , 1 , 1000000 ) ; /* 64 bits pts in us */
2006-12-13 09:48:56 +01:00
2011-07-30 12:46:36 +02:00
screen = DefaultScreen ( dpy ) ;
if ( x11grab - > follow_mouse ) {
int screen_w , screen_h ;
Window w ;
screen_w = DisplayWidth ( dpy , screen ) ;
screen_h = DisplayHeight ( dpy , screen ) ;
2014-08-27 04:43:47 +02:00
XQueryPointer ( dpy , RootWindow ( dpy , screen ) , & w , & w , & x_off , & y_off ,
& ret , & ret , & ret ) ;
2011-07-30 12:46:36 +02:00
x_off - = x11grab - > width / 2 ;
y_off - = x11grab - > height / 2 ;
2014-08-27 04:43:47 +02:00
x_off = FFMIN ( FFMAX ( x_off , 0 ) , screen_w - x11grab - > width ) ;
y_off = FFMIN ( FFMAX ( y_off , 0 ) , screen_h - x11grab - > height ) ;
av_log ( s1 , AV_LOG_INFO ,
" followmouse is enabled, resetting grabbing region to x: %d y: %d \n " ,
x_off , y_off ) ;
2011-07-30 12:46:36 +02:00
}
2006-12-13 09:48:56 +01:00
use_shm = XShmQueryExtension ( dpy ) ;
2014-08-27 04:43:47 +02:00
av_log ( s1 , AV_LOG_INFO ,
2014-08-27 04:43:49 +02:00
" shared memory extension %sfound \n " , use_shm ? " " : " not " ) ;
2006-12-13 09:48:56 +01:00
2014-08-09 21:37:02 +02:00
if ( use_shm & & setup_shm ( s1 , dpy , & image ) < 0 ) {
av_log ( s1 , AV_LOG_WARNING , " Falling back to XGetImage \n " ) ;
use_shm = 0 ;
}
if ( ! use_shm ) {
2011-07-30 12:46:36 +02:00
image = XGetImage ( dpy , RootWindow ( dpy , screen ) ,
2014-08-27 04:43:47 +02:00
x_off , y_off ,
2011-05-24 07:43:01 +02:00
x11grab - > width , x11grab - > height ,
2006-12-13 09:48:56 +01:00
AllPlanes , ZPixmap ) ;
}
2014-09-11 14:15:08 +02:00
if ( x11grab - > draw_mouse & & setup_mouse ( dpy , screen ) < 0 ) {
av_log ( s1 , AV_LOG_WARNING ,
" XFixes not available, cannot draw the mouse cursor \n " ) ;
x11grab - > draw_mouse = 0 ;
}
2014-08-27 04:43:47 +02:00
x11grab - > frame_size = x11grab - > width * x11grab - > height * image - > bits_per_pixel / 8 ;
x11grab - > dpy = dpy ;
x11grab - > time_base = ( AVRational ) { framerate . den , framerate . num } ;
2011-06-03 13:36:36 +02:00
x11grab - > time_frame = av_gettime ( ) / av_q2d ( x11grab - > time_base ) ;
2014-08-27 04:43:47 +02:00
x11grab - > x_off = x_off ;
x11grab - > y_off = y_off ;
x11grab - > image = image ;
x11grab - > use_shm = use_shm ;
2006-12-13 09:48:56 +01:00
2014-08-10 17:32:18 +02:00
ret = pixfmt_from_image ( s1 , image , & st - > codec - > pix_fmt ) ;
if ( ret < 0 )
goto out ;
2010-03-31 01:30:55 +02:00
st - > codec - > codec_type = AVMEDIA_TYPE_VIDEO ;
2014-08-27 04:43:47 +02:00
st - > codec - > codec_id = AV_CODEC_ID_RAWVIDEO ;
st - > codec - > width = x11grab - > width ;
st - > codec - > height = x11grab - > height ;
st - > codec - > time_base = x11grab - > time_base ;
st - > codec - > bit_rate = x11grab - > frame_size * 1 / av_q2d ( x11grab - > time_base ) * 8 ;
2006-12-13 09:48:56 +01:00
2011-05-26 21:17:05 +02:00
out :
2012-03-16 22:23:34 +01:00
av_free ( param ) ;
2011-05-26 21:17:05 +02:00
return ret ;
2006-12-13 09:45:36 +01:00
}
2006-12-13 09:50:30 +01:00
/**
2010-06-30 17:38:06 +02:00
* Paint a mouse pointer in an X11 image .
2006-12-13 09:50:30 +01:00
*
2008-03-15 17:15:47 +01:00
* @ param image image to paint the mouse pointer to
2006-12-13 09:50:30 +01:00
* @ param s context used to retrieve original grabbing rectangle
* coordinates
*/
2014-08-27 04:43:50 +02:00
static void paint_mouse_pointer ( XImage * image , X11GrabContext * s )
2006-12-13 09:46:31 +01:00
{
2014-08-27 04:43:47 +02:00
int x_off = s - > x_off ;
int y_off = s - > y_off ;
int width = s - > width ;
int height = s - > height ;
2009-11-27 18:58:48 +01:00
Display * dpy = s - > dpy ;
XFixesCursorImage * xcim ;
int x , y ;
int line , column ;
int to_line , to_column ;
2010-11-07 19:04:46 +01:00
int pixstride = image - > bits_per_pixel > > 3 ;
/* Warning: in its insanity, xlib provides unsigned image data through a
* char * pointer , so we have to make it uint8_t to make things not break .
* Anyone who performs further investigation of the xlib API likely risks
* permanent brain damage . */
uint8_t * pix = image - > data ;
/* Code doesn't currently support 16-bit or PAL8 */
if ( image - > bits_per_pixel ! = 24 & & image - > bits_per_pixel ! = 32 )
return ;
2006-12-13 09:48:56 +01:00
2010-06-22 00:54:53 +02:00
xcim = XFixesGetCursorImage ( dpy ) ;
2014-09-11 14:28:44 +02:00
if ( ! xcim )
return ;
2006-12-13 09:48:56 +01:00
2009-11-27 18:58:48 +01:00
x = xcim - > x - xcim - > xhot ;
y = xcim - > y - xcim - > yhot ;
2014-08-27 04:43:47 +02:00
to_line = FFMIN ( ( y + xcim - > height ) , ( height + y_off ) ) ;
to_column = FFMIN ( ( x + xcim - > width ) , ( width + x_off ) ) ;
2009-11-27 18:58:48 +01:00
for ( line = FFMAX ( y , y_off ) ; line < to_line ; line + + ) {
for ( column = FFMAX ( x , x_off ) ; column < to_column ; column + + ) {
2014-08-27 04:43:47 +02:00
int xcim_addr = ( line - y ) * xcim - > width + column - x ;
int image_addr = ( ( line - y_off ) * width + column - x_off ) * pixstride ;
int r = ( uint8_t ) ( xcim - > pixels [ xcim_addr ] > > 0 ) ;
int g = ( uint8_t ) ( xcim - > pixels [ xcim_addr ] > > 8 ) ;
int b = ( uint8_t ) ( xcim - > pixels [ xcim_addr ] > > 16 ) ;
int a = ( uint8_t ) ( xcim - > pixels [ xcim_addr ] > > 24 ) ;
2010-11-07 19:04:46 +01:00
if ( a = = 255 ) {
2014-08-27 04:43:47 +02:00
pix [ image_addr + 0 ] = r ;
pix [ image_addr + 1 ] = g ;
pix [ image_addr + 2 ] = b ;
2010-11-07 19:04:46 +01:00
} else if ( a ) {
/* pixel values from XFixesGetCursorImage come premultiplied by alpha */
2014-08-27 04:43:47 +02:00
pix [ image_addr + 0 ] = r + ( pix [ image_addr + 0 ] * ( 255 - a ) + 255 / 2 ) / 255 ;
pix [ image_addr + 1 ] = g + ( pix [ image_addr + 1 ] * ( 255 - a ) + 255 / 2 ) / 255 ;
pix [ image_addr + 2 ] = b + ( pix [ image_addr + 2 ] * ( 255 - a ) + 255 / 2 ) / 255 ;
2006-12-13 09:49:34 +01:00
}
2006-12-13 09:48:56 +01:00
}
}
2009-11-27 18:58:48 +01:00
XFree ( xcim ) ;
xcim = NULL ;
2006-12-13 09:45:36 +01:00
}
2006-12-13 09:50:30 +01:00
/**
2010-06-30 17:38:06 +02:00
* Read new data in the image structure .
2006-12-13 09:50:30 +01:00
*
* @ param dpy X11 display to grab from
2006-12-13 10:14:30 +01:00
* @ param d
2006-12-13 09:50:30 +01:00
* @ param image Image where the grab will be put
* @ param x Top - Left grabbing rectangle horizontal coordinate
* @ param y Top - Left grabbing rectangle vertical coordinate
* @ return 0 if error , ! 0 if successful
2006-12-13 09:45:36 +01:00
*/
2014-08-27 04:43:47 +02:00
static int xget_zpixmap ( Display * dpy , Drawable d , XImage * image , int x , int y )
2006-12-13 09:45:36 +01:00
{
2006-12-13 09:48:56 +01:00
xGetImageReply rep ;
xGetImageReq * req ;
long nbytes ;
2014-08-27 04:43:47 +02:00
if ( ! image )
2006-12-13 09:50:30 +01:00
return 0 ;
2006-12-13 09:48:56 +01:00
LockDisplay ( dpy ) ;
GetReq ( GetImage , req ) ;
/* First set up the standard stuff in the request */
2014-08-27 04:43:47 +02:00
req - > drawable = d ;
req - > x = x ;
req - > y = y ;
req - > width = image - > width ;
req - > height = image - > height ;
2006-12-13 09:48:56 +01:00
req - > planeMask = ( unsigned int ) AllPlanes ;
2014-08-27 04:43:47 +02:00
req - > format = ZPixmap ;
2006-12-13 09:48:56 +01:00
2006-12-13 09:50:30 +01:00
if ( ! _XReply ( dpy , ( xReply * ) & rep , 0 , xFalse ) | | ! rep . length ) {
2006-12-13 09:48:56 +01:00
UnlockDisplay ( dpy ) ;
SyncHandle ( ) ;
2006-12-13 09:50:30 +01:00
return 0 ;
2006-12-13 09:48:56 +01:00
}
nbytes = ( long ) rep . length < < 2 ;
_XReadPad ( dpy , image - > data , nbytes ) ;
UnlockDisplay ( dpy ) ;
SyncHandle ( ) ;
2006-12-13 09:50:30 +01:00
return 1 ;
2006-12-13 09:45:36 +01:00
}
2006-12-13 09:50:30 +01:00
/**
2010-06-30 17:38:06 +02:00
* Grab a frame from x11 ( public device demuxer API ) .
2006-12-13 09:50:30 +01:00
*
* @ param s1 Context from avformat core
* @ param pkt Packet holding the brabbed frame
* @ return frame size in bytes
*/
2014-08-27 04:43:47 +02:00
static int x11grab_read_packet ( AVFormatContext * s1 , AVPacket * pkt )
2006-12-13 09:45:36 +01:00
{
2014-08-27 04:43:50 +02:00
X11GrabContext * s = s1 - > priv_data ;
2014-08-27 04:43:47 +02:00
Display * dpy = s - > dpy ;
XImage * image = s - > image ;
int x_off = s - > x_off ;
int y_off = s - > y_off ;
int follow_mouse = s - > follow_mouse ;
2014-09-26 00:44:17 +02:00
int screen , pointer_x , pointer_y , _ , same_screen = 1 ;
Window w , root ;
2006-12-13 09:48:56 +01:00
int64_t curtime , delay ;
struct timespec ts ;
/* Calculate the time of the next frame */
2006-12-13 11:08:27 +01:00
s - > time_frame + = INT64_C ( 1000000 ) ;
2006-12-13 09:48:56 +01:00
/* wait based on the frame rate */
2014-08-27 04:43:47 +02:00
for ( ; ; ) {
2006-12-13 09:48:56 +01:00
curtime = av_gettime ( ) ;
2014-08-27 04:43:47 +02:00
delay = s - > time_frame * av_q2d ( s - > time_base ) - curtime ;
2006-12-13 09:48:56 +01:00
if ( delay < = 0 ) {
2014-08-27 04:43:47 +02:00
if ( delay < INT64_C ( - 1000000 ) * av_q2d ( s - > time_base ) )
2006-12-13 11:08:27 +01:00
s - > time_frame + = INT64_C ( 1000000 ) ;
2006-12-13 09:48:56 +01:00
break ;
}
2014-08-27 04:43:47 +02:00
ts . tv_sec = delay / 1000000 ;
2006-12-13 09:48:56 +01:00
ts . tv_nsec = ( delay % 1000000 ) * 1000 ;
nanosleep ( & ts , NULL ) ;
}
2011-03-30 17:02:29 +02:00
av_init_packet ( pkt ) ;
pkt - > data = image - > data ;
pkt - > size = s - > frame_size ;
2014-08-27 04:43:47 +02:00
pkt - > pts = curtime ;
2006-12-13 09:48:56 +01:00
2011-07-30 12:46:36 +02:00
screen = DefaultScreen ( dpy ) ;
2014-08-27 04:43:47 +02:00
root = RootWindow ( dpy , screen ) ;
2014-09-26 00:44:17 +02:00
if ( follow_mouse | | s - > draw_mouse )
same_screen = XQueryPointer ( dpy , root , & w , & w ,
& pointer_x , & pointer_y , & _ , & _ , & _ ) ;
if ( follow_mouse & & same_screen ) {
2011-07-30 12:46:36 +02:00
int screen_w , screen_h ;
screen_w = DisplayWidth ( dpy , screen ) ;
screen_h = DisplayHeight ( dpy , screen ) ;
if ( follow_mouse = = - 1 ) {
// follow the mouse, put it at center of grabbing region
2014-08-27 04:43:47 +02:00
x_off + = pointer_x - s - > width / 2 - x_off ;
2011-07-30 12:46:36 +02:00
y_off + = pointer_y - s - > height / 2 - y_off ;
} else {
// follow the mouse, but only move the grabbing region when mouse
// reaches within certain pixels to the edge.
2014-08-27 04:43:47 +02:00
if ( pointer_x > x_off + s - > width - follow_mouse )
2011-07-30 12:46:36 +02:00
x_off + = pointer_x - ( x_off + s - > width - follow_mouse ) ;
2014-08-27 04:43:47 +02:00
else if ( pointer_x < x_off + follow_mouse )
2011-07-30 12:46:36 +02:00
x_off - = ( x_off + follow_mouse ) - pointer_x ;
2014-08-27 04:43:47 +02:00
if ( pointer_y > y_off + s - > height - follow_mouse )
2011-07-30 12:46:36 +02:00
y_off + = pointer_y - ( y_off + s - > height - follow_mouse ) ;
2014-08-27 04:43:47 +02:00
else if ( pointer_y < y_off + follow_mouse )
2011-07-30 12:46:36 +02:00
y_off - = ( y_off + follow_mouse ) - pointer_y ;
}
// adjust grabbing region position if it goes out of screen.
s - > x_off = x_off = FFMIN ( FFMAX ( x_off , 0 ) , screen_w - s - > width ) ;
s - > y_off = y_off = FFMIN ( FFMAX ( y_off , 0 ) , screen_h - s - > height ) ;
2011-07-30 13:13:43 +02:00
if ( s - > show_region & & s - > region_win )
XMoveWindow ( dpy , s - > region_win ,
s - > x_off - REGION_WIN_BORDER ,
s - > y_off - REGION_WIN_BORDER ) ;
}
2014-09-26 00:44:17 +02:00
if ( s - > show_region & & same_screen ) {
2011-07-30 13:13:43 +02:00
if ( s - > region_win ) {
2014-08-27 04:43:48 +02:00
XEvent evt = { . type = NoEventMask } ;
// Clean up the events, and do the initial draw or redraw.
while ( XCheckMaskEvent ( dpy , ExposureMask | StructureNotifyMask ,
& evt ) )
2014-08-27 04:43:47 +02:00
;
2011-07-30 13:13:43 +02:00
if ( evt . type )
x11grab_draw_region_win ( s ) ;
} else {
x11grab_region_win_init ( s ) ;
}
2011-07-30 12:46:36 +02:00
}
2014-08-27 04:43:47 +02:00
if ( s - > use_shm ) {
if ( ! XShmGetImage ( dpy , root , image , x_off , y_off , AllPlanes ) )
av_log ( s1 , AV_LOG_INFO , " XShmGetImage() failed \n " ) ;
2006-12-13 09:48:56 +01:00
} else {
2014-08-27 04:43:47 +02:00
if ( ! xget_zpixmap ( dpy , root , image , x_off , y_off ) )
av_log ( s1 , AV_LOG_INFO , " XGetZPixmap() failed \n " ) ;
2006-12-13 09:48:56 +01:00
}
2014-09-26 00:44:17 +02:00
if ( s - > draw_mouse & & same_screen )
2009-11-27 18:58:48 +01:00
paint_mouse_pointer ( image , s ) ;
2006-12-13 09:48:56 +01:00
return s - > frame_size ;
2006-12-13 09:45:36 +01:00
}
2006-12-13 09:50:30 +01:00
/**
2010-06-30 17:38:06 +02:00
* Close x11 frame grabber ( public device demuxer API ) .
2006-12-13 09:50:30 +01:00
*
* @ param s1 Context from avformat core
* @ return 0 success , ! 0 failure
*/
2014-08-27 04:43:47 +02:00
static int x11grab_read_close ( AVFormatContext * s1 )
2006-12-13 09:45:36 +01:00
{
2014-08-27 04:43:50 +02:00
X11GrabContext * x11grab = s1 - > priv_data ;
2006-12-13 09:48:56 +01:00
/* Detach cleanly from shared mem */
if ( x11grab - > use_shm ) {
XShmDetach ( x11grab - > dpy , & x11grab - > shminfo ) ;
shmdt ( x11grab - > shminfo . shmaddr ) ;
shmctl ( x11grab - > shminfo . shmid , IPC_RMID , NULL ) ;
}
/* Destroy X11 image */
if ( x11grab - > image ) {
XDestroyImage ( x11grab - > image ) ;
x11grab - > image = NULL ;
}
2014-08-27 04:43:47 +02:00
if ( x11grab - > region_win )
2011-07-30 13:13:43 +02:00
XDestroyWindow ( x11grab - > dpy , x11grab - > region_win ) ;
2006-12-13 09:48:56 +01:00
/* Free X11 display */
XCloseDisplay ( x11grab - > dpy ) ;
return 0 ;
2006-12-13 09:45:36 +01:00
}
2014-08-27 04:43:50 +02:00
# define OFFSET(x) offsetof(X11GrabContext, x)
2011-05-24 07:43:01 +02:00
# define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options [ ] = {
2011-10-04 07:38:01 +02:00
{ " video_size " , " A string describing frame size, such as 640x480 or hd720. " , OFFSET ( video_size ) , AV_OPT_TYPE_STRING , { . str = " vga " } , 0 , 0 , DEC } ,
{ " framerate " , " " , OFFSET ( framerate ) , AV_OPT_TYPE_STRING , { . str = " ntsc " } , 0 , 0 , DEC } ,
2012-08-31 12:22:31 +02:00
{ " draw_mouse " , " Draw the mouse pointer. " , OFFSET ( draw_mouse ) , AV_OPT_TYPE_INT , { . i64 = 1 } , 0 , 1 , DEC } ,
2011-07-30 12:46:36 +02:00
{ " follow_mouse " , " Move the grabbing region when the mouse pointer reaches within specified amount of pixels to the edge of region. " ,
2012-08-31 12:22:31 +02:00
OFFSET ( follow_mouse ) , AV_OPT_TYPE_INT , { . i64 = 0 } , - 1 , INT_MAX , DEC , " follow_mouse " } ,
2012-08-31 11:45:52 +02:00
{ " centered " , " Keep the mouse pointer at the center of grabbing region when following. " , 0 , AV_OPT_TYPE_CONST , { . i64 = - 1 } , INT_MIN , INT_MAX , DEC , " follow_mouse " } ,
2012-08-31 12:22:31 +02:00
{ " show_region " , " Show the grabbing region. " , OFFSET ( show_region ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , 1 , DEC } ,
2011-05-24 07:43:01 +02:00
{ NULL } ,
} ;
static const AVClass x11_class = {
. class_name = " X11grab indev " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2006-12-13 09:50:30 +01:00
/** x11 grabber device demuxer declaration */
2012-07-21 21:28:54 +02:00
AVInputFormat ff_x11grab_demuxer = {
2011-09-23 20:50:11 +02:00
. name = " x11grab " ,
. long_name = NULL_IF_CONFIG_SMALL ( " X11grab " ) ,
2014-08-27 04:43:50 +02:00
. priv_data_size = sizeof ( X11GrabContext ) ,
2011-09-23 20:50:11 +02:00
. read_header = x11grab_read_header ,
. read_packet = x11grab_read_packet ,
. read_close = x11grab_read_close ,
. flags = AVFMT_NOFILE ,
. priv_class = & x11_class ,
2006-12-13 09:45:36 +01:00
} ;