Added simple QT-based grabber.

Moved ImageToLedsMap from include to libsrc.
Moved instantiation of objects to Hyperion (no JSON required outside this class).

CMakeLists.txt

@@ -1,7 +1,7 @@
 
 # define the minimum cmake version (as required by cmake)
 cmake_minimum_required(VERSION 2.8)
-#set(CMAKE_TOOLCHAIN_FILE /opt/raspberrypi/Toolchain-RaspberryPi.cmake)
+set(CMAKE_TOOLCHAIN_FILE /opt/raspberrypi/Toolchain-RaspberryPi.cmake)
 
 # Define the main-project name
 project(Hyperion)
@@ -28,6 +28,15 @@ set(CMAKE_BUILD_TYPE "Release")
 # enable C++11
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -Wall")
 
+# Configure the use of QT4
+find_package(Qt4 COMPONENTS QtCore REQUIRED QUIET)
+
+SET(QT_DONT_USE_QTGUI   TRUE)
+SET(QT_USE_QTCONSOLE    TRUE)
+include(${QT_USE_FILE})
+add_definitions(${QT_DEFINITIONS})
+link_directories(${CMAKE_FIND_ROOT_PATH}/lib/arm-linux-gnueabihf)
+
 configure_file(bin/install_hyperion.sh ${LIBRARY_OUTPUT_PATH} @ONLY)
 configure_file(config/hyperion.config.json ${LIBRARY_OUTPUT_PATH} @ONLY)
 configure_file(config/hyperion.schema.json ${LIBRARY_OUTPUT_PATH} @ONLY)

include/hyperion/DispmanxWrapper.h

@@ -0,0 +1,32 @@
+#pragma once
+
+// QT includes
+#include <QObject>
+#include <QTimer>
+
+// Forward class declaration
+class ImageProcessor;
+class DispmanxFrameGrabber;
+
+class DispmanxWrapper: public QObject
+{
+	Q_OBJECT
+public:
+	DispmanxWrapper();
+
+	virtual ~DispmanxWrapper();
+
+public slots:
+	void start();
+
+	void action();
+
+	void stop();
+
+private:
+	QTimer _timer;
+
+	DispmanxFrameGrabber* _frameGrabber;
+	ImageProcessor* _processor;
+};
+

include/hyperion/Hyperion.h

@@ -4,9 +4,14 @@
 // hyperion-utils includes
 #include <utils/RgbImage.h>
 
+// Hyperion includes
 #include <hyperion/LedString.h>
-#include <hyperion/ImageToLedsMap.h>
 #include <hyperion/LedDevice.h>
+#include <hyperion/PriorityMuxer.h>
+
+// Forward class declaration
+namespace hyperion { class ColorTransform; }
+
 
 class Hyperion
 {
@@ -15,27 +20,18 @@ public:
 
 	~Hyperion();
 
-	void setInputSize(const unsigned width, const unsigned height);
-
-	RgbImage& image()
-	{
-		return *mImage;
-	}
-
-	void commit();
-
-	void operator() (const RgbImage& inputImage);
-
-	void setColor(const RgbColor& color);
+	void setValue(int priority, std::vector<RgbColor> &ledColors);
 
 private:
 	void applyTransform(std::vector<RgbColor>& colors) const;
 
 	LedString mLedString;
 
-	RgbImage* mImage;
+	PriorityMuxer mMuxer;
 
-	ImageToLedsMap mLedsMap;
+	hyperion::ColorTransform* mRedTransform;
+	hyperion::ColorTransform* mGreenTransform;
+	hyperion::ColorTransform* mBlueTransform;
 
 	LedDevice* mDevice;
 };

include/hyperion/ImageProcessor.h

@@ -0,0 +1,72 @@
+
+#pragma once
+
+// Utils includes
+#include <utils/RgbImage.h>
+
+#include <hyperion/LedString.h>
+#include <hyperion/ImageProcessorFactory.h>
+
+// Forward class declaration
+namespace hyperion { class ImageToLedsMap;
+					 class ColorTransform; }
+
+/**
+ * The ImageProcessor translates an RGB-image to RGB-values for the leds. The processing is
+ * performed in two steps. First the average color per led-region is computed. Second a
+ * color-tranform is applied based on a gamma-correction.
+ */
+class ImageProcessor
+{
+public:
+	/**
+	 * Processes the image to a list of led colors. This will update the size of the buffer-image
+	 * if required and call the image-to-leds mapping to determine the mean color per led.
+	 *
+	 * @param[in] image  The image to translate to led values
+	 *
+	 * @return The color value per led
+	 */
+	std::vector<RgbColor> process(const RgbImage& image);
+
+	// 'IN PLACE' processing functions
+
+	/**
+	 * Specifies the width and height of 'incomming' images. This will resize the buffer-image to
+	 * match the given size.
+	 * NB All earlier obtained references will be invalid.
+	 *
+	 * @param[in] width   The new width of the buffer-image
+	 * @param[in] height  The new height of the buffer-image
+	 */
+	void setSize(const unsigned width, const unsigned height);
+
+	/**
+	 * Returns a reference of the underlying image-buffer. This can be used to write data directly
+	 * into the buffer, avoiding a copy inside the process method.
+	 *
+	 * @return The reference of the underlying image-buffer.
+	 */
+	RgbImage& image();
+
+	/**
+	 * Determines the led colors of the image in the buffer.
+	 *
+	 * @param[out] ledColors  The color value per led
+	 */
+	void inplace_process(std::vector<RgbColor>& ledColors);
+
+private:
+	friend class ImageProcessorFactory;
+
+	ImageProcessor(const LedString &ledString);
+
+	~ImageProcessor();
+
+private:
+	const LedString mLedString;
+
+	RgbImage *mBuffer;
+	hyperion::ImageToLedsMap* mImageToLeds;
+};
+

