Implemented the X11-grabber (based on v4l code).

Author: tvdzwan

src/hyperion-x11/CMakeLists.txt

@@ -10,42 +10,55 @@ find_package(Protobuf REQUIRED)
 # find Qt4
 find_package(Qt4 REQUIRED QtCore QtGui QtNetwork)
 
+# Find X11
+find_package(X11 REQUIRED)
+
 include_directories(
 	${CMAKE_CURRENT_BINARY_DIR}
 	${PROTOBUF_INCLUDE_DIRS}
 	${QT_INCLUDES}
+	${X11_INCLUDES}
 )
 
+set(Hyperion_X11_QT_HEADERS
+	ProtoWrapper.h
+	X11Wrapper.h)
+
 set(Hyperion_X11_HEADERS
 	X11Grabber.h
 	../hyperion-v4l2/ProtoConnection.h
 )
 
 set(Hyperion_X11_SOURCES
+	hyperion-x11.cpp
+	ProtoWrapper.cpp
 	X11Grabber.cpp
+	X11Wrapper.cpp
 	../hyperion-v4l2/ProtoConnection.cpp
 )
 
 set(Hyperion_X11_PROTOS
 	${CMAKE_CURRENT_SOURCE_DIR}/../../libsrc/protoserver/message.proto
 )
 
-protobuf_generate_cpp(Hyperion_X11_PROTO_SRCS Hyperion_X11_PROTO_HDRS
-	${Hyperion_X11_PROTOS}
-)
+QT4_WRAP_CPP(Hyperion_X11_HEADERS_MOC ${Hyperion_X11_QT_HEADERS})
+
+protobuf_generate_cpp(Hyperion_X11_PROTO_SRCS Hyperion_X11_PROTO_HDRS ${Hyperion_X11_PROTOS})
 
 add_executable(hyperion-x11
 	${Hyperion_X11_HEADERS}
 	${Hyperion_X11_SOURCES}
 	${Hyperion_X11_PROTO_SRCS}
 	${Hyperion_X11_PROTO_HDRS}
+	${Hyperion_X11_HEADERS_MOC}
 )
 
 target_link_libraries(hyperion-x11
 	getoptPlusPlus
 	blackborder
 	hyperion-utils
 	${PROTOBUF_LIBRARIES}
+	${X11_LIBRARIES}
 	pthread
 )
 

src/hyperion-x11/ProtoWrapper.cpp

@@ -0,0 +1,17 @@
+
+//
+#include "ProtoWrapper.h"
+
+ProtoWrapper::ProtoWrapper(const std::string & protoAddress, const bool skipReply) :
+	_priority(200),
+	_duration_ms(2000),
+	_connection(protoAddress)
+{
+	_connection.setSkipReply(skipReply);
+}
+
+void ProtoWrapper::process(const Image<ColorRgb> & image)
+{
+	std::cout << "Attempt to send screenshot" << std::endl;
+	_connection.setImage(image, _priority, _duration_ms);
+}

src/hyperion-x11/ProtoWrapper.h

@@ -0,0 +1,23 @@
+
+// QT includes
+#include <QObject>
+
+
+#include "../hyperion-v4l2/ProtoConnection.h"
+
+class ProtoWrapper : public QObject
+{
+	Q_OBJECT
+public:
+	ProtoWrapper(const std::string & protoAddress, const bool skipReply);
+
+public slots:
+	void process(const Image<ColorRgb> & image);
+
+private:
+
+	int _priority;
+	int _duration_ms;
+
+	ProtoConnection _connection;
+};

src/hyperion-x11/X11Grabber.cpp

@@ -1,14 +1,115 @@
+// STL includes
+#include <iostream>
+#include <cstdint>
 
-#include <X11/Xlib.h>
+// X11 includes
+#include <X11/Xutil.h>
 
