Refactor V4L2 and X11 grabbers to share more code

Former-commit-id: 46176e53d1acf39f9bd0c0ecbb8e5fb5ab4d45be

libsrc/grabber/CMakeLists.txt

@@ -1,4 +1,3 @@
-
 if (ENABLE_DISPMANX)
 	add_subdirectory(dispmanx)
 endif (ENABLE_DISPMANX)
@@ -6,3 +5,7 @@ endif (ENABLE_DISPMANX)
 if (ENABLE_V4L2)
 	add_subdirectory(v4l2)
 endif (ENABLE_V4L2)
+
+if (ENABLE_X11)
+	add_subdirectory(x11)
+endif()

libsrc/grabber/x11/CMakeLists.txt

@@ -0,0 +1,37 @@
+# Define the current source locations
+SET(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/grabber)
+SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/grabber/x11)
+
+# Find X11
+find_package(X11 REQUIRED)
+
+include_directories(
+	${QT_INCLUDES}
+	${X11_INCLUDES}
+)
+
+SET(X11_QT_HEADERS
+		${CURRENT_HEADER_DIR}/X11Grabber.h
+)
+
+SET(X11_HEADERS
+	${CURRENT_HEADER_DIR}/X11Grabber.h
+)
+
+SET(X11_SOURCES
+		${CURRENT_SOURCE_DIR}/X11Grabber.cpp
+)
+
+QT4_WRAP_CPP(X11_HEADERS_MOC ${X11_QT_HEADERS})
+
+add_library(x11-grabber
+		${X11_HEADERS}
+		${X11_SOURCES}
+		${X11_QT_HEADERS}
+		${X11_HEADERS_MOC}
+)
+
+target_link_libraries(x11-grabber
+	hyperion
+	${QT_LIBRARIES}
+)

libsrc/grabber/x11/X11Grabber.cpp

@@ -0,0 +1,115 @@
+// STL includes
+#include <iostream>
+#include <cstdint>
+
+// X11 includes
+#include <X11/Xutil.h>
+
+// X11Grabber includes
+#include <grabber/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()
+{
+    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);
+
+    return 0;
+}

libsrc/protoserver/CMakeLists.txt

