Moved test/v4l2_to_png to src/hyperion-v4l2; Added json backend temporarily

Author: poljvd

dependencies/build/getoptPlusPlus/getoptpp.cc

@@ -120,7 +120,7 @@ void OptionsParser::usage() const {
    for(i = parameters.parameters.begin();
 		   i != parameters.parameters.end(); i++)
    {
-	   cerr.width(30);
+	   cerr.width(31);
 	   cerr << std::left << "    " + (*i)->usageLine();
 
 	   cerr.width(40);

libsrc/protoserver/CMakeLists.txt

@@ -3,9 +3,6 @@
 set(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/protoserver)
 set(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/protoserver)
 
-# add protocol buffers
-find_package(Protobuf REQUIRED)
-
 include_directories(
 		${CMAKE_CURRENT_BINARY_DIR}
 		${PROTOBUF_INCLUDE_DIRS})

src/CMakeLists.txt

@@ -1,2 +1,5 @@
 add_subdirectory(hyperiond)
 add_subdirectory(hyperion-remote)
+if (ENABLE_V4L2)
+	add_subdirectory(hyperion-v4l2)
+endif (ENABLE_V4L2)

src/hyperion-v4l2/CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 2.8)
+
+project(hyperion-v4l2)
+
+# add protocol buffers
+find_package(Protobuf REQUIRED)
+
+# find Qt4
+find_package(Qt4 REQUIRED QtCore QtGui QtNetwork)
+
+include_directories(
+	${CMAKE_CURRENT_BINARY_DIR}
+	${PROTOBUF_INCLUDE_DIRS}
+	${QT_INCLUDES}
+)
+
+set(Hyperion_V4L2_HEADERS
+	V4L2Grabber.h
+	ProtoConnection.h
+)
+
+set(Hyperion_V4L2_SOURCES
+	hyperion-v4l2.cpp
+	V4L2Grabber.cpp
+	ProtoConnection.cpp
+)
+
+set(Hyperion_V4L2_PROTOS
+	${CMAKE_CURRENT_SOURCE_DIR}/../../libsrc/protoserver/message.proto
+)
+
+protobuf_generate_cpp(Hyperion_V4L2_PROTO_SRCS Hyperion_V4L2_PROTO_HDRS
+	${Hyperion_V4L2_PROTOS}
+)
+
+add_executable(hyperion-v4l2
+	${Hyperion_V4L2_HEADERS}
+	${Hyperion_V4L2_SOURCES}
+	${Hyperion_V4L2_PROTO_SRCS}
+	${Hyperion_V4L2_PROTO_HDRS}
+)
+
+target_link_libraries(hyperion-v4l2
+	getoptPlusPlus
+	jsoncpp
+	hyperion-utils
+	${PROTOBUF_LIBRARIES}
+	pthread
+)
+
+qt4_use_modules(hyperion-v4l2
+	Core
+	Gui
+	Network)

src/hyperion-v4l2/ProtoConnection.cpp

@@ -0,0 +1,181 @@
+// stl includes
+#include <stdexcept>
+
+// Qt includes
+#include <QRgb>
+
+// hyperion-v4l2 includes
+#include "ProtoConnection.h"
+
+ProtoConnection::ProtoConnection(const std::string & a) :
+	_socket()
+{
+	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());
+	}
+
+	bool ok;
+	uint16_t 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());
+	}
+
+	_socket.connectToHost(parts[0], port);
+	if (!_socket.waitForConnected())
+	{
+		throw std::runtime_error("Unable to connect to host");
+	}
+
+	std::cout << "Connected to " << a << std::endl;
+}
+
+ProtoConnection::~ProtoConnection()
+{
+	_socket.close();
+}
+
+void ProtoConnection::setColor(std::vector<QColor> colors, int priority, int duration)
+{
+	// create command
+	Json::Value command;
+	command["command"] = "color";
+	command["priority"] = priority;
+	Json::Value & rgbValue = command["color"];
+	for (const QColor & color : colors)
+	{
+		rgbValue.append(color.red());
+		rgbValue.append(color.green());
+		rgbValue.append(color.blue());
+	}
+	if (duration > 0)
+	{
+		command["duration"] = duration;
+	}
+
+	// send command message
+	Json::Value reply = sendMessage(command);
+
+	// parse reply message
+	parseReply(reply);
+}
+
+void ProtoConnection::setImage(const Image<ColorRgb> &image, int priority, int duration)
+{
+	// ensure the image has RGB888 format
+	QByteArray binaryImage = QByteArray::fromRawData(reinterpret_cast<const char *>(image.memptr()), image.width() * image.height() * 3);
+	const QByteArray base64Image = binaryImage.toBase64();
+
+	// create command
+	Json::Value command;
+	command["command"] = "image";
+	command["priority"] = priority;
+	command["imagewidth"] = image.width();
+	command["imageheight"] = image.height();
+	command["imagedata"] = std::string(base64Image.data(), base64Image.size());
+	if (duration > 0)
+	{
+		command["duration"] = duration;
+	}
+
+	// send command message
+	Json::Value reply = sendMessage(command);
+
+	// parse reply message
+	parseReply(reply);
+}
+
+void ProtoConnection::clear(int priority)
+{
+	std::cout << "Clear priority channel " << priority << std::endl;
+
+	// create command
+	Json::Value command;
+	command["command"] = "clear";
+	command["priority"] = priority;
+
+	// send command message
+	Json::Value reply = sendMessage(command);
+
+	// parse reply message
+	parseReply(reply);
+}
+
+void ProtoConnection::clearAll()
+{
+	std::cout << "Clear all priority channels" << std::endl;
+
+	// create command
+	Json::Value command;
+	command["command"] = "clearall";
+
+	// send command message
+	Json::Value reply = sendMessage(command);
+
+	// parse reply message
+	parseReply(reply);
+}
+
+Json::Value ProtoConnection::sendMessage(const Json::Value & message)
+{
+	// serialize message (FastWriter already appends a newline)
+	std::string serializedMessage = Json::FastWriter().write(message);
+
+	// write message
+	_socket.write(serializedMessage.c_str());
+	if (!_socket.waitForBytesWritten())
+	{
+		throw std::runtime_error("Error while writing data to host");
+	}
+
+	// read reply data
+	QByteArray serializedReply;
+	while (!serializedReply.contains('\n'))
+	{
+		// receive reply
+		if (!_socket.waitForReadyRead())
+		{
+			throw std::runtime_error("Error while reading data from host");
+		}
+
+		serializedReply += _socket.readAll();
+	}
+	int bytes = serializedReply.indexOf('\n') + 1;     // Find the end of message
+
+	// parse reply data
+	Json::Reader jsonReader;
+	Json::Value reply;
+	if (!jsonReader.parse(serializedReply.constData(), serializedReply.constData() + bytes, reply))
+	{
+		throw std::runtime_error("Error while parsing reply: invalid json");
+	}
+
+	return reply;
+}
+
+bool ProtoConnection::parseReply(const Json::Value &reply)
+{
+	bool success = false;
+	std::string reason = "No error info";
+
+	try
+	{
+		success = reply.get("success", false).asBool();
+		if (!success)
+			reason = reply.get("error", reason).asString();
+	}
+	catch (const std::runtime_error &)
+	{
+		// Some json parsing error: ignore and set parsing error
+	}
+
+	if (!success)
+	{
+		throw std::runtime_error("Error: " + reason);
+	}
+
+	return success;
+}