include/hyperion/ImageProcessorFactory.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// STL includes
+#include <memory>
+
+// Jsoncpp includes
+#include <json/json.h>
+
+#include <hyperion/LedString.h>
+
+// Forward class declaration
+class ImageProcessor;
+
+class ImageProcessorFactory
+{
+public:
+	static ImageProcessorFactory& getInstance();
+
+public:
+	void init(const LedString& ledString);
+
+	ImageProcessor* newImageProcessor() const;
+
+private:
+	LedString _ledString;
+};

include/hyperion/ImageToLedsMap.h

@@ -1,27 +0,0 @@
-
-#pragma once
-
-// hyperion-utils includes
-#include <utils/RgbImage.h>
-
-// hyperion includes
-#include <hyperion/LedString.h>
-
-class ImageToLedsMap
-{
-public:
-
-	ImageToLedsMap();
-
-	void createMapping(const RgbImage& image, const std::vector<Led>& leds);
-
-	std::vector<RgbColor> getMeanLedColor();
-
-	RgbColor findMeanColor(const std::vector<const RgbColor*>& colors);
-
-	std::vector<RgbColor> getMedianLedColor();
-
-	RgbColor findMedianColor(std::vector<const RgbColor*>& colors);
-private:
-	std::vector<std::vector<const RgbColor*> > mColorsMap;
-};

include/hyperion/LedString.h

@@ -45,28 +45,16 @@ struct Led
 class LedString
 {
 public:
-	static LedString construct(const Json::Value& ledConfig, const Json::Value& colorConfig);
+	static LedString construct(const Json::Value& ledConfig);
 
 	LedString();
 
 	~LedString();
 
+	std::vector<Led>& leds();
+
 	const std::vector<Led>& leds() const;
 
 private:
 	std::vector<Led> mLeds;
-
-public:
-	/**
-	 * Color adjustements per color
-	 */
-	struct
-	{
-		/** The color gradient */
-		double gamma;
-		/** The color offset */
-		double adjust;
-		/** The minimum required level for the led to turn on */
-		double blacklevel;
-	} red, green, blue;
 };

include/hyperion/PriorityMuxer.h

@@ -0,0 +1,55 @@
+#pragma once
+
+// STL includes
+#include <vector>
+#include <map>
+#include <cstdint>
+#include <limits>
+
+// QT includes
+#include <QMap>
+
+// Utils includes
+#include <utils/RgbColor.h>
+
+// Hyperion includes
+#include <hyperion/LedDevice.h>
+
+class PriorityMuxer
+{
+public:
+	struct InputInfo
+	{
+		int priority;
+
+		int64_t timeoutTime_ms;
+		std::vector<RgbColor> ledColors;
+	};
+
+	PriorityMuxer();
+
+	~PriorityMuxer();
+
+	int getCurrentPriority() const;
+
+	bool hasPriority(const int priority) const;
+
+	QList<int> getPriorities() const;
+
+	const InputInfo& getInputInfo(const int priority) const;
+
+	void setInput(const int priority, const std::vector<RgbColor>& ledColors, const int64_t timeoutTime_ms=-1);
+
+	void clearInput(const int priority);
+
+	void clearAll();
+
+	void setCurrentTime(const int64_t& now);
+
+private:
+	int mCurrentPriority;
+
+	QMap<int, InputInfo> mActiveInputs;
+
+	const static int MAX_PRIORITY = std::numeric_limits<int>::max();
+};

include/utils/RgbColor.h

@@ -5,7 +5,6 @@
 #include <stdint.h>
 #include <iostream>
 
-
 // Forward class declaration
 struct RgbColor;
 
@@ -21,8 +20,12 @@ struct RgbColor
 	static RgbColor BLUE;
 	static RgbColor YELLOW;
 	static RgbColor WHITE;
+
 };
 
