Fastest way to perform a screenshot

Question

I would like to perform screenshots (or screen captures) the fastest possible.

Googling this question brings many answeers but my concern is more specific :

I am not interested in the image itself, I would like to grab in near real time the screen brightness, not the hardware one, but the image one, given that, for example, the firefox white google page gives a brighter image than a dark xterm (when both are maximzed).

To make me as clear as possible, here is one way I already managed to implement with X11 and CImg library :

Here is the header :

#include <CImg.h>
using namespace cimg_library;

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>

and the core part which extract an X11 image and make a loop on very pixel :

Display *display = XOpenDisplay(NULL);
Window root = DefaultRootWindow(display);

Screen* screen = DefaultScreenOfDisplay(display);

const int W = WidthOfScreen(screen);
const int H = HeightOfScreen(screen);

XImage *image = XGetImage(display, root, 0, 0, W, H, AllPlanes, ZPixmap);

unsigned long red_count(0), green_count(0), blue_count(0), count(0);

const unsigned long red_mask = image->red_mask;
const unsigned long green_mask = image->green_mask;
const unsigned long blue_mask = image->blue_mask;

CImg<unsigned char> screenshot(W, H, 1, 3, 0);

for (int x = 0; x < W; x += pixel_stride)
  for (int y = 0; y < H; y += pixel_stride)
    {
      unsigned long pixel = XGetPixel(image, x, y);

      screenshot(x, y, 0) = (pixel & red_mask) >> 16;
      screenshot(x, y, 1) = (pixel & green_mask) >> 8;
      screenshot(x, y, 2) = pixel & blue_mask;

      red_count += (int) screenshot(x, y, 0);
      green_count += (int) screenshot(x, y, 1);
      blue_count += (int) screenshot(x, y, 2);

      count++;
   }

As I said, I do not keep the image itself, I just try to compute an average luminance value with respective values of red, green and blue pixels.

XFree(image);

const double luminance_relative = (red_luminance * double(red_count) +
                                  green_luminance * double(green_count) +
                                  blue_luminance * double(blue_count))
    / (double(255) * double(count));

The underlying idea is to adjust the hardware screen brightness depending on the image luminance. In short, the whiter is the screenshot, the more the brightness can be reduced and conversely.

I want to do that because I have sensitive eyes, it usually hurts my eyes when I switch from xterm to firefox.

To do so, the hardware brightness must be adjusted in a very short time, the screenshot, that is to say, the loop on pixels must be as fast as possible.

I began to implement it with X11 methods, but I wonder if there could be faster access methods ? Which comes to the question : what is the fastest way/library to get a screenshot ?

Thanks in advance for your help.

Regards