Differential D5211 Diff 15479 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​ bool xshmAvail;
44​ XCBFrameBuffer *fb_owner;
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
45​};
46​
47​
48​
49​KrfbXCBEventFilter::KrfbXCBEventFilter(XCBFrameBuffer *owner):
50​ xdamageBaseEvent(0), xdamageBaseError(0),
51​ xshmBaseEvent(0), xshmBaseError(0), xshmAvail(false),
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 = true;
87​ xshmBaseEvent = xshm_data->first_event;
88​ xshmBaseError = xshm_data->first_error;
89​ } else {
90​ xshmAvail = false;
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 = false;
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 - uninstall x11 event filter
289​ QCoreApplication::instance()->removeNativeEventFilter(d->x11EvtFilter);
290​ //
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…
291​ if (d->framebufferImage) {
292​ xcb_image_destroy(d->framebufferImage);
293​ fb = Q_NULLPTR; // image data was already destroyed by above call
294​ }
295​ if (d->x11EvtFilter->xshmAvail) {
296​ // detach shared memory
297​ if (d->shminfo.shmseg != XCB_NONE)
298​ xcb_shm_detach(QX11Info::connection(), d->shminfo.shmseg); // detach from X server
299​ if (d->shminfo.shmaddr)
300​ shmdt(d->shminfo.shmaddr); // detach addr from our address space
301​ if (d->shminfo.shmid != XCB_NONE)
302​ shmctl(d->shminfo.shmid, IPC_RMID, 0); // mark shm segment as removed
303​ }
304​ // and delete image used for shared mem
305​ if (d->updateTile) {
306​ d->updateTile->base = NULL;
307​ d->updateTile->data = NULL;
308​ xcb_image_destroy(d->updateTile);
309​ }
310​ // we don't use d->x11EvtFilter anymore, can delete it now
311​ if (d->x11EvtFilter) {
312​ delete d->x11EvtFilter;
313​ }
314​ delete d;
315​}
316​
317​
318​int XCBFrameBuffer::depth() {
319​ if (d->framebufferImage) {
320​ return d->framebufferImage->depth;
321​ }
322​ return 0;
323​}
324​
325​
326​int XCBFrameBuffer::height() {
327​ if (d->framebufferImage) {
328​ return d->framebufferImage->height;
329​ }
330​ return 0;
331​}
332​
333​
334​int XCBFrameBuffer::width() {
335​ if (d->framebufferImage) {
336​ return d->framebufferImage->width;
337​ }
338​ return 0;
339​}
340​
341​int XCBFrameBuffer::paddedWidth() {
342​ if (d->framebufferImage) {
343​ return d->framebufferImage->stride;
344​ }
345​ return 0;
346​}
347​
348​
349​void XCBFrameBuffer::getServerFormat(rfbPixelFormat &format) {
350​ if (!d->framebufferImage) return;
351​
352​ // get information about XCB visual params
353​ xcb_visualtype_t *root_visualtype = NULL; // visual info
354​ if (d->rootScreen) {
355​ xcb_visualid_t root_visual = d->rootScreen->root_visual;
356​ xcb_depth_iterator_t depth_iter;
357​ // To get the xcb_visualtype_t structure, it's a bit less easy.
358​ // You have to get the xcb_screen_t structure that you want, get its
359​ // root_visual member, then iterate over the xcb_depth_t's and the
360​ // xcb_visualtype_t's, and compare the xcb_visualid_t of these
361​ // xcb_visualtype_ts: with root_visual
362​ depth_iter = xcb_screen_allowed_depths_iterator(d->rootScreen);
363​ for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
364​ xcb_visualtype_iterator_t visual_iter;
365​ visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
366​ for (; visual_iter.rem; xcb_visualtype_next(&visual_iter)) {
367​ if (root_visual == visual_iter.data->visual_id) {
368​ root_visualtype = visual_iter.data;
369​ break;
370​ }
371​ }
372​ }
373​ }
374​
375​
376​ // fill in format common info
377​ format.bitsPerPixel = d->framebufferImage->bpp;
378​ format.depth = d->framebufferImage->depth;
379​ format.trueColour = true; // not using color palettes
380​ format.bigEndian = false; // always false for ZPIXMAP format!
381​
382​ // information about pixels layout
383​
384​ if (root_visualtype) {
385​ uint16_t pixelmaxValue = (1 << root_visualtype->bits_per_rgb_value) - 1;
386​
adridgUnsubmitted
Done

Why not use qDebug()s here?

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