@@ -10,7 +10,9 @@ include_directories(
 # Group the headers that go through the MOC compiler
 set(ProtoServer_QT_HEADERS
 		${CURRENT_HEADER_DIR}/ProtoServer.h
+		${CURRENT_HEADER_DIR}/ProtoConnection.h
 		${CURRENT_SOURCE_DIR}/ProtoClientConnection.h
+		${CURRENT_HEADER_DIR}/ProtoConnectionWrapper.h
 )
 
 set(ProtoServer_HEADERS
@@ -19,6 +21,8 @@ set(ProtoServer_HEADERS
 set(ProtoServer_SOURCES
 		${CURRENT_SOURCE_DIR}/ProtoServer.cpp
 		${CURRENT_SOURCE_DIR}/ProtoClientConnection.cpp
+		${CURRENT_SOURCE_DIR}/ProtoConnection.cpp
+		${CURRENT_SOURCE_DIR}/ProtoConnectionWrapper.cpp
 )
 
 set(ProtoServer_PROTOS
@@ -44,5 +48,5 @@ add_library(protoserver
 target_link_libraries(protoserver
 		hyperion
 		hyperion-utils
-        ${PROTOBUF_LIBRARIES}
-        ${QT_LIBRARIES})
+		${PROTOBUF_LIBRARIES}
+		${QT_LIBRARIES})

libsrc/protoserver/ProtoConnection.cpp

@@ -0,0 +1,188 @@
+// stl includes
+#include <stdexcept>
+
+// Qt includes
+#include <QRgb>
+
+// protoserver includes
+#include "protoserver/ProtoConnection.h"
+
+ProtoConnection::ProtoConnection(const std::string & a) :
+    _socket(),
+    _skipReply(false)
+{
+    QString address(a.c_str());
+    QStringList parts = address.split(":");
+    if (parts.size() != 2)
+    {
+        throw std::runtime_error(QString("Wrong address: unable to parse address (%1)").arg(address).toStdString());
+    }
+    _host = parts[0];
+
+    bool ok;
+    _port = parts[1].toUShort(&ok);
+    if (!ok)
+    {
+        throw std::runtime_error(QString("Wrong address: Unable to parse the port number (%1)").arg(parts[1]).toStdString());
+    }
+
+    // try to connect to host
+    std::cout << "Connecting to Hyperion: " << _host.toStdString() << ":" << _port << std::endl;
+    connectToHost();
+}
+
+ProtoConnection::~ProtoConnection()
+{
+    _socket.close();
+}
+
+void ProtoConnection::setSkipReply(bool skip)
+{
+    _skipReply = skip;
+}
+
+void ProtoConnection::setColor(const ColorRgb & color, int priority, int duration)
+{
+    proto::HyperionRequest request;
+    request.set_command(proto::HyperionRequest::COLOR);
+    proto::ColorRequest * colorRequest = request.MutableExtension(proto::ColorRequest::colorRequest);
+    colorRequest->set_rgbcolor((color.red << 16) | (color.green << 8) | color.blue);
+    colorRequest->set_priority(priority);
+    colorRequest->set_duration(duration);
+
+    // send command message
+    sendMessage(request);
+}
+
+void ProtoConnection::setImage(const Image<ColorRgb> &image, int priority, int duration)
+{
+    proto::HyperionRequest request;
+    request.set_command(proto::HyperionRequest::IMAGE);
+    proto::ImageRequest * imageRequest = request.MutableExtension(proto::ImageRequest::imageRequest);
+    imageRequest->set_imagedata(image.memptr(), image.width() * image.height() * 3);
+    imageRequest->set_imagewidth(image.width());
+    imageRequest->set_imageheight(image.height());
+    imageRequest->set_priority(priority);
+    imageRequest->set_duration(duration);
+
+    // send command message
+    sendMessage(request);
+}
+
+void ProtoConnection::clear(int priority)
+{
+    proto::HyperionRequest request;
+    request.set_command(proto::HyperionRequest::CLEAR);
+    proto::ClearRequest * clearRequest = request.MutableExtension(proto::ClearRequest::clearRequest);
+    clearRequest->set_priority(priority);
+
+    // send command message
+    sendMessage(request);
+}
+
+void ProtoConnection::clearAll()
+{
+    proto::HyperionRequest request;
+    request.set_command(proto::HyperionRequest::CLEARALL);
+
+    // send command message
+    sendMessage(request);
+}
+
+void ProtoConnection::connectToHost()
+{
+    _socket.connectToHost(_host, _port);
+    if (_socket.waitForConnected()) {
+        std::cout << "Connected to Hyperion host" << std::endl;
+    }
+}
+
+void ProtoConnection::sendMessage(const proto::HyperionRequest &message)
+{
+    if (_socket.state() == QAbstractSocket::UnconnectedState)
+    {
+        std::cout << "Currently disconnected: trying to connect to host" << std::endl;
+        connectToHost();
+    }
+
+    if (_socket.state() != QAbstractSocket::ConnectedState)
+    {
+        return;
+    }
+
+    // We only get here if we are connected
+
+    // serialize message (FastWriter already appends a newline)
+    std::string serializedMessage = message.SerializeAsString();
+
+    int length = serializedMessage.size();
+    const uint8_t header[] = {
+        uint8_t((length >> 24) & 0xFF),
+        uint8_t((length >> 16) & 0xFF),
+        uint8_t((length >>  8) & 0xFF),
+        uint8_t((length      ) & 0xFF)};
+
+    // write message
+    int count = 0;
+    count += _socket.write(reinterpret_cast<const char *>(header), 4);
+    count += _socket.write(reinterpret_cast<const char *>(serializedMessage.data()), length);
+    if (!_socket.waitForBytesWritten())
+    {
+        std::cerr << "Error while writing data to host" << std::endl;
+        return;
+    }
+
+    if (!_skipReply)
+    {
+        // read reply data
+        QByteArray serializedReply;
+        length = -1;
+        while (length < 0 && serializedReply.size() < length+4)
+        {
+            // receive reply
+            if (!_socket.waitForReadyRead())
+            {
+                std::cerr << "Error while reading data from host" << std::endl;
+                return;
+            }
+
+            serializedReply += _socket.readAll();
+
+            if (length < 0 && serializedReply.size() >= 4)
+            {
+                // read the message size
+                length =
+                        ((serializedReply[0]<<24) & 0xFF000000) |
+                        ((serializedReply[1]<<16) & 0x00FF0000) |
+                        ((serializedReply[2]<< 8) & 0x0000FF00) |
+                        ((serializedReply[3]    ) & 0x000000FF);
+            }
+        }
+
+        // parse reply data
+        proto::HyperionReply reply;
+        reply.ParseFromArray(serializedReply.constData()+4, length);
+
+        // parse reply message
+        parseReply(reply);
+    }
+}
+
+bool ProtoConnection::parseReply(const proto::HyperionReply &reply)
+{
+    bool success = false;
+
+    if (!reply.success())
+    {
+        if (reply.has_error())
+        {
+            throw std::runtime_error("Error: " + reply.error());
+        }
+        else
+        {
+            throw std::runtime_error("Error: No error info");
+        }
+    }
+
+    return success;
+}

libsrc/protoserver/ProtoConnectionWrapper.cpp

@@ -0,0 +1,19 @@
+// protoserver includes
+#include "protoserver/ProtoConnectionWrapper.h"
+
+ProtoConnectionWrapper::ProtoConnectionWrapper(const std::string & address, int priority, int duration_ms, bool skipProtoReply) :
+        _priority(priority),
+        _duration_ms(duration_ms),
+        _connection(address)
+{
+    _connection.setSkipReply(skipProtoReply);
+}
+
+ProtoConnectionWrapper::~ProtoConnectionWrapper()
+{
+}
+
+void ProtoConnectionWrapper::receiveImage(const Image<ColorRgb> & image)
+{
+    _connection.setImage(image, _priority, _duration_ms);
+}