src/hyperion-v4l2/ProtoConnection.h

@@ -0,0 +1,89 @@
+#pragma once
+
+// stl includes
+#include <string>
+
+// Qt includes
+#include <QColor>
+#include <QImage>
+#include <QTcpSocket>
+#include <QMap>
+
+// hyperion util
+#include <utils/Image.h>
+#include <utils/ColorRgb.h>
+
+// jsoncpp includes
+#include <json/json.h>
+
+///
+/// Connection class to setup an connection to the hyperion server and execute commands
+///
+class ProtoConnection
+{
+public:
+	///
+	/// Constructor
+	///
+	/// @param address The address of the Hyperion server (for example "192.168.0.32:19444)
+	///
+	ProtoConnection(const std::string & address);
+
+	///
+	/// Destructor
+	///
+	~ProtoConnection();
+
+	///
+	/// Set all leds to the specified color
+	///
+	/// @param color The color
+	/// @param priority The priority
+	/// @param duration The duration in milliseconds
+	///
+	void setColor(std::vector<QColor> color, int priority, int duration);
+
+	///
+	/// Set the leds according to the given image (assume the image is stretched to the display size)
+	///
+	/// @param image The image
+	/// @param priority The priority
+	/// @param duration The duration in milliseconds
+	///
+	void setImage(const Image<ColorRgb> & image, int priority, int duration);
+
+	///
+	/// Clear the given priority channel
+	///
+	/// @param priority The priority
+	///
+	void clear(int priority);
+
+	///
+	/// Clear all priority channels
+	///
+	void clearAll();
+
+private:
+	///
+	/// Send a json command message and receive its reply
+	///
+	/// @param message The message to send
+	///
+	/// @return The returned reply
+	///
+	Json::Value sendMessage(const Json::Value & message);
+
+	///
+	/// Parse a reply message
+	///
+	/// @param reply The received reply
+	///
+	/// @return true if the reply indicates success
+	///
+	bool parseReply(const Json::Value & reply);
+
+private:
+	/// The TCP-Socket with the connection to the server
+	QTcpSocket _socket;
+};