+static_assert(sizeof(RgbColor) == 3, "Incorrect size of RgbColor");
+
+
 inline std::ostream& operator<<(std::ostream& os, const RgbColor& color)
 {
 	os << "{" << unsigned(color.red) << "," << unsigned(color.green) << "," << unsigned(color.blue) << "}";

libsrc/CMakeLists.txt

@@ -10,18 +10,22 @@ target_link_libraries(bob2hyperion
 		hyperion
 		hyperion-utils)
 
+add_subdirectory(hyperion)
+add_subdirectory(utils)
+
 # Find the libPNG
 find_package(PNG REQUIRED QUIET)
 
-# Add additional includes dirs
-include_directories(${PNG_INCLUDE_DIR})
+if (PNG_FOUND)
+	# Add additional includes dirs
+	include_directories(${PNG_INCLUDE_DIR})
 
-add_library(bob2hyperion-png SHARED
+	add_library(bob2hyperion-png SHARED
 			hyperion-png.cpp)
 
-target_link_libraries(bob2hyperion-png
+	target_link_libraries(bob2hyperion-png
 			hyperion-png)
 
-add_subdirectory(hyperion)
-add_subdirectory(hyperionpng)
-add_subdirectory(utils)
+	add_subdirectory(hyperionpng)
+endif(PNG_FOUND)
+

libsrc/bob2hyperion.cpp

@@ -51,7 +51,7 @@ void boblight_destroy(void* hyperion_ptr)
 	Hyperion* raspiLight = rasp_cast(hyperion_ptr);
 
 	// Switch all leds to black (off)
-	raspiLight->setColor(RgbColor::BLACK);
+//	raspiLight->setColor(RgbColor::BLACK);
 
 	delete raspiLight;
 
@@ -64,20 +64,20 @@ void boblight_setscanrange(void* hyperion_ptr, int width, int height)
 	syslog(LOG_INFO, "Configuring scan range [%dx%d]", width, height);
 
 	Hyperion* raspiLight = rasp_cast(hyperion_ptr);
-	raspiLight->setInputSize(width, height);
+//	raspiLight->setInputSize(width, height);
 }
 
 void boblight_addpixelxy(void* hyperion_ptr, int x, int y, int* rgb)
 {
 	Hyperion* raspiLight = rasp_cast(hyperion_ptr);
 	const RgbColor color = {uint8_t(rgb[0]), uint8_t(rgb[1]), uint8_t(rgb[2])};
-	raspiLight->image().setPixel(x, y, color);
+//	raspiLight->image().setPixel(x, y, color);
 }
 
 int boblight_sendrgb(void* hyperion_ptr, int sync, int* outputused)
 {
 	Hyperion* raspiLight = rasp_cast(hyperion_ptr);
-	raspiLight->commit();
+//	raspiLight->commit();
 
 	return 1;
 }

libsrc/hyperion/CMakeLists.txt

@@ -1,22 +1,52 @@
 
+# Find the BCM-package (VC control)
+find_package(BCM REQUIRED)
+include_directories(${BCM_INCLUDE_DIRS})
+
 # Define the current source locations
 SET(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/hyperion)
 SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/hyperion)
 
-add_library(hyperion
+SET(Hyperion_HEADERS
 		${CURRENT_HEADER_DIR}/Hyperion.h
 		${CURRENT_HEADER_DIR}/LedDevice.h
 		${CURRENT_HEADER_DIR}/LedString.h
-		${CURRENT_HEADER_DIR}/ImageToLedsMap.h
+		${CURRENT_HEADER_DIR}/ImageProcessor.h
+		${CURRENT_HEADER_DIR}/ImageProcessorFactory.h
+		${CURRENT_HEADER_DIR}/PriorityMuxer.h
+		${CURRENT_HEADER_DIR}/DispmanxWrapper.h
+
+		${CURRENT_SOURCE_DIR}/DispmanxFrameGrabber.h
 
 		${CURRENT_SOURCE_DIR}/LedDeviceWs2801.h
-		${CURRENT_SOURCE_DIR}/LedDeviceWs2801.cpp
+		${CURRENT_SOURCE_DIR}/ImageToLedsMap.h
+		${CURRENT_SOURCE_DIR}/ColorTransform.h
+)
+
+SET(Hyperion_SOURCES
 		${CURRENT_SOURCE_DIR}/LedString.cpp
 		${CURRENT_SOURCE_DIR}/Hyperion.cpp
+		${CURRENT_SOURCE_DIR}/ImageProcessor.cpp
+		${CURRENT_SOURCE_DIR}/ImageProcessorFactory.cpp
+		${CURRENT_SOURCE_DIR}/PriorityMuxer.cpp
+
+		${CURRENT_SOURCE_DIR}/DispmanxWrapper.cpp
+		${CURRENT_SOURCE_DIR}/DispmanxFrameGrabber.cpp
+
+		${CURRENT_SOURCE_DIR}/LedDeviceWs2801.cpp
 		${CURRENT_SOURCE_DIR}/ImageToLedsMap.cpp
-                ${CURRENT_SOURCE_DIR}/ColorTransform.h
 		${CURRENT_SOURCE_DIR}/ColorTransform.cpp
 )
 
+QT4_WRAP_CPP(Hyperion_HEADERS_MOC ${Hyperion_HEADERS})
+
+add_library(hyperion
+		${Hyperion_HEADERS}
+		${Hyperion_HEADERS_MOC}
+		${Hyperion_SOURCES}
+)
+
 target_link_libraries(hyperion
-		hyperion-utils)
+		hyperion-utils
+		${QT_LIBRARIES}
+		${BCM_LIBRARIES})

libsrc/hyperion/ColorTransform.cpp

@@ -1,7 +1,10 @@
+// STL includes
 #include <cmath>
 
 #include "ColorTransform.h"
 
+using namespace hyperion;
+
 ColorTransform::ColorTransform() :
 	_threshold(0),
 	_gamma(1.0),

libsrc/hyperion/ColorTransform.h

@@ -1,6 +1,10 @@
 #pragma once
 
-#include "stdint.h"
+// STL includes
+#include <cstdint>
+
+namespace hyperion
+{
 
 /// Transform for a single color byte value
 ///
@@ -15,7 +19,7 @@ class ColorTransform
 {
 public:
 	ColorTransform();
-    ColorTransform(double threshold, double gamma, double whitelevel, double blacklevel);
+	ColorTransform(double threshold, double gamma, double blacklevel, double whitelevel);
 	~ColorTransform();
 
 	double getThreshold() const;
@@ -47,3 +51,5 @@ private:
 
 	uint8_t _mapping[256];
 };
+
+} // end namespace hyperion

libsrc/hyperion/DispmanxFrameGrabber.cpp

@@ -0,0 +1,54 @@
+
+#include "DispmanxFrameGrabber.h"
+
+DispmanxFrameGrabber::DispmanxFrameGrabber(const unsigned width, const unsigned height) :
+	_display(0),
+	_resource(0),
+	_width(width),
+	_height(height)
+{
+	// Initiase BCM
+	bcm_host_init();
+
+	// Open the connection to the displaydisplay
+	_display = vc_dispmanx_display_open(0);
+	int ret = vc_dispmanx_display_get_info(_display, &_info);
+	assert(ret == 0);
+
+	// Create the resources for capturing image
+	_resource = vc_dispmanx_resource_create(
+			VC_IMAGE_RGB888,
+			width,
+			height,
+			&_vc_image_ptr);
+	assert(_resource);
+
+	// Define the capture rectangle with the same size
+	vc_dispmanx_rect_set(&_rectangle, 0, 0, width, height);
+	_pitch = width * 3;
+}
+
+DispmanxFrameGrabber::~DispmanxFrameGrabber()
+{
+	// Clean up resources
+	vc_dispmanx_resource_delete(_resource);
+
+	// Close the displaye
+	vc_dispmanx_display_close(_display);
+
+	// De-init BCM
+	bcm_host_deinit();
+}
+
+void DispmanxFrameGrabber::grabFrame(RgbImage& image)
+{
+	// Sanity check of the given image size
+	assert(image.width() == _width && image.height() == _height);
+
+	void* image_ptr = image.memptr();
+
+	// Create the snapshot
+	vc_dispmanx_snapshot(_display, _resource, VC_IMAGE_ROT0);
+	// Read the snapshot into the memory (incl down-scaling)
+	vc_dispmanx_resource_read_data(_resource, &_rectangle, image_ptr, _pitch);
+}

libsrc/hyperion/DispmanxFrameGrabber.h

@@ -0,0 +1,35 @@
+#pragma once
+
+// BCM includes
+#include <bcm_host.h>
+
+// STL includes
+#include <cstdint>
+
+// Utils includes
+#include <utils/RgbImage.h>
+
+///
+/// The DispmanxFrameGrabber grabs
+///
+class DispmanxFrameGrabber
+{
+public:
+	DispmanxFrameGrabber(const unsigned width, const unsigned height);
+	~DispmanxFrameGrabber();
+
+	void grabFrame(RgbImage& image);
+
+private:
+	DISPMANX_DISPLAY_HANDLE_T _display;
+	DISPMANX_MODEINFO_T _info;
+
+	DISPMANX_RESOURCE_HANDLE_T _resource;
+
+	uint32_t _vc_image_ptr;
+
+	VC_RECT_T _rectangle;
+	unsigned _width;
+	unsigned _height;
+	uint32_t _pitch;
+};

libsrc/hyperion/DispmanxWrapper.cpp

@@ -0,0 +1,46 @@
+// QT includes
+#include <QDebug>
+#include <QDateTime>
+
+// Hyperion includes
+#include <hyperion/DispmanxWrapper.h>
+#include <hyperion/ImageProcessorFactory.h>
+
+
+// Local-Hyperion includes
+#include "DispmanxFrameGrabber.h"
+
+DispmanxWrapper::DispmanxWrapper() :
+	_timer(),
+	_processor(ImageProcessorFactory::getInstance().newImageProcessor()),
+	_frameGrabber(new DispmanxFrameGrabber(64, 64))
+{
+	_timer.setInterval(100);
+	_timer.setSingleShot(false);
+
+	QObject::connect(&_timer, SIGNAL(timeout()), this, SLOT(action()));
+}
+
+DispmanxWrapper::~DispmanxWrapper()
+{
+	delete _frameGrabber;
+	delete _processor;
+}
+
+void DispmanxWrapper::start()
+{
+	_timer.start();
+}
+
+void DispmanxWrapper::action()
+{
+	qDebug() << "[" << QDateTime::currentDateTimeUtc() << "] Grabbing frame";
+	RgbImage image(64, 64);
+	_frameGrabber->grabFrame(image);
+
+	//_processor->
+}
+void DispmanxWrapper::stop()
+{
+	_timer.stop();
+}

libsrc/hyperion/Hyperion.cpp

@@ -10,6 +10,9 @@
 #include <hyperion/LedDevice.h>
 
 #include "LedDeviceWs2801.h"
+#include "ColorTransform.h"
+
+using namespace hyperion;
 
 LedDevice* constructDevice(const Json::Value& deviceConfig)
 {
@@ -34,9 +37,41 @@ LedDevice* constructDevice(const Json::Value& deviceConfig)
 	return device;
 }
 
+ColorTransform* createColorTransform(const Json::Value& colorConfig)
+{
+	const double threshold  = colorConfig["threshold"].asDouble();
+	const double gamma      = colorConfig["gamma"].asDouble();
+	const double blacklevel = colorConfig["blacklevel"].asDouble();
+	const double whitelevel = colorConfig["whitelevel"].asDouble();
+
+	ColorTransform* transform = new ColorTransform(threshold, gamma, blacklevel, whitelevel);
+	return transform;
+}
+LedString createLedString(const Json::Value& ledsConfig)
+{
+	LedString ledString;
+
+	for (const Json::Value& ledConfig : ledsConfig)
+	{
+		Led led;
+		led.index = ledConfig["index"].asInt();
+		const Json::Value& hscanConfig = ledConfig["hscan"];
+		const Json::Value& vscanConfig = ledConfig["vscan"];
+		led.minX_frac = std::max(0.0, std::min(100.0, hscanConfig["minimum"].asDouble()))/100.0;
+		led.maxX_frac = std::max(0.0, std::min(100.0, hscanConfig["maximum"].asDouble()))/100.0;
+		led.minY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["maximum"].asDouble()))/100.0;
+		led.maxY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["minimum"].asDouble()))/100.0;
+
+		ledString.leds().push_back(led);
+	}
+	return ledString;
+}
+
 Hyperion::Hyperion(const Json::Value &jsonConfig) :
