Differential D5211 Diff 12895 framebuffers/xcb/xcb_framebuffer.cpp

Changeset View

Standalone View

View Options

framebuffers/xcb/xcb_framebuffer.cpp

  • This file was added.
1​/* This file is part of the KDE project
2​ Copyright (C) 2017 Alexey Min <alexey.min@gmail.com>
3​
4​ This program is free software; you can redistribute it and/or
5​ modify it under the terms of the GNU General Public
6​ License as published by the Free Software Foundation; either
7​ version 2 of the License, or (at your option) any later version.
8​*/
9​
10​#include "xcb_framebuffer.h"
11​#include "xcb_framebuffer.moc"
12​
13​#include <xcb/xcb.h>
14​#include <xcb/xproto.h>
15​#include <xcb/damage.h>
16​#include <xcb/shm.h>
17​#include <xcb/xcb_image.h>
18​
19​#include <sys/ipc.h>
20​#include <sys/shm.h>
21​
22​#include <QX11Info>
23​#include <QCoreApplication>
24​#include <QGuiApplication>
25​#include <QScreen>
26​#include <QAbstractNativeEventFilter>
27​#include <QDebug>
28​
29​
30​class KrfbXCBEventFilter: public QAbstractNativeEventFilter
31​{
32​public:
33​ KrfbXCBEventFilter(XCBFrameBuffer *owner);
34​
35​public:
36​ virtual bool nativeEventFilter(const QByteArray &eventType, void *message, long *result);
37​
38​public:
39​ int xdamageBaseEvent;
40​ int xdamageBaseError;
41​ int xshmBaseEvent;
42​ int xshmBaseError;
43​ int xshmAvail;
adridgUnsubmitted
Done

Perhaps a bool, since it only seems to be set to 0 or 1

adridg: Perhaps a bool, since it only seems to be set to 0 or 1
44​ XCBFrameBuffer *fb_owner;
45​};
46​
47​
48​
49​KrfbXCBEventFilter::KrfbXCBEventFilter(XCBFrameBuffer *owner):
50​ xdamageBaseEvent(0), xdamageBaseError(0),
51​ xshmBaseEvent(0), xshmBaseError(0), xshmAvail(0),
52​ fb_owner(owner)
53​{
54​ const xcb_query_extension_reply_t *xdamage_data = xcb_get_extension_data(
55​ QX11Info::connection(), &xcb_damage_id);
56​ if (xdamage_data) {
57​ // also query extension version!
58​ // ATTENTION: if we don't do that, xcb_damage_create() will always FAIL!
59​ xcb_damage_query_version_reply_t *xdamage_version = xcb_damage_query_version_reply(
60​ QX11Info::connection(),
61​ xcb_damage_query_version(
62​ QX11Info::connection(),
63​ XCB_DAMAGE_MAJOR_VERSION,
64​ XCB_DAMAGE_MINOR_VERSION),
65​ NULL);
66​ if (!xdamage_version) {
67​ qWarning() << "xcb framebuffer: ERROR: Failed to get XDamage extension version!\n";
68​ return;
69​ }
70​
71​#ifdef _DEBUG
72​ qDebug() << "xcb framebuffer: XDamage extension version:" <<
73​ xdamage_version->major_version << "." << xdamage_version->minor_version;
74​#endif
75​
76​ free(xdamage_version);
77​
78​ xdamageBaseEvent = xdamage_data->first_event;
79​ xdamageBaseError = xdamage_data->first_error;
80​
81​ // XShm presence is optional. If it is present, all image getting
82​ // operations will be faster, without XShm it will only be slower.
83​ const xcb_query_extension_reply_t *xshm_data = xcb_get_extension_data(
84​ QX11Info::connection(), &xcb_shm_id);
85​ if (xshm_data) {
86​ xshmAvail = 1;
87​ xshmBaseEvent = xshm_data->first_event;
88​ xshmBaseError = xshm_data->first_error;
89​ } else {
90​ xshmAvail = 0;
91​ qWarning() << "xcb framebuffer: WARNING: XSHM extension not available!";
92​ }
93​ } else {
94​ // if there is no xdamage available, this plugin can be considered useless anyway.
95​ // you can use just qt framebuffer plugin instead...
96​ qWarning() << "xcb framebuffer: ERROR: no XDamage extension available. I am useless.";
97​ qWarning() << "xcb framebuffer: use qt framebuffer plugin instead.";
98​ }
99​}
100​
101​
102​bool KrfbXCBEventFilter::nativeEventFilter(const QByteArray &eventType,
103​ void *message, long *result) {
104​ Q_UNUSED(result); // "result" is only used on windows
105​
106​ if (xdamageBaseEvent == 0) return false; // no xdamage extension
107​
108​ if (eventType == "xcb_generic_event_t") {
109​ xcb_generic_event_t* ev = static_cast<xcb_generic_event_t *>(message);
110​ if ((ev->response_type & 0x7F) == (xdamageBaseEvent + XCB_DAMAGE_NOTIFY)) {
111​ // this is xdamage notification
112​ this->fb_owner->handleXDamageNotify(ev);
113​ return true; // filter out this event, stop its processing
114​ }
115​ }
116​
117​ // continue event processing
118​ return false;
119​}
120​
121​
122​class XCBFrameBuffer::P {
123​public:
124​ xcb_damage_damage_t damage;
125​ xcb_shm_segment_info_t shminfo;
126​ xcb_screen_t *rootScreen; // X screen info (all monitors)
127​ xcb_image_t *framebufferImage;
128​ xcb_image_t *updateTile;
129​
130​ KrfbXCBEventFilter *x11EvtFilter;
131​
132​ bool running;
133​
134​ QRect area; // capture area, primary monitor coordinates
135​};
136​
137​
138​static xcb_screen_t *get_xcb_screen(xcb_connection_t *conn, int screen_num) {
139​ xcb_screen_t *screen = NULL;
140​ xcb_screen_iterator_t screens_iter = xcb_setup_roots_iterator(xcb_get_setup(conn));
141​ for (; screens_iter.rem; --screen_num, xcb_screen_next(&screens_iter))
142​ if (screen_num == 0)
143​ screen = screens_iter.data;
144​ return screen;
145​}
146​
147​
148​
149​XCBFrameBuffer::XCBFrameBuffer(WId winid, QObject *parent):
150​ FrameBuffer(winid, parent), d(new XCBFrameBuffer::P)
151​{
152​ d->running = false;
153​ d->damage = XCB_NONE;
154​ d->framebufferImage = Q_NULLPTR;
155​ d->shminfo.shmaddr = Q_NULLPTR;
156​ d->shminfo.shmid = XCB_NONE;
157​ d->shminfo.shmseg = XCB_NONE;
158​ d->updateTile = Q_NULLPTR;
159​ d->area.setRect(0, 0, 0, 0);
160​ d->x11EvtFilter = new KrfbXCBEventFilter(this);
161​ d->rootScreen = get_xcb_screen(QX11Info::connection(), QX11Info::appScreen());
162​
163​ this->fb = Q_NULLPTR;
164​
165​ QScreen *primaryScreen = QGuiApplication::primaryScreen();
166​ if (primaryScreen) {
167​ qDebug() << "xcb framebuffer: Primary screen: " << primaryScreen->name()
168​ << ", geometry: " << primaryScreen->geometry()
169​ << ", depth: " << primaryScreen->depth();
170​ //
171​ d->area = primaryScreen->geometry();
172​ } else {
173​ qWarning() << "xcb framebuffer: ERROR: Failed to get application's primary screen info!";
174​ return;
175​ }
176​
177​ d->framebufferImage = xcb_image_get(QX11Info::connection(),
178​ this->win,
179​ d->area.left(),
180​ d->area.top(),
181​ d->area.width(),
182​ d->area.height(),
183​ 0xFFFFFFFF, // == Xlib: AllPlanes ((unsigned long)~0L)
184​ XCB_IMAGE_FORMAT_Z_PIXMAP);
185​ if (d->framebufferImage) {
186​#ifdef _DEBUG
187​ qDebug() << "xcb framebuffer: Got primary screen image. bpp: " << d->framebufferImage->bpp
188​ << ", size (" << d->framebufferImage->width << d->framebufferImage->height << ")"
189​ << ", depth: " << d->framebufferImage->depth
190​ << ", padded width: " << d->framebufferImage->stride;
191​#endif
192​ this->fb = (char *)d->framebufferImage->data;
193​ } else {
194​ qWarning() << "xcb framebuffer: ERROR: Failed to get primary screen image!";
195​ return;
196​ }
197​
198​ // all XShm operations should take place only if Xshm extension was loaded
199​ if (d->x11EvtFilter->xshmAvail) {
200​ // Create xcb_image_t structure, but do not automatically allocate memory
201​ // for image data storage - it will be allocated as shared memory.
202​ // "If base == 0 and bytes == ~0 and data == 0, no storage will be auto-allocated."
203​ // Width and height of the image = size of the capture area.
204​ d->updateTile = xcb_image_create_native(
205​ QX11Info::connection(),
206​ d->area.width(), // width
207​ d->area.height(), // height
208​ XCB_IMAGE_FORMAT_Z_PIXMAP, // image format
209​ d->rootScreen->root_depth, // depth
210​ NULL, // base address = 0
211​ (uint32_t)~0, // bytes = 0xffffffff
212​ NULL); // data = 0
213​ if (d->updateTile) {
214​#ifdef _DEBUG
215​ qDebug() << "xcb framebuffer: Successfully created new empty image in native format";
216​ qDebug() << " size: " << d->updateTile->width << "x" << d->updateTile->height
217​ << "(stride: " << d->updateTile->stride << ")";
218​ qDebug() << " bpp, depth: " << d->updateTile->bpp << d->updateTile->depth; // 32, 24
219​ qDebug() << " addr of base, data: " << d->updateTile->base << (void *)d->updateTile->data;
220​ qDebug() << " size: " << d->updateTile->size;
221​ qDebug() << " image byte order = " << d->updateTile->byte_order; // == 0 .._LSB_FIRST
222​ qDebug() << " image bit order = " << d->updateTile->bit_order; // == 1 .._MSB_FIRST
223​ qDebug() << " image plane_mask = " << d->updateTile->plane_mask; // == 16777215 == 0x00FFFFFF
224​#endif
225​
226​ // allocate shared memory block only once, make its size large enough
227​ // to fit whole capture area (d->area rect)
228​ // so, we get as many bytes as needed for image (updateTile->size)
229​ d->shminfo.shmid = shmget(IPC_PRIVATE, d->updateTile->size, IPC_CREAT | 0777);
230​ // attached shared memory address is stored both in shminfo structure and in xcb_image_t->data
231​ d->shminfo.shmaddr = (uint8_t *)shmat(d->shminfo.shmid, NULL, 0);
232​ d->updateTile->data = d->shminfo.shmaddr;
233​ // we keep updateTile->base == NULL here, so xcb_image_destroy() will not attempt
234​ // to free this block, just in case.
235​
236​ // attach this shm segment also to X server
237​ d->shminfo.shmseg = xcb_generate_id(QX11Info::connection());
238​ xcb_shm_attach(QX11Info::connection(), d->shminfo.shmseg, d->shminfo.shmid, 0);
239​
240​#ifdef _DEBUG
241​ qDebug() << " shm id: " << d->shminfo.shmseg << ", addr: " << (void *)d->shminfo.shmaddr;
242​#endif
243​
244​ // will return 1 on success (yes!)
245​ int shmget_res = xcb_image_shm_get(
246​ QX11Info::connection(),
247​ this->win,
248​ d->updateTile,
249​ d->shminfo,
250​ d->area.left(), // x
251​ d->area.top(), // y (size taken from image structure itself)?
252​ 0xFFFFFFFF);
253​
254​ if (shmget_res == 0) {
255​ // error! shared mem not working?
256​ // will not use shared mem! detach and cleanup
257​ xcb_shm_detach(QX11Info::connection(), d->shminfo.shmseg);
258​ shmdt(d->shminfo.shmaddr);
259​ shmctl(d->shminfo.shmid, IPC_RMID, 0); // mark shm segment as removed
260​ d->x11EvtFilter->xshmAvail = 0;
261​ d->shminfo.shmaddr = Q_NULLPTR;
262​ d->shminfo.shmid = XCB_NONE;
263​ d->shminfo.shmseg = XCB_NONE;
264​ qWarning() << "xcb framebuffer: ERROR: xcb_image_shm_get() result: " << shmget_res;
265​ }
266​
267​ // image is freed, and recreated again for every new damage rectangle
268​ // data was allocated manually and points to shared mem;
269​ // tell xcb_image_destroy() do not free image data
270​ d->updateTile->data = NULL;
271​ xcb_image_destroy(d->updateTile);
272​ d->updateTile = NULL;
273​ }
274​ }
275​
276​#ifdef _DEBUG
277​ qDebug() << "xcb framebuffer: XCBFrameBuffer(), xshm base event = " << d->x11EvtFilter->xshmBaseEvent
278​ << ", xshm base error = " << d->x11EvtFilter->xdamageBaseError
279​ << ", xdamage base event = " << d->x11EvtFilter->xdamageBaseEvent
280​ << ", xdamage base error = " << d->x11EvtFilter->xdamageBaseError;
281​#endif
282​
283​ QCoreApplication::instance()->installNativeEventFilter(d->x11EvtFilter);
284​}
285​
286​
287​XCBFrameBuffer::~XCBFrameBuffer() {
288​ // first - remove x11 event filter
289​ if (d->x11EvtFilter)
adridgUnsubmitted
Done

Please add { } even to single-statement if()s, to be consistent with e.g. line 316 in XCBFrameBuffer::depth()

adridg: Please add { } even to single-statement if()s, to be consistent with e.g. line 316 in…
290​ // this also removes itself from QApplication event filters
291​ delete d->x11EvtFilter;
292​ //
293​ if (d->framebufferImage) {
294​ xcb_image_destroy(d->framebufferImage);
295​ fb = Q_NULLPTR; // image data was already destroyed by above call
296​ }
297​ if (d->x11EvtFilter->xshmAvail) {
298​ // detach shared memory
299​ if (d->shminfo.shmseg != XCB_NONE)
300​ xcb_shm_detach(QX11Info::connection(), d->shminfo.shmseg); // detach from X server
301​ if (d->shminfo.shmaddr)
302​ shmdt(d->shminfo.shmaddr); // detach addr from our address space
303​ if (d->shminfo.shmid != XCB_NONE)
304​ shmctl(d->shminfo.shmid, IPC_RMID, 0); // mark shm segment as removed
305​ }
306​ // and delete image used for shared mem
307​ if (d->updateTile) {
308​ d->updateTile->base = NULL;
309​ d->updateTile->data = NULL;
310​ xcb_image_destroy(d->updateTile);
311​ }
312​ delete d;
313​}
314​
315​
316​int XCBFrameBuffer::depth() {
317​ if (d->framebufferImage) {
318​ return d->framebufferImage->depth;
319​ }
320​ return 0;
321​}
322​
323​
324​int XCBFrameBuffer::height() {
325​ if (d->framebufferImage) {
326​ return d->framebufferImage->height;
327​ }
328​ return 0;
329​}
330​
331​
332​int XCBFrameBuffer::width() {
333​ if (d->framebufferImage) {
334​ return d->framebufferImage->width;
335​ }
336​ return 0;
337​}
338​
339​int XCBFrameBuffer::paddedWidth() {
340​ if (d->framebufferImage) {
341​ return d->framebufferImage->stride;
342​ }
343​ return 0;
344​}
345​
346​
347​void XCBFrameBuffer::getServerFormat(rfbPixelFormat &format) {
348​ if (!d->framebufferImage) return;
349​
350​ // get information about XCB visual params
351​ xcb_visualtype_t *root_visualtype = NULL; // visual info
352​ if (d->rootScreen) {
353​ xcb_visualid_t root_visual = d->rootScreen->root_visual;
354​ xcb_depth_iterator_t depth_iter;
355​ // To get the xcb_visualtype_t structure, it's a bit less easy.
356​ // You have to get the xcb_screen_t structure that you want, get its
357​ // root_visual member, then iterate over the xcb_depth_t's and the
358​ // xcb_visualtype_t's, and compare the xcb_visualid_t of these
359​ // xcb_visualtype_ts: with root_visual
360​ depth_iter = xcb_screen_allowed_depths_iterator(d->rootScreen);
361​ for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
362​ xcb_visualtype_iterator_t visual_iter;
363​ visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
364​ for (; visual_iter.rem; xcb_visualtype_next(&visual_iter)) {
365​ if (root_visual == visual_iter.data->visual_id) {
366​ root_visualtype = visual_iter.data;
367​ break;
368​ }
369​ }
370​ }
371​ }
372​
373​
374​ // fill in format common info
375​ format.bitsPerPixel = d->framebufferImage->bpp;
376​ format.depth = d->framebufferImage->depth;
377​ format.trueColour = true; // not using color palettes
378​ format.bigEndian = false; // always false for ZPIXMAP format!
379​
380​ // information about pixels layout
381​
382​ if (root_visualtype) {
383​ uint16_t pixelmaxValue = (1 << root_visualtype->bits_per_rgb_value) - 1;
384​
385​#ifdef _DEBUG
adridgUnsubmitted
Done

Why not use qDebug()s here?

adridg: Why not use qDebug()s here?
386​ printf("xcb framebuffer: Got info about root visual:\n"
387​ " bits per rgb value: %d\n"
388​ " red mask: %08x\n"
389​ " green mask: %08x\n"
390​ " blue mask: %08x\n"
391​ " pixelMaxValue = %d\n",
392​ (int)root_visualtype->bits_per_rgb_value,
393​ root_visualtype->red_mask,
394​ root_visualtype->green_mask,
395​ root_visualtype->blue_mask,
396​ (int)pixelmaxValue);
397​#endif
398​
399​ // calculate shifts
400​ format.redShift = 0;
401​ format.redMax = pixelmaxValue;
402​ if (root_visualtype->red_mask) {
403​ while (!(root_visualtype->red_mask & (1 << format.redShift))) {
404​ format.redShift++;
405​ }
406​ }
407​ format.greenShift = 0;
408​ format.greenMax = pixelmaxValue;
409​ if (root_visualtype->green_mask) {
410​ while (!(root_visualtype->green_mask & (1 << format.greenShift))) {
411​ format.greenShift++;
412​ }
413​ }
414​ format.blueShift = 0;
415​ format.blueMax = pixelmaxValue;
416​ if (root_visualtype->blue_mask) {
417​ while (!(root_visualtype->blue_mask & (1 << format.blueShift))) {
418​ format.blueShift++;
419​ }
420​ }
421​
422​#ifdef _DEBUG
423​ printf(" Calculated redShift = %d\n", (int)format.redShift);
424​ printf(" Calculated greenShift = %d\n", (int)format.greenShift);
425​ printf(" Calculated blueShift = %d\n", (int)format.blueShift);
426​#endif
427​ } else {
428​ // some kind of fallback (unlikely code execution will go this way)
429​ // idea taken from qt framefuffer sources
430​ if (format.bitsPerPixel == 8) {
431​ format.redShift = 0;
432​ format.greenShift = 3;
433​ format.blueShift = 6;
434​ format.redMax = 7;
435​ format.greenMax = 7;
436​ format.blueMax = 3;
437​ } else if (format.bitsPerPixel == 16) {
438​ // TODO: 16 bits per pixel format ??
439​ // what format of pixels X server uses for 16-bpp?
440​ } else if (format.bitsPerPixel == 32) {
441​ format.redMax = 0xff;
442​ format.greenMax = 0xff;
443​ format.blueMax = 0xff;
444​ if (format.bigEndian) {
445​ format.redShift = 0;
446​ format.greenShift = 8;
447​ format.blueShift = 16;
448​ } else {
449​ format.redShift = 16;
450​ format.greenShift = 8;
451​ format.blueShift = 0;
452​ }
453​ }
454​ }
455​}
456​
457​
458​/**
459​ * This function contents was taken from X11 framebuffer source code.
460​ * It simply several intersecting rectangles into one bigger rect.
461​ * Non-intersecting rects are treated as different rects and exist
462​ * separately in this->tiles QList.
463​ */
464​void XCBFrameBuffer::cleanupRects() {
465​ QList<QRect> cpy = tiles;
466​ bool inserted = false;
467​ tiles.clear();
468​
469​ QListIterator<QRect> iter(cpy);
470​ while (iter.hasNext()) {
471​ const QRect &r = iter.next();
472​ // skip rects not intersecting with primary monitor
473​ if (!r.intersects(d->area)) continue;
474​ // only take intersection of this rect with primary monitor rect
475​ QRect ri = r.intersected(d->area);
476​
477​ if (tiles.size() > 0) {
478​ for (int i = 0; i < tiles.size(); i++) {
479​ // if current rect has intersection with tiles[i], unite them
480​ if (ri.intersects(tiles[i])) {
481​ tiles[i] |= ri;
482​ inserted = true;
483​ break;
484​ }
485​ }
486​
487​ if (!inserted) {
488​ // else, append to list as different rect
489​ tiles.append(ri);
490​ }
491​ } else {
492​ // tiles list is empty, append first item
493​ tiles.append(ri);
494​ }
495​ }
496​
497​ // increase all rectangles size by 30 pixels each side.
498​ // limit coordinates to primary monitor boundaries.
499​ for (int i = 0; i < tiles.size(); i++) {
500​ tiles[i].adjust(-30, -30, 30, 30);
501​ if (tiles[i].top() < d->area.top()) {
502​ tiles[i].setTop(d->area.top());
503​ }
504​ if (tiles[i].bottom() > d->area.bottom()) {
505​ tiles[i].setBottom(d->area.bottom());
506​ }
507​ //
508​ if (tiles[i].left() < d->area.left()) {
509​ tiles[i].setLeft(d->area.left());
510​ }
511​ if (tiles[i].right() > d->area.right()) {
512​ tiles[i].setRight(d->area.right());
513​ }
514​ // move update rects so that they are positioned relative to
515​ // framebuffer image, not whole screen
516​ tiles[i].moveTo(tiles[i].left() - d->area.left(),
517​ tiles[i].top() - d->area.top());
518​ }
519​}
520​
521​
522​/**
523​ * This function is called by RfbServerManager::updateScreens()
524​ * approximately every 50ms (!!), driven by QTimer to get all
525​ * modified rectangles on the screen
526​ */
527​QList<QRect> XCBFrameBuffer::modifiedTiles() {
528​ QList<QRect> ret;
529​ if (!d->running) {
530​ return ret;
531​ }
532​
533​ cleanupRects();
534​
535​ if (tiles.size() > 0) {
536​ if (d->x11EvtFilter->xshmAvail) {
537​
538​ // loop over all damage rectangles gathered up to this time
539​ QListIterator<QRect> iter(tiles);
540​ //foreach(const QRect &r, tiles) {
541​ while (iter.hasNext()) {
542​ const QRect &r = iter.next();
543​
544​ // get image data into shared memory segment
545​ // now rects are positioned relative to framebufferImage,
546​ // but we need to get image from the whole screen, so
547​ // translate whe coordinates
548​ xcb_shm_get_image_cookie_t sgi_cookie = xcb_shm_get_image(
549​ QX11Info::connection(),
550​ this->win,
551​ d->area.left() + r.left(),
552​ d->area.top() + r.top(),
553​ r.width(),
554​ r.height(),
555​ 0xFFFFFFFF,
556​ XCB_IMAGE_FORMAT_Z_PIXMAP,
557​ d->shminfo.shmseg,
558​ 0);
559​
560​ xcb_shm_get_image_reply_t *sgi_reply = xcb_shm_get_image_reply(
561​ QX11Info::connection(), sgi_cookie, NULL);
562​ if (sgi_reply) {
563​ // create temporary image to get update rect contents into
564​ d->updateTile = xcb_image_create_native(
565​ QX11Info::connection(),
566​ r.width(),
567​ r.height(),
568​ XCB_IMAGE_FORMAT_Z_PIXMAP,
569​ d->rootScreen->root_depth,
570​ NULL, // base == 0
571​ (uint32_t)~0, // bytes == ~0
572​ NULL);
573​
574​ if (d->updateTile) {
575​ d->updateTile->data = d->shminfo.shmaddr;
576​
577​ // copy pixels from this damage rectangle image
578​ // to our total framebuffer image
579​ int pxsize = d->framebufferImage->bpp / 8;
580​ char *dest = fb + ((d->framebufferImage->stride * r.top()) + (r.left() * pxsize));
581​ char *src = (char *)d->updateTile->data;
582​ for (int i = 0; i < d->updateTile->height; i++) {
583​ memcpy(dest, src, d->updateTile->stride); // copy whole row of pixels
584​ dest += d->framebufferImage->stride;
585​ src += d->updateTile->stride;
586​ }
587​
588​ // delete temporary image
589​ d->updateTile->data = NULL;
590​ xcb_image_destroy(d->updateTile);
591​ d->updateTile = NULL;
592​ }
593​
594​ free(sgi_reply);
595​ }
596​ } // foreach
597​ } else {
598​ // not using shared memory
599​ // will use just xcb_image_get() and copy pixels
600​ foreach(const QRect &r, tiles) {
601​ // I did not find XGetSubImage() analog in XCB!!
602​ // need function that copies pixels from one image to another
603​ xcb_image_t *damagedImage = xcb_image_get(
604​ QX11Info::connection(),
605​ this->win,
606​ r.left(),
607​ r.top(),
608​ r.width(),
609​ r.height(),
610​ 0xFFFFFFFF, // AllPlanes
611​ XCB_IMAGE_FORMAT_Z_PIXMAP);
612​ // manually copy pixels
613​ int pxsize = d->framebufferImage->bpp / 8;
614​ char *dest = fb + ((d->framebufferImage->stride * r.top()) + (r.left() * pxsize));
615​ char *src = (char *)damagedImage->data;
616​ // loop every row in damaged image
617​ for (int i = 0; i < damagedImage->height; i++) {
618​ // copy whole row of pixels from src image to dest
619​ memcpy(dest, src, damagedImage->stride);
620​ dest += d->framebufferImage->stride; // move 1 row down in dest
621​ src += damagedImage->stride; // move 1 row down in src
622​ }
623​ //
624​ xcb_image_destroy(damagedImage);
625​ }
626​ }
627​ } // if (tiles.size() > 0)
628​
629​ ret = tiles;
630​ tiles.clear();
631​ // ^^ If we clear here all our known "damage areas", then we can also clear
632​ // damaged area for xdamage? No, we don't need to in our case
633​ // (XCB_DAMAGE_REPORT_LEVEL_RAW_RECTANGLES report mode)
634​ //xcb_damage_subtract(QX11Info::connection(), d->damage, XCB_NONE, XCB_NONE);
635​
636​ return ret;
637​}
638​
639​
640​void XCBFrameBuffer::startMonitor() {
641​ if (d->running) return;
642​
643​ d->running = true;
644​ d->damage = xcb_generate_id(QX11Info::connection());
645​ xcb_damage_create(QX11Info::connection(), d->damage, this->win,
646​ XCB_DAMAGE_REPORT_LEVEL_RAW_RECTANGLES);
647​
648​ // (currently) we do not call xcb_damage_subtract() EVER, because
649​ // RAW rectangles are reported. every time some area of the screen
650​ // was changed, we get only that rectangle
651​ //xcb_damage_subtract(QX11Info::connection(), d->damage, XCB_NONE, XCB_NONE);
652​}
653​
654​
655​void XCBFrameBuffer::stopMonitor() {
656​ if (!d->running) return;
657​ d->running = false;
658​ xcb_damage_destroy(QX11Info::connection(), d->damage);
659​}
660​
661​
662​// void XCBFrameBuffer::acquireEvents() {} // this function was totally unused
663​// in X11 framebuffer, but it was the only function where XDamageSubtract() was called?
664​// Also it had a blocking event loop like:
665​//
666​// XEvent ev;
667​// while (XCheckTypedEvent(QX11Info::display(), d->xdamageBaseEvent + XDamageNotify, &ev)) {
668​// handleXDamage(&ev);
669​// }
670​// XDamageSubtract(QX11Info::display(), d->damage, None, None);
671​//
672​// This loop takes all available Xdamage events from queue, and ends if there are no
673​// more such events in input queue.
674​
675​
676​void XCBFrameBuffer::handleXDamageNotify(xcb_generic_event_t *xevent) {
677​ xcb_damage_notify_event_t *xdevt = (xcb_damage_notify_event_t *)xevent;
678​
679​ QRect r((int)xdevt->area.x, (int)xdevt->area.y,
680​ (int)xdevt->area.width, (int)xdevt->area.height);
681​ this->tiles.append(r);
682​}
683​