-int main(int argc, char ** argv)
+// X11Grabber includes
+#include "X11Grabber.h"
+
+X11Grabber::X11Grabber(const unsigned cropHorizontal, const unsigned cropVertical, const unsigned pixelDecimation) :
+	_pixelDecimation(pixelDecimation),
+	_cropWidth(cropHorizontal),
+	_cropHeight(cropVertical),
+	_x11Display(nullptr),
+	_screenWidth(0),
+	_screenHeight(0),
+	_image(0,0)
+{
+	// empty
+}
+
+X11Grabber::~X11Grabber()
+{
+	if (_x11Display != nullptr)
+	{
+		XCloseDisplay(_x11Display);
+	}
+}
+
+int X11Grabber::open()
+{
+	const char * display_name = nullptr;
+	_x11Display = XOpenDisplay(display_name);
+
+	if (_x11Display == nullptr)
+	{
+		std::cerr << "Failed to open the default X11-display" << std::endl;
+		return -1;
+	}
+
+	return 0;
+}
+
+Image<ColorRgb> & X11Grabber::grab()
 {
-	Display * dspl;
-	Drawable drwbl;
-	int x = 0;
-	int y = 0;
-	int width = 0;
-	int height = 0;
+	if (_x11Display == nullptr)
+	{
+		open();
+	}
+
+	updateScreenDimensions();
+
+	const int croppedWidth  = _screenWidth  - 2*_cropWidth;
+	const int croppedHeight = _screenHeight - 2*_cropHeight;
+
+	// Capture the current screen
+	XImage * xImage = XGetImage(_x11Display, DefaultRootWindow(_x11Display), _cropWidth, _cropHeight, croppedWidth, croppedHeight, AllPlanes, ZPixmap);
+	if (xImage == nullptr)
+	{
+		std::cerr << "Grab failed" << std::endl;
+		return _image;
+	}
+
+	// Copy the capture XImage to the local image (and apply required decimation)
+	ColorRgb * outputPtr = _image.memptr();
+	for (int iY=(_pixelDecimation/2); iY<croppedHeight; iY+=_pixelDecimation)
+	{
+		for (int iX=(_pixelDecimation/2); iX<croppedWidth; iX+=_pixelDecimation)
+		{
+			// Extract the pixel from the X11-image
+			const uint32_t pixel = uint32_t(XGetPixel(xImage, iX, iY));
+
+			// Assign the color value
+			outputPtr->red   = uint8_t((pixel >> 16) & 0xff);
+			outputPtr->green = uint8_t((pixel >> 8)  & 0xff);
+			outputPtr->blue  = uint8_t((pixel >> 0)  & 0xff);
+
+			// Move to the next output pixel
+			++outputPtr;
+		}
+	}
+	// Cleanup allocated resources of the X11 grab
+	XDestroyImage(xImage);
+
+	return _image;
+}
+
+int X11Grabber::updateScreenDimensions()
+{
+	XWindowAttributes window_attributes_return;
+	const Status status = XGetWindowAttributes(_x11Display, DefaultRootWindow(_x11Display), &window_attributes_return);
+	if (status == 0)
+	{
+		std::cerr << "Failed to obtain window attributes" << std::endl;
+		return -1;
+	}
+
+	if (_screenWidth == unsigned(window_attributes_return.width) && _screenHeight == unsigned(window_attributes_return.height))
+	{
+		// No update required
+		return 0;
+	}
+	std::cout << "Update of screen resolution: [" << _screenWidth << "x" << _screenHeight <<"] => ";
+	_screenWidth  = window_attributes_return.width;
+	_screenHeight = window_attributes_return.height;
+	std::cout << "[" << _screenWidth << "x" << _screenHeight <<"]" << std::endl;
+
+	// Update the size of the buffer used to transfer the screenshot
+	int width  = (_screenWidth  - 2 * _cropWidth  + _pixelDecimation/2) / _pixelDecimation;
+	int height = (_screenHeight - 2 * _cropHeight + _pixelDecimation/2) / _pixelDecimation;
+	_image.resize(width, height);
 
-	XImage * xImage = XGetImage(dspl, drwbl, x, y, width, height, AllPlanes, ZPixmap);
+	return 0;
 }

src/hyperion-x11/X11Grabber.h

@@ -0,0 +1,37 @@
+
+// Hyperion-utils includes
+#include <utils/Image.h>
+#include <utils/ColorRgb.h>
+
+// X11 includes
+#include <X11/Xlib.h>
+
+class X11Grabber
+{
+public:
+
+	X11Grabber(const unsigned cropHorizontal, const unsigned cropVertical, const unsigned pixelDecimation);
+
+	virtual ~X11Grabber();
+
+	int open();
+
+	Image<ColorRgb> & grab();
+
+private:
+
+	const unsigned _pixelDecimation;
+
+	const unsigned _cropWidth;
+	const unsigned _cropHeight;
+
+	/// Reference to the X11 display (nullptr if not opened)
+	Display * _x11Display;
+
+	unsigned _screenWidth;
+	unsigned _screenHeight;
+
+	Image<ColorRgb> _image;
+
+	int updateScreenDimensions();
+};

src/hyperion-x11/X11Wrapper.cpp

@@ -0,0 +1,33 @@
+
+// Hyperion-X11 includes
+#include "X11Wrapper.h"
+
+X11Wrapper::X11Wrapper(const unsigned cropHorizontal, const unsigned cropVertical, const unsigned pixelDecimation) :
+	_timer(this),
+	_grabber(cropHorizontal, cropVertical, pixelDecimation)
+{
+	// Connect capturing to the timeout signal of the timer
+	connect(&_timer, SIGNAL(timeout()), this, SLOT(capture()));
+}
+
+const Image<ColorRgb> & X11Wrapper::getScreenshot()
+{
+	const Image<ColorRgb> & screenshot = _grabber.grab();
+	return screenshot;
+}
+
+void X11Wrapper::start()
+{
+	_timer.start(200);
+}
+
+void X11Wrapper::stop()
+{
+	_timer.stop();
+}
+
+void X11Wrapper::capture()
+{
+	const Image<ColorRgb> & screenshot = _grabber.grab();
+	emit sig_screenshot(screenshot);
+}

src/hyperion-x11/X11Wrapper.h

@@ -0,0 +1,39 @@
+
+// QT includes
+#include <QTimer>
+
+// Hyperion-X11 includes
+#include "X11Grabber.h"
+
+class X11Wrapper : public QObject
+{
+	Q_OBJECT
+public:
+	X11Wrapper(const unsigned cropHorizontal, const unsigned cropVertical, const unsigned pixelDecimation);
+
+	const Image<ColorRgb> & getScreenshot();
+
+	///
+	/// Starts the timed capturing of screenshots
+	///
+	void start();
+
+	void stop();
+
+signals:
+	void sig_screenshot(const Image<ColorRgb> & screenshot);
+
+private slots:
+	///
+	/// Performs a single screenshot capture and publishes the capture screenshot on the screenshot
+	/// signal.
+	///
+	void capture();
+
+private:
+	/// The QT timer to generate capture-publish events
+	QTimer _timer;
+
+	/// The grabber for creating screenshots
+	X11Grabber _grabber;
+};