-	mLedString(LedString::construct(jsonConfig["leds"], jsonConfig["color"])),
-	mImage(nullptr),
+	mLedString(createLedString(jsonConfig["leds"])),
+	mRedTransform(  createColorTransform(jsonConfig["color"]["red"])),
+	mGreenTransform(createColorTransform(jsonConfig["color"]["green"])),
+	mBlueTransform( createColorTransform(jsonConfig["color"]["blue"])),
 	mDevice(constructDevice(jsonConfig["device"]))
 {
 	// empty
@@ -45,58 +80,29 @@ Hyperion::Hyperion(const Json::Value &jsonConfig) :
 
 Hyperion::~Hyperion()
 {
-	// Delete the existing image (or delete nullptr)
-	delete mImage;
-
 	// Delete the Led-String
 	delete mDevice;
+
+	// Delete the color-transform
+	delete mBlueTransform;
+	delete mGreenTransform;
+	delete mRedTransform;
 }
 
-void Hyperion::setInputSize(const unsigned width, const unsigned height)
+void Hyperion::setValue(int priority, std::vector<RgbColor>& ledColors)
 {
-	// Delete the existing image (or delete nullptr)
-	delete mImage;
-
-	// Create the new image with the mapping to the leds
-	mImage = new RgbImage(width, height);
-	mLedsMap.createMapping(*mImage, mLedString.leds());
-}
-
-void Hyperion::commit()
-{
-	// Derive the color per led
-	std::vector<RgbColor> ledColors = mLedsMap.getMeanLedColor();
-//	const std::vector<RgbColor> ledColors = mLedsMap.getMedianLedColor();
-
-	// Write the Led colors to the led-string
-	mDevice->write(ledColors);
-}
-
-void Hyperion::operator() (const RgbImage& inputImage)
-{
-	// Copy the input-image into the buffer
-	mImage->copy(inputImage);
-
-	// Derive the color per led
-	std::vector<RgbColor> ledColors = mLedsMap.getMeanLedColor();
-//	std::vector<RgbColor> ledColors = mLedsMap.getMedianLedColor();
-	applyTransform(ledColors);
-
-	// Write the Led colors to the led-string
-	mDevice->write(ledColors);
-}
-
-void Hyperion::setColor(const RgbColor& color)
-{
-	mDevice->write(std::vector<RgbColor>(mLedString.leds().size(), color));
-}
-
-void Hyperion::applyTransform(std::vector<RgbColor>& colors) const
-{
-	for (RgbColor& color : colors)
+	// Apply the transform to each led and color-channel
+	for (RgbColor& color : ledColors)
 	{
-		color.red   = (color.red  < mLedString.red.blacklevel)?    0 : mLedString.red.adjust   + mLedString.red.gamma   * color.red;
-		color.green = (color.green < mLedString.green.blacklevel)? 0 : mLedString.green.adjust + mLedString.green.gamma * color.green;
-		color.blue  = (color.blue  < mLedString.blue.blacklevel)?  0 : mLedString.blue.adjust  + mLedString.blue.gamma  * color.blue;
+		color.red   = mRedTransform->transform(color.red);
+		color.green = mGreenTransform->transform(color.green);
+		color.blue  = mBlueTransform->transform(color.blue);
+	}
+
+	mMuxer.setInput(priority, ledColors);
+
+	if (priority == mMuxer.getCurrentPriority())
+	{
+		mDevice->write(ledColors);
 	}
 }

libsrc/hyperion/ImageProcessor.cpp

@@ -0,0 +1,65 @@
+#include <hyperion/ImageProcessor.h>
+
+
+#include "ImageToLedsMap.h"
+#include "ColorTransform.h"
+
+using namespace hyperion;
+
+ImageProcessor::ImageProcessor(const LedString& ledString) :
+	mLedString(ledString),
+	mBuffer(nullptr),
+	mImageToLeds(nullptr)
+{
+	// empty
+}
+
+ImageProcessor::~ImageProcessor()
+{
+	delete mImageToLeds;
+	delete mBuffer;
+}
+
+std::vector<RgbColor> ImageProcessor::process(const RgbImage& image)
+{
+	// Ensure that the buffer-image is the proper size
+	setSize(image.width(), image.height());
+
+	// Copy the data of the given image into the mapped-image
+	mBuffer->copy(image);
+
+	// Create a result vector and call the 'in place' functionl
+	std::vector<RgbColor> colors(mLedString.leds().size(), RgbColor::BLACK);
+	inplace_process(colors);
+
+	// return the computed colors
+	return colors;
+}
+
+void ImageProcessor::setSize(const unsigned width, const unsigned height)
+{
+	// Check if the existing buffer-image is already the correct dimensions
+	if (mBuffer && mBuffer->width() == width && mBuffer->height() == height)
+	{
+		return;
+	}
+
+	// Clean up the old buffer and mapping
+	delete mImageToLeds;
+	delete mBuffer;
+
+	// Construct a new buffer and mapping
+	mBuffer = new RgbImage(width, height);
+	mImageToLeds = new ImageToLedsMap(*mBuffer, mLedString.leds());
+}
+
+RgbImage& ImageProcessor::image()
+{
+	return *mBuffer;
+}
+
+void ImageProcessor::inplace_process(std::vector<RgbColor>& ledColors)
+{
+	// Determine the mean-colors of each led (using the existing mapping)
+	mImageToLeds->getMeanLedColor(ledColors);
+}

libsrc/hyperion/ImageProcessorFactory.cpp

@@ -0,0 +1,21 @@
+
+// Hyperion includes
+#include <hyperion/ImageProcessorFactory.h>
+#include <hyperion/ImageProcessor.h>
+
+ImageProcessorFactory& ImageProcessorFactory::getInstance()
+{
+	static ImageProcessorFactory instance;
+	// Return the singleton instance
+	return instance;
+}
+
+void ImageProcessorFactory::init(const LedString& ledString)
+{
+	_ledString = ledString;
+}
+
+ImageProcessor* ImageProcessorFactory::newImageProcessor() const
+{
+	return new ImageProcessor(_ledString);
+}

libsrc/hyperion/ImageToLedsMap.cpp

@@ -3,14 +3,11 @@
 #include <algorithm>
 
 // hyperion includes
-#include <hyperion/ImageToLedsMap.h>
+#include "ImageToLedsMap.h"
 
-ImageToLedsMap::ImageToLedsMap()
-{
-	// empty
-}
+using namespace hyperion;
 
-void ImageToLedsMap::createMapping(const RgbImage& image, const std::vector<Led>& leds)
+ImageToLedsMap::ImageToLedsMap(const RgbImage& image, const std::vector<Led>& leds)
 {
 	mColorsMap.resize(leds.size(), std::vector<const RgbColor*>());
 
@@ -46,6 +43,19 @@ std::vector<RgbColor> ImageToLedsMap::getMeanLedColor()
 	return colors;
 }
 
+void ImageToLedsMap::getMeanLedColor(std::vector<RgbColor>& ledColors)
+{
+	// Sanity check for the number of leds
+	assert(mColorsMap.size() == ledColors.size());
+
+	auto led = ledColors.begin();
+	for (auto ledColors = mColorsMap.begin(); ledColors != mColorsMap.end(); ++ledColors, ++led)
+	{
+		const RgbColor color = findMeanColor(*ledColors);
+		*led = color;
+	}
+}
+
 RgbColor ImageToLedsMap::findMeanColor(const std::vector<const RgbColor*>& colors)
 {
 	uint_fast16_t cummRed   = 0;
@@ -64,27 +74,3 @@ RgbColor ImageToLedsMap::findMeanColor(const std::vector<const RgbColor*>& color
 
 	return {avgRed, avgGreen, avgBlue};
 }
-
-std::vector<RgbColor> ImageToLedsMap::getMedianLedColor()
-{
-	std::vector<RgbColor> ledColors;
-	for (std::vector<const RgbColor*>& colors : mColorsMap)
-	{
-		const RgbColor color = findMedianColor(colors);
-		ledColors.push_back(color);
-	}
-
-	return ledColors;
-}
-
-RgbColor ImageToLedsMap::findMedianColor(std::vector<const RgbColor*>& colors)
-{
-	std::sort(colors.begin(), colors.end(), [](const RgbColor* lhs, const RgbColor* rhs){ return lhs->red   < rhs->red;   });
-	const uint8_t red   = colors.at(colors.size()/2)->red;
-	std::sort(colors.begin(), colors.end(), [](const RgbColor* lhs, const RgbColor* rhs){ return lhs->green < rhs->green; });
-	const uint8_t green = colors.at(colors.size()/2)->green;
-	std::sort(colors.begin(), colors.end(), [](const RgbColor* lhs, const RgbColor* rhs){ return lhs->blue  < rhs->blue;  });
-	const uint8_t blue  = colors.at(colors.size()/2)->blue;
-
-	return {red, green, blue};
-}

libsrc/hyperion/ImageToLedsMap.h

@@ -0,0 +1,57 @@
+
+#pragma once
+
+// hyperion-utils includes
+#include <utils/RgbImage.h>
+
+// hyperion includes
+#include <hyperion/LedString.h>
+
+namespace hyperion
+{
+
+class ImageToLedsMap
+{
+public:
+
+	/**
+	 * Constructs an mapping from the colors in the image to each led based on the border
+	 * definition given in the list of leds. The map holds pointers to the given image and its
+	 * lifetime should never exceed that of the given image
+	 *
+	 * @param[in] image  The RGB image
+	 * @param[in] leds   The list with led specifications
+	 */
+	ImageToLedsMap(const RgbImage& image, const std::vector<Led>& leds);
+
+	/**
+	 * Determines the mean-color for each led using the mapping the image given
+	 * at construction.
+	 *
+	 * @return ledColors  The vector containing the output
+	 */
+	std::vector<RgbColor> getMeanLedColor();
+
+	/**
+	 * Determines the mean-color for each led using the mapping the image given
+	 * at construction.
+	 *
+	 * @param[out] ledColors  The vector containing the output
+	 */
+	void getMeanLedColor(std::vector<RgbColor>& ledColors);
+
+private:
+	std::vector<std::vector<const RgbColor*> > mColorsMap;
+
+	/**
+	 * Finds the 'mean color' of the given list. This is the mean over each color-channel (red,
+	 * green, blue)
+	 *
+	 * @param colors  The list with colors
+	 *
+	 * @return The mean of the given list of colors (or black when empty)
+	 */
+	RgbColor findMeanColor(const std::vector<const RgbColor*>& colors);
+};
+
+} // end namespace hyperion

libsrc/hyperion/LedString.cpp

@@ -9,41 +9,6 @@
 // hyperion includes
 #include <hyperion/LedString.h>
 
-LedString LedString::construct(const Json::Value& ledsConfig, const Json::Value& colorConfig)
-{
-	LedString ledString;
-
-	const Json::Value& redConfig   = colorConfig["red"];
-	const Json::Value& greenConfig = colorConfig["greem"];
-	const Json::Value& blueConfig  = colorConfig["blue"];
-
-	ledString.red.gamma      = redConfig["gamma"].asDouble();
-	ledString.red.adjust     = redConfig["adjust"].asDouble();
-	ledString.red.blacklevel = redConfig["blacklevel"].asDouble();
-
-	ledString.green.gamma      = greenConfig["gamma"].asDouble();
-	ledString.green.adjust     = colorConfig["adjust"].asDouble();
-	ledString.green.blacklevel = colorConfig["blacklevel"].asDouble();
-
-	ledString.blue.gamma      = blueConfig["gamma"].asDouble();
-	ledString.blue.adjust     = blueConfig["adjust"].asDouble();
-	ledString.blue.blacklevel = blueConfig["blacklevel"].asDouble();
-
-	for (const Json::Value& ledConfig : ledsConfig)
-	{
-		Led led;
-		led.index = ledConfig["index"].asInt();
-		const Json::Value& hscanConfig = ledConfig["hscan"];
-		const Json::Value& vscanConfig = ledConfig["vscan"];
-		led.minX_frac = std::max(0.0, std::min(100.0, hscanConfig["minimum"].asDouble()))/100.0;
-		led.maxX_frac = std::max(0.0, std::min(100.0, hscanConfig["maximum"].asDouble()))/100.0;
-		led.minY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["maximum"].asDouble()))/100.0;
-		led.maxY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["minimum"].asDouble()))/100.0;
-
-		ledString.mLeds.push_back(led);
-	}
-	return ledString;
-}
 
 LedString::LedString()
 {
@@ -54,6 +19,11 @@ LedString::~LedString()
 {
 }
 
+std::vector<Led>& LedString::leds()
+{
+	return mLeds;
+}
+
 const std::vector<Led>& LedString::leds() const
 {
 	return mLeds;

libsrc/hyperion/PriorityMuxer.cpp

@@ -0,0 +1,94 @@
+
+// STL includes
+#include <algorithm>
+#include <stdexcept>
+
+// Hyperion includes
+#include <hyperion/PriorityMuxer.h>
+
+PriorityMuxer::PriorityMuxer() :
+	mCurrentPriority(MAX_PRIORITY)
+{
+	// empty
+}
+
+PriorityMuxer::~PriorityMuxer()
+{
+	// empty
+}
+
+int PriorityMuxer::getCurrentPriority() const
+{
+	return mCurrentPriority;
+}
+
+QList<int> PriorityMuxer::getPriorities() const
+{
+	return mActiveInputs.keys();
+}
+
+bool PriorityMuxer::hasPriority(const int priority) const
+{
+	return mActiveInputs.contains(priority);
+}
+
+const PriorityMuxer::InputInfo& PriorityMuxer::getInputInfo(const int priority) const
+{
+	auto elemIt = mActiveInputs.find(priority);
+	if (elemIt == mActiveInputs.end())
+	{
+		throw std::runtime_error("no such priority");
+	}
+	return elemIt.value();
+}
+
+void PriorityMuxer::setInput(const int priority, const std::vector<RgbColor>& ledColors, const int64_t timeoutTime_ms)
+{
+	InputInfo& input = mActiveInputs[priority];
+	input.priority       = priority;
+	input.timeoutTime_ms = timeoutTime_ms;
+	input.ledColors      = ledColors;
+
+	mCurrentPriority = std::min(mCurrentPriority, priority);
+}
+
+void PriorityMuxer::clearInput(const int priority)
+{
+	mActiveInputs.remove(priority);
+	if (mCurrentPriority == priority)
+	{
+		if (mActiveInputs.empty())
+		{
+			mCurrentPriority = MAX_PRIORITY;
+		}
+		else
+		{
+			QList<int> keys = mActiveInputs.keys();
+			mCurrentPriority = *std::min_element(keys.begin(), keys.end());
+		}
+	}
+}
+
+void PriorityMuxer::clearAll()
+{
+	mActiveInputs.clear();
+	mCurrentPriority = MAX_PRIORITY;
+}
+
+void PriorityMuxer::setCurrentTime(const int64_t& now)
+{
+	mCurrentPriority = MAX_PRIORITY;
+
+	for (auto infoIt = mActiveInputs.begin(); infoIt != mActiveInputs.end();)
+	{
+		if (infoIt->timeoutTime_ms != -1 && infoIt->timeoutTime_ms <= now)
+		{
+			infoIt = mActiveInputs.erase(infoIt);
+		}
+		else
+		{
+			mCurrentPriority = std::min(mCurrentPriority, infoIt->priority);
+			++infoIt;
+		}
+	}
+}

src/CMakeLists.txt

@@ -2,6 +2,12 @@
 add_executable(WriteConfig
 		WriteConfig.cpp)
 
+add_executable(HyperionDispmanx
+		HyperionMain.cpp)
+
+target_link_libraries(HyperionDispmanx
+		hyperion)
+
 add_executable(boblight-dispmanx
 		boblight-dispmanx.cpp
 		flagmanager.h
@@ -27,12 +33,12 @@ target_link_libraries(boblight-dispmanx
 		bob2hyperion
 		${BCM_LIBRARIES})
 
-add_executable(HyperionDispmanX
-		HyperionDispmanX.cpp)
+#add_executable(HyperionDispmanX
+#		HyperionDispmanX.cpp)
 
-target_link_libraries(HyperionDispmanX
-		hyperion
-		${BCM_LIBRARIES})
+#target_link_libraries(HyperionDispmanX
+#		hyperion
+#		${BCM_LIBRARIES})
 
 
 # Find the libPNG

src/HyperionDispmanX.cpp

@@ -43,7 +43,7 @@ int main(int /*argc*/, char** /*argv*/)
 	}
 	Hyperion hyperion(raspiConfig);
 
-	dispmanx_process(hyperion, sRunning);
+//	dispmanx_process(hyperion, sRunning);
 
 	return 0;
 }

src/HyperionMain.cpp

@@ -0,0 +1,17 @@
+
+// QT includes
+#include <QCoreApplication>
+
+// Hyperion includes
+#include <hyperion/DispmanxWrapper.h>
+
+int main(int argc, char** argv)
+{
+	QCoreApplication app(argc, argv);
+
+
+	DispmanxWrapper dispmanx;
+	dispmanx.start();
+
+	app.exec();
+}

src/ViewPng.cpp

@@ -144,10 +144,10 @@ int main(int argc, char** argv)
 	FbWriter fbWriter;
 
 	Hyperion raspiLight(raspiConfig);
-	raspiLight.setInputSize(image->width(), image->height());
+//	raspiLight.setInputSize(image->width(), image->height());
 
 	fbWriter.writeImage(*image);
-	raspiLight(*image);
+//	raspiLight(*image);
 
 	sleep(5);
 

src/flagmanager.cpp

@@ -179,7 +179,7 @@ void CFlagManager::ParseBoblightOptions(void* boblight)
 {
   int nrlights = boblight_getnrlights(boblight);
 
-  for (int i = 0; i < m_options.size(); i++)
+  for (size_t i = 0; i < m_options.size(); i++)
   {
 	string option = m_options[i];
 	string lightname;
@@ -235,7 +235,7 @@ void CFlagManager::ParseBoblightOptions(void* boblight)
 
 bool CFlagManager::SetVideoGamma()
 {
-  for (int i = 0; i < m_options.size(); i++)
+  for (size_t i = 0; i < m_options.size(); i++)
   {
 	string option = m_options[i];
 	if (option.find(':') != string::npos)

src/misc.h

@@ -135,7 +135,7 @@ inline bool StrToInt(const std::string& data, int& value)
 
 inline bool StrToInt(const std::string& data, int64_t& value)
 {
-  return sscanf(data.c_str(), "%ld", &value) == 1;
+  return sscanf(data.c_str(), "%lld", &value) == 1;
 }
 
 inline bool HexStrToInt(const std::string& data, int& value)
@@ -145,7 +145,7 @@ inline bool HexStrToInt(const std::string& data, int& value)
 
 inline bool HexStrToInt(const std::string& data, int64_t& value)
 {
-  return sscanf(data.c_str(), "%x", &value) == 1;
+  return sscanf(data.c_str(), "%llx", &value) == 1;
 }
 
 inline bool StrToFloat(const std::string& data, float& value)

test/TestColorTransform.cpp

@@ -1,7 +1,10 @@
+// STL includes
 #include <iostream>
 #include <cmath>
 
-#include <hyperion/ColorTransform.h>
+#include <../../libsrc/hyperion/ColorTransform.h>
+
+using namespace hyperion;
 
 int main()
 {

test/TestConfigFile.cpp

@@ -32,7 +32,7 @@ int main()
 	double redGamma = redConfig["gamma"].asDouble();
 	std::cout << "RED GAMMA = " << redGamma << std::endl;
 	std::cout << "RED GAMMA = " << colorConfig["red.gamma"].asDouble() << std::endl;
-	LedString ledString = LedString::construct(ledConfig, colorConfig);
+//	LedString ledString = LedString::construct(ledConfig, colorConfig);
 
 	return 0;
 }