[Ffmpeg-devel] [RFC #6] X11 device demuxer (synced svn 2006-12-01)

Edouard Gomez ed.gomez
Sat Dec 2 15:44:19 CET 2006


Hi again.

Changelog from previous RFC:
 - Addressed all bits from Michael.
 - Finally have a good license header !

What about answering my RFC questions in the introductory message of the
patch before approval (maybe ?) ?

# HG changeset patch
# User Edouard Gomez <ed.gomez at free.fr>
# Date 1165069504 -3600
# Node ID f6bf37ded701569ed4260a03be7452fb6d1047df
# Parent  c00db635f6ac15df15669d16ea02e5447a015b51
X11 device demuxer (synced svn 2006-12-01)

This adds a X11 device demuxer that grabs frames from the X11 server.

I am not the original author, but it seems this feature has never been
submited upstream and lacks active maintainer since 2005-12. I've picked
it up, cleaned it a bit and refreshed to newer ffmpeg habits. In the hope
to improve its chances to get it included upstream, here it is proposed
for review.

Request for comment:
 - Is it better to activate this demuxer even if XShm is not available ?
   (This code has already a code path for non shm server, but it still
    ask X11 server for the XShm extension... it could be enclosed in an
    ifdef. But does this extra work is still necessary for modern X11
    servers ?)
 - What would be a good way for plugging this into ffmpeg ? The actual
   patch if ugly in that aspect.

ChangeLog compared to original patch:
 - Synced with 2006-12-01 SVN source code
 - Uses av_log
 - Removed device name strdup.
 - Detach from SHM segment and destroy it.
 - Free X11 image
 - Templated Cursor drawing for 16/32bit
 - Cleaned source (untabified, simplified etc...)
 - Better configure integration
 - Synced with upstream SVN
 - Changed license header to plain GPL as it's the license that applies
   here. This avoids any confusion about the license source for now
 - Uses 64bit PTS instead of 48bit
 - Made mouse pointer bitmap const and static so it doesn't get set for
   each mouse painting call.
 - Changed the way mouse painting is done as suggested by
   Michael Niedermayer
 - License stays GPL, Karl H. Beckers see no good in making it LGPL.
 - Use AVRational where relevant
 - Removed unused X11Grab structure fields.
 - Renamed internal functions/structures using more C-fashioned names
 - Changed order of some parameters so they are more libc alike with
   destination as first parameter
 - Fixed time calculation
 - Added doxygen comments

Todo:
 - Check if a/v sync works
 - Check input size against X11 display dimensions.

diff -r c00db635f6ac -r f6bf37ded701 configure
--- a/configure	Fri Dec 01 20:38:54 2006 +0000
+++ b/configure	Sat Dec 02 15:25:04 2006 +0100
@@ -1644,6 +1644,16 @@ struct v4l2_buffer dummy1;
 struct v4l2_buffer dummy1;
 EOF
 
+# Deal with the x11 frame grabber
+enabled gpl                             &&
+enabled x11_grab_device_demuxer         &&
+check_header X11/Xlib.h                 &&
+check_header X11/extensions/XShm.h      &&
+check_func XOpenDisplay -lX11           &&
+check_func XShmCreateImage -lX11 -lXext &&
+add_extralibs -lX11 -lXext              ||
+disable x11_grab_device_demuxer
+
 enabled debug && add_cflags -g
 
 # add some useful compiler flags if supported
diff -r c00db635f6ac -r f6bf37ded701 ffmpeg.c
--- a/ffmpeg.c	Fri Dec 01 20:38:54 2006 +0000
+++ b/ffmpeg.c	Sat Dec 02 15:25:04 2006 +0100
@@ -3234,6 +3234,10 @@ static void prepare_grab(void)
 
     if (has_video) {
         AVInputFormat *fmt1;
+#warning FIXME: find a better interface
+        if(!strncmp(video_device,"x11:",4)) {
+            video_grab_format="x11grab";
+        }
         fmt1 = av_find_input_format(video_grab_format);
         vp->device  = video_device;
         vp->channel = video_channel;
diff -r c00db635f6ac -r f6bf37ded701 libavformat/Makefile
--- a/libavformat/Makefile	Fri Dec 01 20:38:54 2006 +0000
+++ b/libavformat/Makefile	Sat Dec 02 15:25:04 2006 +0100
@@ -123,6 +123,7 @@ OBJS-$(CONFIG_WSAUD_DEMUXER)            
 OBJS-$(CONFIG_WSAUD_DEMUXER)             += westwood.o
 OBJS-$(CONFIG_WSVQA_DEMUXER)             += westwood.o
 OBJS-$(CONFIG_WV_DEMUXER)                += wv.o
+OBJS-$(CONFIG_X11_GRAB_DEVICE_DEMUXER)   += x11grab.o
 OBJS-$(CONFIG_YUV4MPEGPIPE_MUXER)        += yuv4mpeg.o
 OBJS-$(CONFIG_YUV4MPEGPIPE_DEMUXER)      += yuv4mpeg.o
 
diff -r c00db635f6ac -r f6bf37ded701 libavformat/allformats.c
--- a/libavformat/allformats.c	Fri Dec 01 20:38:54 2006 +0000
+++ b/libavformat/allformats.c	Sat Dec 02 15:25:04 2006 +0100
@@ -166,6 +166,7 @@ void av_register_all(void)
     REGISTER_DEMUXER (WSAUD, wsaud);
     REGISTER_DEMUXER (WSVQA, wsvqa);
     REGISTER_DEMUXER (WV, wv);
+    REGISTER_DEMUXER (X11_GRAB_DEVICE, x11_grab_device);
     REGISTER_MUXDEMUX(YUV4MPEGPIPE, yuv4mpegpipe);
 
 #ifdef CONFIG_PROTOCOLS
diff -r c00db635f6ac -r f6bf37ded701 libavformat/allformats.h
--- a/libavformat/allformats.h	Fri Dec 01 20:38:54 2006 +0000
+++ b/libavformat/allformats.h	Sat Dec 02 15:25:04 2006 +0100
@@ -163,6 +163,7 @@ extern AVOutputFormat yuv4mpegpipe_muxer
 extern AVOutputFormat yuv4mpegpipe_muxer;
 extern AVInputFormat yuv4mpegpipe_demuxer;
 extern AVInputFormat tiertexseq_demuxer;
+extern AVInputFormat x11_grab_device_demuxer;
 
 /* raw.c */
 int pcm_read_seek(AVFormatContext *s,
diff -r c00db635f6ac -r f6bf37ded701 libavformat/x11grab.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libavformat/x11grab.c	Sat Dec 02 15:25:04 2006 +0100
@@ -0,0 +1,516 @@
+/*
+ * X11 video grab interface
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg integration:
+ * Copyright (C) 2006 Clemens Fruhwirth <clemens at endorphin.org>
+ *                    Edouard Gomez <ed.gomez at free.fr>
+ *
+ * This file contains code from grab.c:
+ * Copyright (c) 2000-2001 Fabrice Bellard
+ *
+ * This file contains code from the xvidcap project:
+ * Copyright (C) 1997-1998 Rasca, Berlin
+ *               2003-2004 Karl H. Beckers, Frankfurt
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * 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.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * @file x11grab.c
+ * X11 frame device demuxer by Clemens Fruhwirth <clemens at endorphin.org>
+ * and Edouard Gomez <ed.gomez at free.fr>.
+ */
+
+#include "avformat.h"
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#define _LINUX_TIME_H 1
+#include <time.h>
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xlibint.h>
+#include <X11/Xproto.h>
+#include <X11/Xutil.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <X11/extensions/XShm.h>
+
+/**
+ * X11 Device Demuxer context
+ */
+typedef struct x11_grab_s
+{
+    int frame_size;          /**< Size in bytes of a grabbed frame */
+    AVRational time_base;    /**< Time base */
+    int64_t time_frame;      /**< Current time */
+
+    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 */
+} x11_grab_t;
+
+/**
+ * Initializes the x11 grab device demuxer (public device demuxer API).
+ *
+ * @param s1 Context from avformat core
+ * @param ap Parameters from avformat core
+ * @return <ul>
+ *          <li>ENOMEM no memory left</li>
+ *          <li>AVERROR_IO other failure case</li>
+ *          <li>0 success</li>
+ *         </ul>
+ */
+static int
+x11grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
+{
+    x11_grab_t *x11grab = s1->priv_data;
+    Display *dpy;
+    AVStream *st = NULL;
+    int input_pixfmt;
+    XImage *image;
+    int x_off = 0;
+    int y_off = 0;
+    int use_shm;
+
+    dpy = XOpenDisplay(NULL);
+    if(!dpy) {
+        av_free(st);
+        return AVERROR_IO;
+    }
+
+    sscanf(ap->device, "x11:%d,%d", &x_off, &y_off);
+    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);
+
+    if (!ap || ap->width <= 0 || ap->height <= 0 || ap->time_base.den <= 0) {
+        av_log(s1, AV_LOG_ERROR, "AVParameters don't have any video size. Use -s.\n");
+        return AVERROR_IO;
+    }
+
+    st = av_new_stream(s1, 0);
+    if (!st) {
+        return -ENOMEM;
+    }
+    av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+
+    use_shm = XShmQueryExtension(dpy);
+    av_log(s1, AV_LOG_INFO, "shared memory extension %s found\n", use_shm ? "" : "not");
+
+    if(use_shm) {
+        int scr = XDefaultScreen(dpy);
+        image = XShmCreateImage(dpy,
+                                DefaultVisual(dpy, scr),
+                                DefaultDepth(dpy, scr),
+                                ZPixmap,
+                                NULL,
+                                &x11grab->shminfo,
+                                ap->width, ap->height);
+        x11grab->shminfo.shmid = shmget(IPC_PRIVATE,
+                                        image->bytes_per_line * image->height,
+                                        IPC_CREAT|0777);
+        if (x11grab->shminfo.shmid == -1) {
+            av_log(s1, AV_LOG_ERROR, "Fatal: Can't get shared memory!\n");
+            return -ENOMEM;
+        }
+        x11grab->shminfo.shmaddr = image->data = shmat(x11grab->shminfo.shmid, 0, 0);
+        x11grab->shminfo.readOnly = False;
+
+        if (!XShmAttach(dpy, &x11grab->shminfo)) {
+            av_log(s1, AV_LOG_ERROR, "Fatal: Failed to attach shared memory!\n");
+            /* needs some better error subroutine :) */
+            return AVERROR_IO;
+        }
+    } else {
+        image = XGetImage(dpy, RootWindow(dpy, DefaultScreen(dpy)),
+                          x_off,y_off,
+                          ap->width,ap->height,
+                          AllPlanes, ZPixmap);
+    }
+
+    switch (image->bits_per_pixel) {
+    case 8:
+        av_log (s1, AV_LOG_DEBUG, "8 bit pallete\n");
+        input_pixfmt = PIX_FMT_PAL8;
+        break;
+    case 16:
+        if (       image->red_mask   == 0xf800 &&
+                   image->green_mask == 0x07e0 &&
+                   image->blue_mask  == 0x001f ) {
+            av_log (s1, AV_LOG_DEBUG, "16 bit RGB565\n");
+            input_pixfmt = PIX_FMT_RGB565;
+        } else if (image->red_mask   == 0x7c00 &&
+                   image->green_mask == 0x03e0 &&
+                   image->blue_mask  == 0x001f ) {
+            av_log(s1, AV_LOG_DEBUG, "16 bit RGB555\n");
+            input_pixfmt = PIX_FMT_RGB555;
+        } else {
+            av_log(s1, AV_LOG_ERROR, "RGB ordering at image depth %i not supported ... aborting\n", image->bits_per_pixel);
+            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);
+            return AVERROR_IO;
+        }
+        break;
+    case 24:
+        if (        image->red_mask   == 0xff0000 &&
+                    image->green_mask == 0x00ff00 &&
+                    image->blue_mask  == 0x0000ff ) {
+            input_pixfmt = PIX_FMT_BGR24;
+        } else if ( image->red_mask   == 0x0000ff &&
+                    image->green_mask == 0x00ff00 &&
+                    image->blue_mask  == 0xff0000 ) {
+            input_pixfmt = PIX_FMT_RGB24;
+        } else {
+            av_log(s1, AV_LOG_ERROR,"rgb ordering at image depth %i not supported ... aborting\n", image->bits_per_pixel);
+            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);
+            return AVERROR_IO;
+        }
+        break;
+    case 32:
+#if 0
+        GetColorInfo (image, &c_info);
+        if ( c_info.alpha_mask == 0xff000000 && image->green_mask == 0x0000ff00) {
+            /* byte order is relevant here, not endianness
+             * endianness is handled by avcodec, but atm no such thing
+             * as having ABGR, instead of ARGB in a word. Since we
+             * need this for Solaris/SPARC, but need to do the conversion
+             * for every frame we do it outside of this loop, cf. below
+             * this matches both ARGB32 and ABGR32 */
+            input_pixfmt = PIX_FMT_ARGB32;
+        }  else {
+            av_log(s1, AV_LOG_ERROR,"image depth %i not supported ... aborting\n", image->bits_per_pixel);
+            return AVERROR_IO;
+        }
+#endif
+        input_pixfmt = PIX_FMT_RGBA32;
+        break;
+    default:
+        av_log(s1, AV_LOG_ERROR, "image depth %i not supported ... aborting\n", image->bits_per_pixel);
+        return -1;
+    }
+
+    x11grab->frame_size = ap->width * ap->height * image->bits_per_pixel/8;
+    x11grab->dpy = dpy;
+    x11grab->width = ap->width;
+    x11grab->height = ap->height;
+    x11grab->time_base  = ap->time_base;
+    x11grab->time_frame = av_gettime() / av_q2d(ap->time_base);
+    x11grab->x_off = x_off;
+    x11grab->y_off = y_off;
+    x11grab->image = image;
+    x11grab->use_shm = use_shm;
+
+    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_id = CODEC_ID_RAWVIDEO;
+    st->codec->width = ap->width;
+    st->codec->height = ap->height;
+    st->codec->pix_fmt = input_pixfmt;
+    st->codec->time_base = ap->time_base;
+    st->codec->bit_rate = x11grab->frame_size * 1/av_q2d(ap->time_base) * 8;
+
+    return 0;
+}
+
+/**
+ * Get pointer coordinates from X11.
+ *
+ * @param x Integer where horizontal coordinate will be returned
+ * @param y Integer where vertical coordinate will be returned
+ * @param dpy X11 display from where pointer coordinates are retrieved
+ * @param s1 Context used for logging errors if necessary
+ */
+static void
+get_pointer_coordinates(int *x, int *y, Display *dpy, AVFormatContext *s1)
+{
+    Window mrootwindow, childwindow;
+    int dummy;
+
+    mrootwindow = DefaultRootWindow(dpy);
+
+    if (XQueryPointer(dpy, mrootwindow, &mrootwindow, &childwindow,
+                      x, y, &dummy, &dummy, (unsigned int*)&dummy)) {
+    } else {
+        av_log(s1, AV_LOG_INFO, "couldn't find mouse pointer\n");
+        *x = -1;
+        *y = -1;
+    }
+}
+
+/**
+ * Mouse painting helper function that applies an 'and' and 'or' mask pair to
+ * '*dst' pixel. It actually draws a mouse pointer pixel to grabbed frame.
+ *
+ * @param dst Destination pixel
+ * @param and Part of the mask that must be applied using a bitwise 'and'
+ *            operator
+ * @param or  Part of the mask that must be applied using a bitwise 'or'
+ *            operator
+ * @param bits_per_pixel Bits per pixel used in the grabbed image
+ */
+static void inline
+apply_masks(uint8_t *dst, int and, int or, int bits_per_pixel)
+{
+    switch (bits_per_pixel) {
+    case 32:
+        *(uint32_t*)dst = (*(uint32_t*)dst & and) | or;
+        break;
+    case 16:
+        *(uint16_t*)dst = (*(uint16_t*)dst & and) | or;
+        break;
+    case 8:
+        *dst = !!or;
+        break;
+    }
+}
+
+/**
+ * Paints a mouse pointer in an X11 image.
+ *
+ * @param image Image where to paint the mouse pointer
+ * @param s context used to retrieve original grabbing rectangle
+ *          coordinates
+ * @param x Mouse pointer coordinate
+ * @param y Mouse pointer coordinate
+ */
+static void
+paint_mouse_pointer(XImage *image, x11_grab_t *s, int x, int y)
+{
+    /* 16x20x1bpp bitmap for the black channel of the mouse pointer */
+    static const uint16_t const mousePointerBlack[] =
+        {
+            0x0000, 0xc000, 0xa000, 0x9000, 0x8800,
+            0x8400, 0x8200, 0x8100, 0x8080, 0x8040,
+            0x83c0, 0x9200, 0xa900, 0xc900, 0x0480,
+            0x0480, 0x0240, 0x0240, 0x01c0, 0x0000
+        };
+
+    /* 16x20x1bpp bitmap for the white channel of the mouse pointer */
+    static const uint16_t const mousePointerWhite[] =
+        {
+            0x0000, 0x0000, 0x4000, 0x6000, 0x7000,
+            0x7800, 0x7c00, 0x7e00, 0x7f00, 0x7f80,
+            0x7c00, 0x6c00, 0x4600, 0x0600, 0x0300,
+            0x0300, 0x0180, 0x0180, 0x0000, 0x0000
+        };
+
+    int x_off = s->x_off;
+    int y_off = s->y_off;
+    int width = s->width;
+    int height = s->height;
+
+    if (   x - x_off >= 0 && x < width + x_off
+        && y - y_off >= 0 && y < height + y_off) {
+        uint8_t *im_data = (uint8_t*)image->data;
+        int bytes_per_pixel;
+        int line;
+        int masks;
+
+        /* Select correct masks and pixel size */
+        if (image->bits_per_pixel == 8) {
+            masks = 1;
+        } else {
+            masks = (image->red_mask|image->green_mask|image->blue_mask);
+        }
+        bytes_per_pixel = image->bits_per_pixel>>3;
+
+        /* Shift to right line */
+        im_data += image->bytes_per_line * (y - y_off);
+        /* Shift to right pixel in the line */
+        im_data += bytes_per_pixel * (x - x_off);
+
+        /* Draw the cursor - proper loop */
+        for (line = 0; line < FFMIN(20, (y_off + height) - y); line++) {
+            uint8_t *cursor = im_data;
+            int column;
+            uint16_t bm_b;
+            uint16_t bm_w;
+
+            bm_b = mousePointerBlack[line];
+            bm_w = mousePointerWhite[line];
+
+            for (column = 0; column < FFMIN(16, (x_off + width) - x); column++) {
+                apply_masks(cursor, ~(masks*(bm_b&1)), masks*(bm_w&1),
+                            image->bits_per_pixel);
+                cursor += bytes_per_pixel;
+                bm_b >>= 1;
+                bm_w >>= 1;
+            }
+            im_data += image->bytes_per_line;
+        }
+    }
+}
+
+
+/**
+ * Reads new data in the image structure.
+ *
+ * @param dpy X11 display to grab from
+ * @param d 
+ * @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
+ */
+static int
+xget_zpixmap(Display *dpy, Drawable d, XImage *image, int x, int y)
+{
+    xGetImageReply rep;
+    xGetImageReq *req;
+    long nbytes;
+
+    if (!image) {
+        return 0;
+    }
+
+    LockDisplay(dpy);
+    GetReq(GetImage, req);
+
+    /* First set up the standard stuff in the request */
+    req->drawable = d;
+    req->x = x;
+    req->y = y;
+    req->width = image->width;
+    req->height = image->height;
+    req->planeMask = (unsigned int)AllPlanes;
+    req->format = ZPixmap;
+
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.length) {
+        UnlockDisplay(dpy);
+        SyncHandle();
+        return 0;
+    }
+
+    nbytes = (long)rep.length << 2;
+    _XReadPad(dpy, image->data, nbytes);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return 1;
+}
+
+/**
+ * Grabs a frame from x11 (public device demuxer API).
+ *
+ * @param s1 Context from avformat core
+ * @param pkt Packet holding the brabbed frame
+ * @return frame size in bytes
+ */
+static int
+x11grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
+{
+    x11_grab_t *s = s1->priv_data;
+    Display *dpy = s->dpy;
+    XImage *image = s->image;
+    int x_off = s->x_off;
+    int y_off = s->y_off;
+
+    int64_t curtime, delay;
+    struct timespec ts;
+
+    /* Calculate the time of the next frame */
+    s->time_frame += int64_t_C(1000000);
+
+    /* wait based on the frame rate */
+    for(;;) {
+        curtime = av_gettime();
+        delay = s->time_frame * av_q2d(s->time_base) - curtime;
+        if (delay <= 0) {
+            if (delay < int64_t_C(-1000000) * av_q2d(s->time_base)) {
+                s->time_frame += int64_t_C(1000000);
+            }
+            break;
+        }
+        ts.tv_sec = delay / 1000000;
+        ts.tv_nsec = (delay % 1000000) * 1000;
+        nanosleep(&ts, NULL);
+    }
+
+    if (av_new_packet(pkt, s->frame_size) < 0) {
+        return AVERROR_IO;
+    }
+
+    pkt->pts = curtime;
+
+    if(s->use_shm) {
+        if (!XShmGetImage(dpy, RootWindow(dpy, DefaultScreen(dpy)), image, x_off, y_off, AllPlanes)) {
+            av_log (s1, AV_LOG_INFO, "XShmGetImage() failed\n");
+        }
+    } else {
+        if (!xget_zpixmap(dpy, RootWindow(dpy, DefaultScreen(dpy)), image, x_off, y_off)) {
+            av_log (s1, AV_LOG_INFO, "XGetZPixmap() failed\n");
+        }
+    }
+
+    {
+        int pointer_x, pointer_y;
+        get_pointer_coordinates(&pointer_x, &pointer_y, dpy, s1);
+        paint_mouse_pointer(image, s, pointer_x, pointer_y);
+    }
+
+
+    /* XXX: avoid memcpy */
+    memcpy(pkt->data, image->data, s->frame_size);
+    return s->frame_size;
+}
+
+/**
+ * Closes x11 frame grabber (public device demuxer API).
+ *
+ * @param s1 Context from avformat core
+ * @return 0 success, !0 failure
+ */
+static int
+x11grab_read_close(AVFormatContext *s1)
+{
+    x11_grab_t *x11grab = s1->priv_data;
+
+    /* 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;
+    }
+
+    /* Free X11 display */
+    XCloseDisplay(x11grab->dpy);
+    return 0;
+}
+
+/** x11 grabber device demuxer declaration */
+AVInputFormat x11_grab_device_demuxer =
+{
+    "x11grab",
+    "X11grab",
+    sizeof(x11_grab_t),
+    NULL,
+    x11grab_read_header,
+    x11grab_read_packet,
+    x11grab_read_close,
+    .flags = AVFMT_NOFILE,
+};

-- 
Edouard Gomez




More information about the ffmpeg-devel mailing list