frodovdr
/
hyperion.ng
mirror of https://github.com/hyperion-project/hyperion.ng.git
1
0
Fork 0
Code Issues Releases Wiki Activity

QSocket connection added to hyperion-remote

This commit is contained in:
johan 2013-08-13 19:31:56 +02:00
parent cc3baec022 2ec9f9202e
commit 3f4f1eff74
59 changed files with 2236 additions and 3725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
CMakeLists.txt
View File

@ -2,7 +2,7 @@
# define the minimum cmake version (as required by cmake)
cmake_minimum_required(VERSION 2.8)
set(CMAKE_TOOLCHAIN_FILE /home/johan/raspberrypi/Toolchain-RaspberryPi.cmake)
set(CMAKE_TOOLCHAIN_FILE /opt/raspberrypi/Toolchain-RaspberryPi.cmake)
# Define the main-project name
project(Hyperion)
@ -29,6 +29,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)

41
include/boblight-functions.h
View File

@ -1,41 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//these definitions can be expanded to make normal prototypes, or functionpointers and dlsym lines
BOBLIGHT_FUNCTION(void*, boblight_init, ());
BOBLIGHT_FUNCTION(void, boblight_destroy, (void* vpboblight));
BOBLIGHT_FUNCTION(int, boblight_connect, (void* vpboblight, const char* address, int port, int usectimeout));
BOBLIGHT_FUNCTION(int, boblight_setpriority, (void* vpboblight, int priority));
BOBLIGHT_FUNCTION(const char*, boblight_geterror, (void* vpboblight));
BOBLIGHT_FUNCTION(int, boblight_getnrlights, (void* vpboblight));
BOBLIGHT_FUNCTION(const char*, boblight_getlightname, (void* vpboblight, int lightnr));
BOBLIGHT_FUNCTION(int, boblight_getnroptions, (void* vpboblight));
BOBLIGHT_FUNCTION(const char*, boblight_getoptiondescript,(void* vpboblight, int option));
BOBLIGHT_FUNCTION(int, boblight_setoption, (void* vpboblight, int lightnr, const char* option));
BOBLIGHT_FUNCTION(int, boblight_getoption, (void* vpboblight, int lightnr, const char* option, const char** output));
BOBLIGHT_FUNCTION(void, boblight_setscanrange, (void* vpboblight, int width, int height));
BOBLIGHT_FUNCTION(int, boblight_addpixel, (void* vpboblight, int lightnr, int* rgb));
BOBLIGHT_FUNCTION(void, boblight_addpixelxy, (void* vpboblight, int x, int y, int* rgb));
BOBLIGHT_FUNCTION(int, boblight_sendrgb, (void* vpboblight, int sync, int* outputused));
BOBLIGHT_FUNCTION(int, boblight_ping, (void* vpboblight, int* outputused));

103
include/boblight.h
View File

@ -1,103 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//if you define BOBLIGHT_DLOPEN, all boblight functions are defined as pointers
//you can then call boblight_loadlibrary to load libboblight with dlopen and the function pointers with dlsym
//if you pass NULL to boblight_loadlibrary's first argument, the default filename for libboblight is used
//if boblight_loadlibrary returns NULL, dlopen and dlsym went ok, if not it returns a char* from dlerror
//if you want to use the boblight functions from multiple files, you can define BOBLIGHT_DLOPEN in one file,
//and define BOBLIGHT_DLOPEN_EXTERN in the other file, the functionpointers are then defined as extern
#ifndef LIBBOBLIGHT
#define LIBBOBLIGHT
#if !defined(BOBLIGHT_DLOPEN) && !defined(BOBLIGHT_DLOPEN_EXTERN)
#ifdef __cplusplus
extern "C" {
#endif
//generate normal prototypes
#define BOBLIGHT_FUNCTION(returnvalue, name, arguments) returnvalue name arguments
#include "boblight-functions.h"
#undef BOBLIGHT_FUNCTION
#ifdef __cplusplus
}
#endif
#elif defined(BOBLIGHT_DLOPEN)
#include <dlfcn.h>
#include <stddef.h>
//generate function pointers
#define BOBLIGHT_FUNCTION(returnvalue, name, arguments) returnvalue (* name ) arguments = NULL
#include "boblight-functions.h"
#undef BOBLIGHT_FUNCTION
#ifdef __cplusplus
#define BOBLIGHT_CAST(value) reinterpret_cast<value>
#else
#define BOBLIGHT_CAST(value) (value)
#endif
//gets a functionpointer from dlsym, and returns char* from dlerror if it didn't work
#define BOBLIGHT_FUNCTION(returnvalue, name, arguments) \
name = BOBLIGHT_CAST(returnvalue (*) arguments)(dlsym(p_boblight, #name)); \
{ char* error = dlerror(); if (error) return error; }
void* p_boblight = NULL; //where we put the lib
//load function pointers
char* boblight_loadlibrary(const char* filename)
{
if (filename == NULL)
filename = "libboblight.so";
if (p_boblight != NULL)
{
dlclose(p_boblight);
p_boblight = NULL;
}
p_boblight = dlopen(filename, RTLD_NOW);
if (p_boblight == NULL)
return dlerror();
//generate dlsym lines
#include "boblight-functions.h"
return NULL;
}
#undef BOBLIGHT_FUNCTION
#undef BOBLIGHT_CAST
//you can define BOBLIGHT_DLOPEN_EXTERN when you load the library in another file
#elif defined(BOBLIGHT_DLOPEN_EXTERN)
extern char* boblight_loadlibrary(const char* filename);
extern void* p_boblight;
#define BOBLIGHT_FUNCTION(returnvalue, name, arguments) extern returnvalue (* name ) arguments
#include "boblight-functions.h"
#undef BOBLIGHT_FUNCTION
#endif //BOBLIGHT_DLOPEN_EXTERN
#endif //LIBBOBLIGHT

32
include/hyperion/DispmanxWrapper.h Normal file
View File

@ -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;
};

26
include/hyperion/Hyperion.h
View File

@ -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;
};

72
include/hyperion/ImageProcessor.h Normal file
View File

@ -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:
~ImageProcessor();
/**
* 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);
private:
const LedString mLedString;
RgbImage *mBuffer;
hyperion::ImageToLedsMap* mImageToLeds;
};

26
include/hyperion/ImageProcessorFactory.h Normal file
View File

@ -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;
};

27
include/hyperion/ImageToLedsMap.h
View File

@ -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;
};

18
include/hyperion/LedString.h
View File

@ -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;
};

55
include/hyperion/PriorityMuxer.h Normal file
View File

@ -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();
};

5
include/utils/RgbColor.h
View File

@ -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) << "}";

22
libsrc/CMakeLists.txt
View File

@ -3,25 +3,7 @@
SET(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include)
SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc)
add_library(bob2hyperion SHARED
bob2hyperion.cpp)
target_link_libraries(bob2hyperion
hyperion
hyperion-utils)
# Find the libPNG
find_package(PNG REQUIRED QUIET)
# Add additional includes dirs
include_directories(${PNG_INCLUDE_DIR})
add_library(bob2hyperion-png SHARED
hyperion-png.cpp)
target_link_libraries(bob2hyperion-png
hyperion-png)
add_subdirectory(hyperion)
add_subdirectory(hyperionpng)
add_subdirectory(utils)
add_subdirectory(hyperionpng)

141
libsrc/bob2hyperion.cpp
View File

@ -1,141 +0,0 @@
// SysLog includes
#include <syslog.h>
// Boblight includes
#include "boblight.h"
// JsonSchema includes
#include <utils/jsonschema/JsonFactory.h>
// Raspilight includes
#include <hyperion/Hyperion.h>
static std::ofstream sDebugStream;
inline Hyperion* rasp_cast(void* hyperion_ptr)
{
return reinterpret_cast<Hyperion*>(hyperion_ptr);
}
void* boblight_init()
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
// syslog(LOG_INFO, __PRETTY_FUNCTION__);
const char* homeDir = getenv("RASPILIGHT_HOME");
if (!homeDir)
{
homeDir = "/etc";
}
syslog(LOG_INFO, "RASPILIGHT HOME DIR: %s", homeDir);
const std::string schemaFile = std::string(homeDir) + "/hyperion.schema.json";
const std::string configFile = std::string(homeDir) + "/hyperion.config.json";
Json::Value raspiConfig;
if (JsonFactory::load(schemaFile, configFile, raspiConfig) < 0)
{
syslog(LOG_WARNING, "UNABLE TO LOAD CONFIGURATION");
return 0;
}
Hyperion* raspiLight = new Hyperion(raspiConfig);
return reinterpret_cast<void*>(raspiLight);
}
void boblight_destroy(void* hyperion_ptr)
{
syslog(LOG_INFO, __PRETTY_FUNCTION__);
Hyperion* raspiLight = rasp_cast(hyperion_ptr);
// Switch all leds to black (off)
raspiLight->setColor(RgbColor::BLACK);
delete raspiLight;
sDebugStream.close();
}
void boblight_setscanrange(void* hyperion_ptr, int width, int height)
{
syslog(LOG_INFO, __PRETTY_FUNCTION__);
syslog(LOG_INFO, "Configuring scan range [%dx%d]", width, height);
Hyperion* raspiLight = rasp_cast(hyperion_ptr);
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);
}
int boblight_sendrgb(void* hyperion_ptr, int sync, int* outputused)
{
Hyperion* raspiLight = rasp_cast(hyperion_ptr);
raspiLight->commit();
return 1;
}
int boblight_connect(void* hyperion_ptr, const char* address, int port, int usectimeout)
{
std::cout << "SUCCESFULL NO CONNECTION WITH BOBLIGHT" << std::endl;
return 1;
}
const char* boblight_geterror(void* hyperion_ptr)
{
return "ERROR";
}
int boblight_setpriority(void* hyperion_ptr, int priority)
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
return 1;
}
int boblight_getnrlights(void* hyperion_ptr)
{
return 1;
}
const char* boblight_getlightname(void* hyperion_ptr, int lightnr)
{
return "LIGHT_NAME";
}
int boblight_getnroptions(void* hyperion_ptr)
{
return 1;
}
const char* boblight_getoptiondescript(void* hyperion_ptr, int option)
{
return "OPTION-DESCRIPTION";
}
int boblight_setoption(void* hyperion_ptr, int lightnr, const char* option)
{
return 1;
}
int boblight_getoption(void* hyperion_ptr, int lightnr, const char* option, const char** output)
{
return 1;
}
int boblight_addpixel(void* hyperion_ptr, int lightnr, int* rgb)
{
return 1;
}
int boblight_ping(void* hyperion_ptr, int* outputused)
{
return 1;
}

174
libsrc/hyperion-png.cpp
View File

@ -1,174 +0,0 @@
// STL includes
#include <fstream>
#include <sstream>
#include <iostream>
// Boblight includes
#include <boblight.h>
// PNGWriter includes
#define NO_FREETYPE
#include "hyperionpng/pngwriter.h"
struct RaspiPng
{
pngwriter writer;
unsigned long fileIndex;
unsigned frameCnt;
std::ofstream logFile;
};
void* boblight_init()
{
RaspiPng* raspiPng = new RaspiPng();
raspiPng->writer.pngwriter_rename("/home/pi/RASPI_0000.png");
raspiPng->fileIndex = 0;
raspiPng->frameCnt = 0;
raspiPng->logFile.open("/home/pi/raspipng.log");
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return reinterpret_cast<void*>(raspiPng);
}
void boblight_destroy(void* vpboblight)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
raspiPng->logFile.close();
delete raspiPng;
}
void boblight_setscanrange(void* vpboblight, int width, int height)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << "(" << width << ", " << height << ")" << std::endl;
raspiPng->writer.resize(width, height);
}
void boblight_addpixelxy(void* vpboblight, int x, int y, int* rgb)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
if (raspiPng->frameCnt%50 == 0)
{
// NB libpngwriter uses a one-based indexing scheme
raspiPng->writer.plot(x+1,y+1, rgb[0]/255.0, rgb[1]/255.0, rgb[2]/255.0);
}
}
int boblight_sendrgb(void* vpboblight, int sync, int* outputused)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << "(" << sync << ", outputused) FRAME " << raspiPng->frameCnt++ << std::endl;
if (raspiPng->frameCnt%50 == 0)
{
// Write-out the current frame and prepare for the next
raspiPng->writer.write_png();
++raspiPng->fileIndex;
char filename[64];
sprintf(filename, "/home/pi/RASPI_%04ld.png", raspiPng->fileIndex);
raspiPng->writer.pngwriter_rename(filename);
}
return 1;
}
int boblight_connect(void* vpboblight, const char* address, int port, int usectimeout)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 1;
}
int boblight_setpriority(void* vpboblight, int priority)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 1;
}
const char* boblight_geterror(void* vpboblight)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return "ERROR";
}
int boblight_getnrlights(void* vpboblight)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 50;
}
const char* boblight_getlightname(void* vpboblight, int lightnr)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return "LIGHT";
}
int boblight_getnroptions(void* vpboblight)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 1;
}
const char* boblight_getoptiondescript(void* vpboblight, int option)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return "";
}
int boblight_setoption(void* vpboblight, int lightnr, const char* option)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 1;
}
int boblight_getoption(void* vpboblight, int lightnr, const char* option, const char** output)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 1;
}
int boblight_addpixel(void* vpboblight, int lightnr, int* rgb)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 1;
}
int boblight_ping(void* vpboblight, int* outputused)
{
RaspiPng* raspiPng = reinterpret_cast<RaspiPng*>(vpboblight);
raspiPng->logFile << __PRETTY_FUNCTION__ << std::endl;
return 1;
}

51
libsrc/hyperion/CMakeLists.txt
View File

@ -1,22 +1,57 @@
# 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
# Group the headers that go through the MOC compiler
SET(Hyperion_QT_HEADERS
${CURRENT_HEADER_DIR}/DispmanxWrapper.h
)
SET(Hyperion_HEADERS
${CURRENT_HEADER_DIR}/LedString.h
${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_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}/ImageToLedsMap.cpp
${CURRENT_SOURCE_DIR}/ColorTransform.h
${CURRENT_SOURCE_DIR}/ColorTransform.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.cpp
)
QT4_WRAP_CPP(Hyperion_HEADERS_MOC ${Hyperion_QT_HEADERS})
add_library(hyperion
${Hyperion_HEADERS}
${Hyperion_QT_HEADERS}
${Hyperion_HEADERS_MOC}
${Hyperion_SOURCES}
)
target_link_libraries(hyperion
hyperion-utils)
hyperion-utils
${QT_LIBRARIES}
${BCM_LIBRARIES})

97
libsrc/hyperion/ColorTransform.cpp
View File

@ -1,23 +1,26 @@
// STL includes
#include <cmath>
#include "ColorTransform.h"
using namespace hyperion;
ColorTransform::ColorTransform() :
_threshold(0),
_gamma(1.0),
_blacklevel(0.0),
_whitelevel(1.0)
_threshold(0),
_gamma(1.0),
_blacklevel(0.0),
_whitelevel(1.0)
{
initializeMapping();
initializeMapping();
}
ColorTransform::ColorTransform(double threshold, double gamma, double blacklevel, double whitelevel) :
_threshold(threshold),
_gamma(gamma),
_blacklevel(blacklevel),
_whitelevel(whitelevel)
_threshold(threshold),
_gamma(gamma),
_blacklevel(blacklevel),
_whitelevel(whitelevel)
{
initializeMapping();
initializeMapping();
}
ColorTransform::~ColorTransform()
@ -26,77 +29,77 @@ ColorTransform::~ColorTransform()
double ColorTransform::getThreshold() const
{
return _threshold;
return _threshold;
}
void ColorTransform::setThreshold(double threshold)
{
_threshold = threshold;
initializeMapping();
_threshold = threshold;
initializeMapping();
}
double ColorTransform::getGamma() const
{
return _gamma;
return _gamma;
}
void ColorTransform::setGamma(double gamma)
{
_gamma = gamma;
initializeMapping();
_gamma = gamma;
initializeMapping();
}
double ColorTransform::getBlacklevel() const
{
return _blacklevel;
return _blacklevel;
}
void ColorTransform::setBlacklevel(double blacklevel)
{
_blacklevel = blacklevel;
initializeMapping();
_blacklevel = blacklevel;
initializeMapping();
}
double ColorTransform::getWhitelevel() const
{
return _whitelevel;
return _whitelevel;
}
void ColorTransform::setWhitelevel(double whitelevel)
{
_whitelevel = whitelevel;
initializeMapping();
_whitelevel = whitelevel;
initializeMapping();
}
void ColorTransform::initializeMapping()
{
// initialize the mapping as a linear array
for (int i = 0; i < 256; ++i)
{
double output = i / 255.0;
// initialize the mapping as a linear array
for (int i = 0; i < 256; ++i)
{
double output = i / 255.0;
// apply linear transform
if (output < _threshold)
{
output = 0.0;
}
// apply linear transform
if (output < _threshold)
{
output = 0.0;
}
// apply gamma correction
output = std::pow(output, _gamma);
// apply gamma correction
output = std::pow(output, _gamma);
// apply blacklevel and whitelevel
output = _blacklevel + (_whitelevel - _blacklevel) * output;
// apply blacklevel and whitelevel
output = _blacklevel + (_whitelevel - _blacklevel) * output;
// calc mapping
int mappingValue = output * 255;
if (mappingValue < 0)
{
mappingValue = 0;
}
else if (mappingValue > 255)
{
mappingValue = 255;
}
_mapping[i] = mappingValue;
}
// calc mapping
int mappingValue = output * 255;
if (mappingValue < 0)
{
mappingValue = 0;
}
else if (mappingValue > 255)
{
mappingValue = 255;
}
_mapping[i] = mappingValue;
}
}

52
libsrc/hyperion/ColorTransform.h
View File

@ -1,6 +1,10 @@
#pragma once
#include "stdint.h"
// STL includes
#include <cstdint>
namespace hyperion
{
/// Transform for a single color byte value
///
@ -14,36 +18,38 @@
class ColorTransform
{
public:
ColorTransform();
ColorTransform(double threshold, double gamma, double whitelevel, double blacklevel);
~ColorTransform();
ColorTransform();
ColorTransform(double threshold, double gamma, double blacklevel, double whitelevel);
~ColorTransform();
double getThreshold() const;
void setThreshold(double threshold);
double getThreshold() const;
void setThreshold(double threshold);
double getGamma() const;
void setGamma(double gamma);
double getGamma() const;
void setGamma(double gamma);
double getBlacklevel() const;
void setBlacklevel(double blacklevel);
double getBlacklevel() const;
void setBlacklevel(double blacklevel);
double getWhitelevel() const;
void setWhitelevel(double whitelevel);
double getWhitelevel() const;
void setWhitelevel(double whitelevel);
/// get the transformed value for the given byte value
uint8_t transform(uint8_t input) const
{
return _mapping[input];
}
/// get the transformed value for the given byte value
uint8_t transform(uint8_t input) const
{
return _mapping[input];
}
private:
void initializeMapping();
void initializeMapping();
private:
double _threshold;
double _gamma;
double _blacklevel;
double _whitelevel;
double _threshold;
double _gamma;
double _blacklevel;
double _whitelevel;
uint8_t _mapping[256];
uint8_t _mapping[256];
};
} // end namespace hyperion

56
libsrc/hyperion/DispmanxFrameGrabber.cpp Normal file
View File

@ -0,0 +1,56 @@
#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);
// Make the compiler (in release mode) happy by 'using' ret
(void)ret;
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);
}

36
libsrc/hyperion/DispmanxFrameGrabber.h Normal file
View File

@ -0,0 +1,36 @@
#pragma once
// BCM includes
#pragma GCC system_header
#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;
};

49
libsrc/hyperion/DispmanxWrapper.cpp Normal file
View File

@ -0,0 +1,49 @@
// QT includes
#include <QDebug>
#include <QDateTime>
// Hyperion includes
#include <hyperion/DispmanxWrapper.h>
#include <hyperion/ImageProcessorFactory.h>
#include <hyperion/ImageProcessor.h>
// Local-Hyperion includes
#include "DispmanxFrameGrabber.h"
DispmanxWrapper::DispmanxWrapper() :
_timer(),
_frameGrabber(new DispmanxFrameGrabber(64, 64)),
_processor(ImageProcessorFactory::getInstance().newImageProcessor())
{
_timer.setInterval(100);
_timer.setSingleShot(false);
_processor->setSize(64, 64);
QObject::connect(&_timer, SIGNAL(timeout()), this, SLOT(action()));
}
DispmanxWrapper::~DispmanxWrapper()
{
delete _processor;
delete _frameGrabber;
}
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();
}

104
libsrc/hyperion/Hyperion.cpp
View File

@ -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);
}
}

65
libsrc/hyperion/ImageProcessor.cpp Normal file
View File

@ -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);
}

21
libsrc/hyperion/ImageProcessorFactory.cpp Normal file
View File

@ -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);
}

46
libsrc/hyperion/ImageToLedsMap.cpp
View File

@ -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};
}

57
libsrc/hyperion/ImageToLedsMap.h Normal file
View File

@ -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

40
libsrc/hyperion/LedString.cpp
View File

@ -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;

94
libsrc/hyperion/PriorityMuxer.cpp Normal file
View File

@ -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;
}
}
}

2258
libsrc/hyperionpng/pngwriter.cc
View File

File diff suppressed because it is too large Load Diff

38
src/CMakeLists.txt
View File

@ -2,38 +2,11 @@
add_executable(WriteConfig
WriteConfig.cpp)
add_executable(boblight-dispmanx
boblight-dispmanx.cpp
flagmanager.h
flagmanager.cpp
flagmanager-dispmanx.h
flagmanager-dispmanx.cpp
grabber-dispmanx.h
grabber-dispmanx.cpp
misc.h
misc.cpp
timer.h
timer.cpp
timeutils.h
timeutils.cpp)
# Find the BCM-package (VC control)
find_package(BCM REQUIRED)
include_directories(${BCM_INCLUDE_DIRS})
target_link_libraries(boblight-dispmanx
# hyperion-png
bob2hyperion
${BCM_LIBRARIES})
add_executable(HyperionDispmanX
HyperionDispmanX.cpp)
target_link_libraries(HyperionDispmanX
hyperion
${BCM_LIBRARIES})
add_executable(hyperiond
hyperion-d.cpp)
target_link_libraries(hyperiond
hyperion)
# Find the libPNG
find_package(PNG QUIET)
@ -47,10 +20,7 @@ if(PNG_FOUND)
target_link_libraries(ViewPng
hyperion
hyperion-utils
${PNG_LIBRARIES})
endif(PNG_FOUND)
add_subdirectory(dispmanx-png)
add_subdirectory(hyperion-remote)

49
src/HyperionDispmanX.cpp
View File

@ -1,49 +0,0 @@
// VC includes
#include <bcm_host.h>
// Hyperion includes
#include <hyperion/Hyperion.h>
#include <json/json.h>
#include <utils/jsonschema/JsonFactory.h>
#include "dispmanx-helper.h"
static volatile bool sRunning = true;
void signal_handler(int signum)
{
std::cout << "RECEIVED SIGNAL: " << signum << std::endl;
sRunning = false;
}
int main(int /*argc*/, char** /*argv*/)
{
// Install signal-handlers to exit the processing loop
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
const char* homeDir = getenv("RASPILIGHT_HOME");
if (!homeDir)
{
homeDir = "/etc";
}
std::cout << "RASPILIGHT HOME DIR: " << homeDir << std::endl;
const std::string schemaFile = std::string(homeDir) + "/hyperion.schema.json";
const std::string configFile = std::string(homeDir) + "/hyperion.config.json";
Json::Value raspiConfig;
if (JsonFactory::load(schemaFile, configFile, raspiConfig) < 0)
{
std::cerr << "UNABLE TO LOAD CONFIGURATION" << std::endl;
return -1;
}
Hyperion hyperion(raspiConfig);
dispmanx_process(hyperion, sRunning);
return 0;
}

4
src/ViewPng.cpp
View File

@ -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);

179
src/boblight-dispmanx.cpp
View File

@ -1,179 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//#define BOBLIGHT_DLOPEN
#include "boblight.h"
#include <iostream>
#include <string>
#include <vector>
#include <signal.h>
#include <unistd.h>
//#include "config.h"
#include "misc.h"
#include "flagmanager-dispmanx.h"
#include "grabber-dispmanx.h"
//OpenMax includes
#include "bcm_host.h"
#include <assert.h>
using namespace std;
#define TEST_SAVE_IMAGE 0
#define PRINT_RET_VAL(ret, func, ...) ret = func(__VA_ARGS__); printf(#func " returned %d\n", ret);
int Run();
void SignalHandler(int signum);
volatile bool stop = false;
CFlagManagerDispmanX g_flagmanager;
int main(int argc, char *argv[])
{
std::cout << "HACKED VERSION WITH TIMOLIGHT" << std::endl;
//load the boblight lib, if it fails we get a char* from dlerror()
// char* boblight_error = boblight_loadlibrary(NULL);
// if (boblight_error)
// {
// PrintError(boblight_error);
// return 1;
// }
//try to parse the flags and bitch to stderr if there's an error
try
{
g_flagmanager.ParseFlags(argc, argv);
}
catch (string error)
{
PrintError(error);
g_flagmanager.PrintHelpMessage();
return 1;
}
if (g_flagmanager.m_printhelp) //print help message
{
g_flagmanager.PrintHelpMessage();
return 1;
}
if (g_flagmanager.m_printboblightoptions) //print boblight options (-o [light:]option=value)
{
g_flagmanager.PrintBoblightOptions();
return 1;
}
if (g_flagmanager.m_fork)
{
if (fork())
return 0;
}
//set up signal handlers
signal(SIGTERM, SignalHandler);
signal(SIGINT, SignalHandler);
//keep running until we want to quit
return Run();
}
int Run()
{
while(!stop)
{
//init boblight
void* boblight = boblight_init();
cout << "Connecting to boblightd\n";
//try to connect, if we can't then bitch to stderr and destroy boblight
if (!boblight_connect(boblight, g_flagmanager.m_address, g_flagmanager.m_port, 5000000) ||
!boblight_setpriority(boblight, g_flagmanager.m_priority))
{
PrintError(boblight_geterror(boblight));
cout << "Waiting 10 seconds before trying again\n";
boblight_destroy(boblight);
sleep(10);
continue;
}
cout << "Connection to boblightd opened\n";
//try to parse the boblight flags and bitch to stderr if we can't
try
{
g_flagmanager.ParseBoblightOptions(boblight);
}
catch (string error)
{
PrintError(error);
return 1;
}
CGrabberDispmanX *grabber = new CGrabberDispmanX(boblight, stop, g_flagmanager.m_sync);
grabber->SetInterval(g_flagmanager.m_interval);
grabber->SetSize(g_flagmanager.m_pixels);
if (!grabber->Setup()) //just exit if we can't set up the grabber
{
PrintError(grabber->GetError());
delete grabber;
boblight_destroy(boblight);
return 1;
}
if (!grabber->Run()) //just exit if some unrecoverable error happens
{
PrintError(grabber->GetError());
delete grabber;
boblight_destroy(boblight);
return 1;
}
else //boblightd probably timed out, so just try to reconnect
{
if (!grabber->GetError().empty())
PrintError(grabber->GetError());
}
delete grabber;
boblight_destroy(boblight);
}
cout << "Exiting\n";
return 0;
}
void SignalHandler(int signum)
{
if (signum == SIGTERM)
{
cout << "caught SIGTERM\n";
stop = true;
}
else if (signum == SIGINT)
{
cout << "caught SIGINT\n";
stop = true;
}
}

59
src/dispmanx-helper.h
View File

@ -1,59 +0,0 @@
#pragma once
// VC includes
#include <bcm_host.h>
template <typename Hyperion_T>
int dispmanx_process(Hyperion_T& hyperion, volatile bool& running)
{
// Configure the used image size
const unsigned width = 64;
const unsigned height = 64;
hyperion.setInputSize(width, height);
// Initiase BCM
bcm_host_init();
// Open the connection to the displaydisplay
DISPMANX_DISPLAY_HANDLE_T display = vc_dispmanx_display_open(0);
DISPMANX_MODEINFO_T info;
int ret = vc_dispmanx_display_get_info(display, &info);
assert(ret == 0);
// Create the resources for capturing image
uint32_t vc_image_ptr;
DISPMANX_RESOURCE_HANDLE_T resource = vc_dispmanx_resource_create(
VC_IMAGE_RGB888,
width,
height,
&vc_image_ptr);
assert(resource);
VC_RECT_T rectangle;
vc_dispmanx_rect_set(&rectangle, 0, 0, width, height);
void* image_ptr = hyperion.image().memptr();
const uint32_t pitch = width * 3;
timespec updateInterval;
updateInterval.tv_sec = 0;
updateInterval.tv_nsec = 100000000;
while(running)
{
vc_dispmanx_snapshot(display, resource, VC_IMAGE_ROT0);
vc_dispmanx_resource_read_data(resource, &rectangle, image_ptr, pitch);
hyperion.commit();
nanosleep(&updateInterval, NULL);
}
// Clean up resources
vc_dispmanx_resource_delete(resource);
vc_dispmanx_display_close(display);
// De-init BCM
bcm_host_deinit();
return 0;
}

13
src/dispmanx-png/CMakeLists.txt
View File

@ -1,13 +0,0 @@
# Find the BCM-package (VC control)
find_package(BCM REQUIRED)
# Add the include dirs to the search path
include_directories(${BCM_INCLUDE_DIRS})
add_executable(dispmanx-png
dispmanx-png.cpp)
target_link_libraries(dispmanx-png
hyperion-png
${BCM_LIBRARIES})

28
src/dispmanx-png/dispmanx-png.cpp
View File

@ -1,28 +0,0 @@
// STL includes
#include <csignal>
// Hyperion includes
#include <hyperionpng/HyperionPng.h>
#include "../dispmanx-helper.h"
static volatile bool sRunning = true;
void signal_handler(int signum)
{
std::cout << "RECEIVED SIGNAL: " << signum << std::endl;
sRunning = false;
}
int main(int /*argc*/, char** /*argv*/)
{
// Install signal-handlers to exit the processing loop
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
// Construct and initialise the PNG creator with preset size
HyperionPng hyperion;
return dispmanx_process(hyperion, sRunning);
}

106
src/flagmanager-dispmanx.cpp
View File

@ -1,106 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include "flagmanager-dispmanx.h"
//#include "config.h"
#include "misc.h"
using namespace std;
CFlagManagerDispmanX::CFlagManagerDispmanX()
{
//extend the base getopt flags
//i = interval, u = pixels, x = xgetimage, d = debug
m_flags += "i:u:d::";
m_interval = 0.1; //default interval is 100 milliseconds
m_pixels = 64; //-1 says to the capture classes to use default
m_debug = false; //no debugging by default
m_debugdpy = NULL; //default debug dpy is system default
m_sync = true; //sync mode enabled by default
}
void CFlagManagerDispmanX::ParseFlagsExtended(int& argc, char**& argv, int& c, char*& optarg) //we load our own flags here
{
if (c == 'i') //interval
{
bool vblank = false;
if (optarg[0] == 'v') //starting interval with v means vblank interval
{
#ifdef HAVE_LIBGL
optarg++;
vblank = true;
#else
throw string("Compiled without opengl support");
#endif
}
if (!StrToFloat(optarg, m_interval) || m_interval <= 0.0)
{
throw string("Wrong value " + string(optarg) + " for interval");
}
if (vblank)
{
if (m_interval < 1.0)
{
throw string("Wrong value " + string(optarg) + " for vblank interval");
}
m_interval *= -1.0; //negative interval means vblank
optarg--;
}
}
else if (c == 'u') //nr of pixels to use
{
if (!StrToInt(optarg, m_pixels) || m_pixels <= 0)
{
throw string("Wrong value " + string(optarg) + " for pixels");
}
}
else if (c == 'd') //turn on debug mode
{
m_debug = true;
if (optarg) //optional debug dpy
{
m_strdebugdpy = optarg;
m_debugdpy = m_strdebugdpy.c_str();
}
}
}
void CFlagManagerDispmanX::PrintHelpMessage()
{
cout << "Usage: boblight-dispmanx [OPTION]\n";
cout << "\n";
cout << " options:\n";
cout << "\n";
cout << " -p priority, from 0 to 255, default is 128\n";
cout << " -s address:[port], set the address and optional port to connect to\n";
cout << " -o add libboblight option, syntax: [light:]option=value\n";
cout << " -l list libboblight options\n";
cout << " -i set the interval in seconds, default is 0.1\n";
cout << " -u set the number of pixels/rows to use\n";
cout << " default is 64 for xrender and 16 for xgetimage\n";
cout << " -d debug mode\n";
cout << " -f fork\n";
cout << " -y set the sync mode, default is on, valid options are \"on\" and \"off\"\n";
cout << "\n";
}

44
src/flagmanager-dispmanx.h
View File

@ -1,44 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef FLAGMANAGERDISPMANX
#define FLAGMANAGERDISPMANX
#include "flagmanager.h"
class CFlagManagerDispmanX : public CFlagManager
{
public:
CFlagManagerDispmanX();
int m_color;
void ParseFlagsExtended(int& argc, char**& argv, int& c, char*& optarg); //we load our own flags here
void PrintHelpMessage();
double m_interval; //grab interval in seconds, or vertical blanks when negative
int m_pixels; //number of pixels on lines to capture
bool m_debug; //if true we make a little window where we put our captured output on, looks pretty
const char* m_debugdpy; //display to place the debug window on, default is NULL
private:
std::string m_strdebugdpy; //place to store the debug dpy, cause our copied argv is destroyed
};
#endif //FLAGMANAGEROPENMAX

257
src/flagmanager.cpp
View File

@ -1,257 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include <unistd.h>
#include <iostream>
#include "flagmanager.h"
#include "misc.h"
//#define BOBLIGHT_DLOPEN_EXTERN
#include "boblight.h"
using namespace std;
//very simple, store a copy of argc and argv
CArguments::CArguments(int argc, char** argv)
{
m_argc = argc;
if (m_argc == 0)
{
m_argv = NULL;
}
else
{
m_argv = new char*[m_argc];
for (int i = 0; i < m_argc; i++)
{
m_argv[i] = new char[strlen(argv[i]) + 1];
strcpy(m_argv[i], argv[i]);
}
}
}
//delete the copy of argv
CArguments::~CArguments()
{
if (m_argv)
{
for (int i = 0; i < m_argc; i++)
{
delete[] m_argv[i];
}
delete[] m_argv;
}
}
CFlagManager::CFlagManager()
{
m_port = -1; //-1 tells libboblight to use default port
m_address = NULL; //NULL tells libboblight to use default address
m_priority = 128; //default priority
m_printhelp = false; //don't print helpmessage unless asked to
m_printboblightoptions = false; //same for libboblight options
m_fork = false; //don't fork by default
m_sync = false; //sync mode disabled by default
// default getopt flags, can be extended in derived classes
// p = priority, s = address[:port], o = boblight option, l = list boblight options, h = print help message, f = fork
m_flags = "p:s:o:lhfy:";
}
void CFlagManager::ParseFlags(int tempargc, char** tempargv)
{
//that copy class sure comes in handy now!
CArguments arguments(tempargc, tempargv);
int argc = arguments.m_argc;
char** argv = arguments.m_argv;
string option;
int c;
opterr = 0; //we don't want to print error messages
while ((c = getopt(argc, argv, m_flags.c_str())) != -1)
{
if (c == 'p') //priority
{
option = optarg;
if (!StrToInt(option, m_priority) || m_priority < 0 || m_priority > 255)
{
throw string("Wrong option " + string(optarg) + " for argument -p");
}
}
else if (c == 's') //address[:port]
{
option = optarg;
//store address in string and set the char* to it
m_straddress = option.substr(0, option.find(':'));
m_address = m_straddress.c_str();
if (option.find(':') != string::npos) //check if we have a port
{
option = option.substr(option.find(':') + 1);
string word;
if (!StrToInt(option, m_port) || m_port < 0 || m_port > 65535)
{
throw string("Wrong option " + string(optarg) + " for argument -s");
}
}
}
else if (c == 'o') //option for libboblight
{
m_options.push_back(optarg);
}
else if (c == 'l') //list libboblight options
{
m_printboblightoptions = true;
return;
}
else if (c == 'h') //print help message
{
m_printhelp = true;
return;
}
else if (c == 'f')
{
m_fork = true;
}
else if (c == 'y')
{
if (!StrToBool(optarg, m_sync))
{
throw string("Wrong value " + string(optarg) + " for sync mode");
}
}
else if (c == '?') //unknown option
{
//check if we know this option, but expected an argument
if (m_flags.find(ToString((char)optopt) + ":") != string::npos)
{
throw string("Option " + ToString((char)optopt) + "requires an argument");
}
else
{
throw string("Unkown option " + ToString((char)optopt));
}
}
else
{
ParseFlagsExtended(argc, argv, c, optarg); //pass our argument to a derived class
}
}
PostGetopt(optind, argc, argv); //some postprocessing
}
//go through all options and print the descriptions to stdout
void CFlagManager::PrintBoblightOptions()
{
void* boblight = boblight_init();
int nroptions = boblight_getnroptions(boblight);
for (int i = 0; i < nroptions; i++)
{
cout << boblight_getoptiondescript(boblight, i) << "\n";
}
boblight_destroy(boblight);
}
void CFlagManager::ParseBoblightOptions(void* boblight)
{
int nrlights = boblight_getnrlights(boblight);
for (int i = 0; i < m_options.size(); i++)
{
string option = m_options[i];
string lightname;
string optionname;
string optionvalue;
int lightnr = -1;
//check if we have a lightname, otherwise we use all lights
if (option.find(':') != string::npos)
{
lightname = option.substr(0, option.find(':'));
if (option.find(':') == option.size() - 1) //check if : isn't the last char in the string
{
throw string("wrong option \"" + option + "\", syntax is [light:]option=value");
}
option = option.substr(option.find(':') + 1); //shave off the lightname
//check which light this is
bool lightfound = false;
for (int j = 0; j < nrlights; j++)
{
if (lightname == boblight_getlightname(boblight, j))
{
lightfound = true;
lightnr = j;
break;
}
}
if (!lightfound)
{
throw string("light \"" + lightname + "\" used in option \"" + m_options[i] + "\" doesn't exist");
}
}
//check if '=' exists and it's not at the end of the string
if (option.find('=') == string::npos || option.find('=') == option.size() - 1)
{
throw string("wrong option \"" + option + "\", syntax is [light:]option=value");
}
optionname = option.substr(0, option.find('=')); //option name is everything before = (already shaved off the lightname here)
optionvalue = option.substr(option.find('=') + 1); //value is everything after =
option = optionname + " " + optionvalue; //libboblight wants syntax without =
//bitch if we can't set this option
if (!boblight_setoption(boblight, lightnr, option.c_str()))
{
throw string(boblight_geterror(boblight));
}
}
}
bool CFlagManager::SetVideoGamma()
{
for (int i = 0; i < m_options.size(); i++)
{
string option = m_options[i];
if (option.find(':') != string::npos)
option = option.substr(option.find(':') + 1); //shave off the lightname
if (option.find('=') != string::npos)
{
if (option.substr(0, option.find('=')) == "gamma")
return false; //gamma set by user, don't override
}
}
m_options.push_back("gamma=" + ToString(VIDEOGAMMA));
cout << "Gamma not set, using " << VIDEOGAMMA << " since this is default for video\n";
return true;
}

72
src/flagmanager.h
View File

@ -1,72 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef FLAGMANAGER
#define FLAGMANAGER
#define VIDEOGAMMA 2.2
#include <string>
#include <vector>
//class for making a copy of argc and argv
class CArguments
{
public:
CArguments(int argc, char** argv);
~CArguments();
int m_argc;
char** m_argv;
};
class CFlagManager
{
public:
CFlagManager();
bool m_printhelp; //if we need to print the help message
bool m_printboblightoptions; //if we need to print the boblight options
const char* m_address; //address to connect to, set to NULL if none given for default
int m_port; //port to connect to, set to -1 if none given for default
int m_priority; //priority, set to 128 if none given for default
bool m_fork; //if we should fork
bool m_sync; //if sync mode is enabled
void ParseFlags(int tempargc, char** tempargv); //parsing commandline flags
virtual void PrintHelpMessage() {};
void PrintBoblightOptions(); //printing of boblight options (-o [light:]option=value)
void ParseBoblightOptions(void* boblight); //parsing of boblight options
bool SetVideoGamma(); //set gamma to 2.2 if not given, returns true if done
protected:
std::string m_flags; //string to pass to getopt, for example "c:r:a:p"
std::string m_straddress; //place to store address to connect to, because CArguments deletes argv
std::vector<std::string> m_options; //place to store boblight options
//gets called from ParseFlags, for derived classes
virtual void ParseFlagsExtended(int& argc, char**& argv, int& c, char*& optarg){};
//gets called after getopt
virtual void PostGetopt(int optind, int argc, char** argv) {};
};
#endif //FLAGMANAGER

165
src/grabber-dispmanx.cpp
View File

@ -1,165 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "stdint.h"
#include "grabber-dispmanx.h"
#include <string.h>
#include <assert.h>
#include "misc.h"
//#define BOBLIGHT_DLOPEN_EXTERN
#include "boblight.h"
using namespace std;
CGrabberDispmanX::CGrabberDispmanX(void* boblight, volatile bool& stop, bool sync) : m_stop(stop), m_timer(&stop)
{
int ret;
bcm_host_init();
m_boblight = boblight;
m_debug = false;
m_sync = sync;
type = VC_IMAGE_RGB888;
display = vc_dispmanx_display_open(0);
ret = vc_dispmanx_display_get_info(display, &info);
assert(ret == 0);
}
CGrabberDispmanX::~CGrabberDispmanX()
{
int ret;
free(image);
ret = vc_dispmanx_resource_delete(resource);
assert( ret == 0 );
ret = vc_dispmanx_display_close(display);
assert( ret == 0 );
bcm_host_deinit();
}
bool CGrabberDispmanX::Setup()
{
if (m_interval > 0.0) //set up timer
{
m_timer.SetInterval(Round64(m_interval * 1000000.0));
}
pitch = ALIGN_UP(m_size*3, 32);
image = new char[m_size * m_size * 3];
resource = vc_dispmanx_resource_create(type,
m_size,
m_size,
&vc_image_ptr );
assert(resource);
m_error.clear();
return ExtendedSetup(); //run stuff from derived classes
}
bool CGrabberDispmanX::ExtendedSetup()
{
if (!CheckExtensions())
return false;
return true;
}
bool CGrabberDispmanX::CheckExtensions()
{
return true;
}
bool CGrabberDispmanX::Run()
{
int rgb[3];
VC_RECT_T rectangle;
char* image_ptr;
boblight_setscanrange(m_boblight, m_size, m_size);
while(!m_stop)
{
vc_dispmanx_snapshot(display,resource, VC_IMAGE_ROT0);
vc_dispmanx_rect_set(&rectangle, 0, 0, m_size, m_size);
vc_dispmanx_resource_read_data(resource, &rectangle, image, m_size*3);
image_ptr = (char *)image;
//read out the pixels
for (int y = 0; y < m_size && !m_stop; y++)
{
// image_ptr += y*m_size*3;
for (int x = 0; x < m_size && !m_stop; x++)
{
rgb[0] = image_ptr[y*m_size*3+x*3];
rgb[1] = image_ptr[y*m_size*3+x*3 + 1];
rgb[2] = image_ptr[y*m_size*3+x*3 + 2];
boblight_addpixelxy(m_boblight, x, y, rgb);
}
}
//send pixeldata to boblight
if (!boblight_sendrgb(m_boblight, m_sync, NULL))
{
m_error = boblight_geterror(m_boblight);
return true; //recoverable error
}
//when in debug mode, put the captured image on the debug window
if (m_debug)
{
printf("Debug not supproted!\n");
m_debug = false;
}
if (!Wait())
{
return false; //unrecoverable error
}
}
m_error.clear();
return true;
}
bool CGrabberDispmanX::Wait()
{
if (m_interval > 0.0) //wait for timer
{
m_timer.Wait();
}
return true;
}

90
src/grabber-dispmanx.h
View File

@ -1,90 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRABBERDISPMANX
#define GRABBERDISPMANX
#include "bcm_host.h"
#include <string>
//#include "config.h"
#include "timer.h"
#ifndef ALIGN_UP
#define ALIGN_UP(x,y) ((x + (y)-1) & ~((y)-1))
#endif
//class for grabbing with DispmanX
class CGrabberDispmanX
{
public:
CGrabberDispmanX(void* boblight, volatile bool& stop, bool sync);
~CGrabberDispmanX();
bool ExtendedSetup();
bool Run();
std::string& GetError() { return m_error; } //retrieves the latest error
void SetInterval(double interval) { m_interval = interval; } //sets interval, negative means vblanks
void SetSize(int size) { m_size = size; } //sets how many pixels we want to grab
bool Setup(); //base setup function
void SetDebug(const char* display); //turn on debug window
protected:
bool Wait(); //wait for the timer or on the vblank
volatile bool& m_stop;
std::string m_error; //latest error
void* m_boblight; //our handle from libboblight
int m_size; //nr of pixels on lines to grab
bool m_debug; //if we have debug mode on
long double m_lastupdate;
long double m_lastmeasurement;
long double m_measurements;
int m_nrmeasurements;
double m_interval; //interval in seconds, or negative for vblanks
CTimer m_timer; //our timer
bool m_sync; //sync mode for libboblight
private:
bool CheckExtensions();
DISPMANX_DISPLAY_HANDLE_T display;
DISPMANX_MODEINFO_T info;
void *image;
DISPMANX_UPDATE_HANDLE_T update;
DISPMANX_RESOURCE_HANDLE_T resource;
DISPMANX_ELEMENT_HANDLE_T element;
uint32_t vc_image_ptr;
VC_IMAGE_TYPE_T type;
int pitch;
};
#endif //GRABBEROPENMAX

17
src/hyperion-d.cpp Normal file
View File

@ -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();
}

3
src/hyperion-remote/CMakeLists.txt
View File

@ -12,7 +12,8 @@ include_directories(${QT_INCLUDES})
set(hyperion-remote_HEADERS
specialoptions.h
connection.h)
connection.h
colortransform.h)
set(hyperion-remote_SOURCES
hyperion-remote.cpp

8
src/hyperion-remote/colortransform.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
struct ColorTransform
{
double valueRed;
double valueGreen;
double valueBlue;
};

82
src/hyperion-remote/connection.cpp
View File

@ -1,16 +1,41 @@
#include <stdexcept>
#include "connection.h"
Connection::Connection(const std::string &address, bool printJson)
Connection::Connection(const std::string & a, bool printJson) :
_printJson(printJson),
_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");
}
}
Connection::~Connection()
{
_socket.close();
}
bool Connection::setColor(QColor color, int priority, int duration)
{
std::cout << "Set color to " << color.red() << " " << color.green() << " " << color.blue() << std::endl;
sendMessage("Set color message");
return false;
}
@ -38,32 +63,49 @@ bool Connection::clearAll()
return false;
}
bool Connection::setThreshold(double red, double green, double blue)
bool Connection::setTransform(ColorTransform *threshold, ColorTransform *gamma, ColorTransform *blacklevel, ColorTransform *whitelevel)
{
std::cout << "Set color transforms" << std::endl;
return false;
}
bool Connection::setGamma(double red, double green, double blue)
{
return false;
}
bool Connection::setBlacklevel(double red, double green, double blue)
{
return false;
}
bool Connection::setWhitelevel(double red, double green, double blue)
{
return false;
}
bool Connection::sendMessage(const Json::Value &message)
bool Connection::sendMessage(const Json::Value & message)
{
// rpint if requested
if (_printJson)
{
std::cout << "Command:" << std::endl;
std::cout << message << std::endl;
std::cout << "Command: " << message << std::endl;
}
// serialize message
Json::FastWriter jsonWriter;
std::string serializedMessage = jsonWriter.write(message);
// write message
_socket.write(serializedMessage.c_str());
if (!_socket.waitForBytesWritten())
{
throw std::runtime_error("Error while writing data to host");
}
// receive reply
if (!_socket.waitForReadyRead())
{
throw std::runtime_error("Error while reading data from host");
}
char data[1024 * 100];
uint64_t count = _socket.read(data, sizeof(data));
std::string serializedReply(data, count);
Json::Reader jsonReader;
Json::Value reply;
if (!jsonReader.parse(serializedReply, reply))
{
throw std::runtime_error("Error while parsing reply:" + serializedReply);
}
if (_printJson)
{
std::cout << "Reply:" << reply << std::endl;
}
return true;

10
src/hyperion-remote/connection.h
View File

@ -4,9 +4,12 @@
#include <QColor>
#include <QImage>
#include <QTcpSocket>
#include <json/json.h>
#include "colortransform.h"
class Connection
{
public:
@ -18,14 +21,13 @@ public:
bool listPriorities();
bool clear(int priority);
bool clearAll();
bool setThreshold(double red, double green, double blue);
bool setGamma(double red, double green, double blue);
bool setBlacklevel(double red, double green, double blue);
bool setWhitelevel(double red, double green, double blue);
bool setTransform(ColorTransform * threshold, ColorTransform * gamma, ColorTransform * blacklevel, ColorTransform * whitelevel);
private:
bool sendMessage(const Json::Value & message);
private:
bool _printJson;
QTcpSocket _socket;
};

190
src/hyperion-remote/hyperion-remote.cpp
View File

@ -20,36 +20,112 @@ int count(std::initializer_list<bool> values)
return count;
}
int main(int argc, const char * argv[])
int main(int argc, char * argv[])
{
// some settings
QString defaultServerAddress = "localhost:19444";
int defaultPriority = 100;
OptionsParser optionParser("Simple application to send a command to hyperion using the Json interface");
ParameterSet & parameters = optionParser.getParameters();
StringParameter & argAddress = parameters.add<StringParameter> ('a', "address" , QString("Set the address of the hyperion server [default: %1]").arg(defaultServerAddress).toAscii().constData());
IntParameter & argPriority = parameters.add<IntParameter> ('p', "priority" , QString("Use to the provided priority channel (the lower the number, the higher the priority) [default: %1]").arg(defaultPriority).toAscii().constData());
IntParameter & argDuration = parameters.add<IntParameter> ('d', "duration" , "Specify how long the leds should be switched on in millseconds [default: infinity]");
ColorParameter & argColor = parameters.add<ColorParameter> ('c', "color" , "Set all leds to a constant color (either RRGGBB hex value or a color name)");
ImageParameter & argImage = parameters.add<ImageParameter> ('i', "image" , "Set the leds to the colors according to the given image file");
SwitchParameter<> & argList = parameters.add<SwitchParameter<> >('l', "list" , "List all priority channels which are in use");
SwitchParameter<> & argClear = parameters.add<SwitchParameter<> >('x', "clear" , "Clear data for the priority channel provided by the -p option");
SwitchParameter<> & argClearAll = parameters.add<SwitchParameter<> >(0x0, "clear-all" , "Clear data for all priority channels");
TransformParameter & argGamma = parameters.add<TransformParameter>('g', "gamma" , "Set the gamma of the leds (requires 3 values)");
TransformParameter & argThreshold = parameters.add<TransformParameter>('t', "threshold" , "Set the threshold of the leds (requires 3 space seperated values between 0.0 and 1.0)");
TransformParameter & argBlacklevel = parameters.add<TransformParameter>('b', "blacklevel", "Set the blacklevel of the leds (requires 3 space seperated values which are normally between 0.0 and 1.0)");
TransformParameter & argWhitelevel = parameters.add<TransformParameter>('w', "whitelevel", "Set the whitelevel of the leds (requires 3 space seperated values which are normally between 0.0 and 1.0)");
SwitchParameter<> & argPrint = parameters.add<SwitchParameter<> >(0x0, "print" , "Print the json input and output messages on stdout");
SwitchParameter<> & argHelp = parameters.add<SwitchParameter<> >('h', "help" , "Show this help message and exit");
argAddress.setDefault(defaultServerAddress.toStdString());
argPriority.setDefault(defaultPriority);
argDuration.setDefault(-1);
QCoreApplication app(argc, argv);
try
{
optionParser.parse(argc, argv);
// some settings
QString defaultServerAddress = "localhost:19444";
int defaultPriority = 100;
OptionsParser optionParser("Simple application to send a command to hyperion using the Json interface");
ParameterSet & parameters = optionParser.getParameters();
StringParameter & argAddress = parameters.add<StringParameter> ('a', "address" , QString("Set the address of the hyperion server [default: %1]").arg(defaultServerAddress).toAscii().constData());
IntParameter & argPriority = parameters.add<IntParameter> ('p', "priority" , QString("Use to the provided priority channel (the lower the number, the higher the priority) [default: %1]").arg(defaultPriority).toAscii().constData());
IntParameter & argDuration = parameters.add<IntParameter> ('d', "duration" , "Specify how long the leds should be switched on in millseconds [default: infinity]");
ColorParameter & argColor = parameters.add<ColorParameter> ('c', "color" , "Set all leds to a constant color (either RRGGBB hex value or a color name)");
ImageParameter & argImage = parameters.add<ImageParameter> ('i', "image" , "Set the leds to the colors according to the given image file");
SwitchParameter<> & argList = parameters.add<SwitchParameter<> >('l', "list" , "List all priority channels which are in use");
SwitchParameter<> & argClear = parameters.add<SwitchParameter<> >('x', "clear" , "Clear data for the priority channel provided by the -p option");
SwitchParameter<> & argClearAll = parameters.add<SwitchParameter<> >(0x0, "clear-all" , "Clear data for all priority channels");
TransformParameter & argGamma = parameters.add<TransformParameter>('g', "gamma" , "Set the gamma of the leds (requires 3 values)");
TransformParameter & argThreshold = parameters.add<TransformParameter>('t', "threshold" , "Set the threshold of the leds (requires 3 space seperated values between 0.0 and 1.0)");
TransformParameter & argBlacklevel = parameters.add<TransformParameter>('b', "blacklevel", "Set the blacklevel of the leds (requires 3 space seperated values which are normally between 0.0 and 1.0)");
TransformParameter & argWhitelevel = parameters.add<TransformParameter>('w', "whitelevel", "Set the whitelevel of the leds (requires 3 space seperated values which are normally between 0.0 and 1.0)");
SwitchParameter<> & argPrint = parameters.add<SwitchParameter<> >(0x0, "print" , "Print the json input and output messages on stdout");
SwitchParameter<> & argHelp = parameters.add<SwitchParameter<> >('h', "help" , "Show this help message and exit");
argAddress.setDefault(defaultServerAddress.toStdString());
argPriority.setDefault(defaultPriority);
argDuration.setDefault(-1);
// parse the options
optionParser.parse(argc, const_cast<const char **>(argv));
// check if we need to display the usage
if (argHelp.isSet())
{
optionParser.usage();
return 0;
}
// check if a color transform is set
bool colorTransform = argThreshold.isSet() || argGamma.isSet() || argBlacklevel.isSet() || argWhitelevel.isSet();
// check if exactly one command was given
int commandCount = count({argColor.isSet(), argImage.isSet(), argList.isSet(), argClear.isSet(), argClearAll.isSet(), colorTransform});
if (commandCount != 1)
{
if (commandCount == 0)
{
std::cerr << "No command found. Provide one of the following options:" << std::endl;
}
else
{
std::cerr << "Multiple commands found. Provide one of the following options:" << std::endl;
}
std::cerr << " " << argColor.usageLine() << std::endl;
std::cerr << " " << argImage.usageLine() << std::endl;
std::cerr << " " << argList.usageLine() << std::endl;
std::cerr << " " << argClear.usageLine() << std::endl;
std::cerr << " " << argClearAll.usageLine() << std::endl;
std::cerr << "or one or more of the color transformations:" << std::endl;
std::cerr << " " << argThreshold.usageLine() << std::endl;
std::cerr << " " << argGamma.usageLine() << std::endl;
std::cerr << " " << argBlacklevel.usageLine() << std::endl;
std::cerr << " " << argWhitelevel.usageLine() << std::endl;
return 1;
}
// create the connection
Connection connection(argAddress.getValue(), argPrint.isSet());
// now execute the given command
if (argColor.isSet())
{
connection.setColor(argColor.getValue(), argPriority.getValue(), argDuration.getValue());
}
else if (argImage.isSet())
{
connection.setImage(argImage.getValue(), argPriority.getValue(), argDuration.getValue());
}
else if (argList.isSet())
{
connection.listPriorities();
}
else if (argClear.isSet())
{
connection.clear(argPriority.getValue());
}
else if (argClearAll.isSet())
{
connection.clearAll();
}
else if (colorTransform)
{
ColorTransform threshold = argThreshold.getValue();
ColorTransform gamma = argGamma.getValue();
ColorTransform blacklevel = argBlacklevel.getValue();
ColorTransform whitelevel = argWhitelevel.getValue();
connection.setTransform(
argThreshold.isSet() ? &threshold : nullptr,
argGamma.isSet() ? &gamma : nullptr,
argBlacklevel.isSet() ? &blacklevel : nullptr,
argWhitelevel.isSet() ? &whitelevel : nullptr);
}
}
catch (const std::runtime_error & e)
{
@ -57,67 +133,5 @@ int main(int argc, const char * argv[])
return 1;
}
// check if we need to display the usage
if (argHelp.isSet())
{
optionParser.usage();
return 0;
}
// check if a color transform is set
bool colorTransform = argThreshold.isSet() || argGamma.isSet() || argBlacklevel.isSet() || argWhitelevel.isSet();
// check if exactly one command was given
int commandCount = count({argColor.isSet(), argImage.isSet(), argList.isSet(), argClear.isSet(), argClearAll.isSet(), colorTransform});
if (commandCount != 1)
{
if (commandCount == 0)
{
std::cerr << "No command found. Provide one of the following options:" << std::endl;
}
else
{
std::cerr << "Multiple commands found. Provide one of the following options:" << std::endl;
}
std::cerr << " " << argColor.usageLine() << std::endl;
std::cerr << " " << argImage.usageLine() << std::endl;
std::cerr << " " << argList.usageLine() << std::endl;
std::cerr << " " << argClear.usageLine() << std::endl;
std::cerr << " " << argClearAll.usageLine() << std::endl;
std::cerr << "or one or more of the color transformations:" << std::endl;
std::cerr << " " << argThreshold.usageLine() << std::endl;
std::cerr << " " << argGamma.usageLine() << std::endl;
std::cerr << " " << argBlacklevel.usageLine() << std::endl;
std::cerr << " " << argWhitelevel.usageLine() << std::endl;
return 1;
}
Connection connection(argAddress.getValue(), argPrint.isSet());
// now execute the given command
if (argColor.isSet())
{
connection.setColor(argColor.getValue(), argPriority.getValue(), argDuration.getValue());
}
else if (argImage.isSet())
{
connection.setImage(argImage.getValue(), argPriority.getValue(), argDuration.getValue());
}
else if (argList.isSet())
{
connection.listPriorities();
}
else if (argClear.isSet())
{
connection.clear(argPriority.getValue());
}
else if (argClearAll.isSet())
{
connection.clearAll();
}
else if (colorTransform)
{
}
return 0;
}

7
src/hyperion-remote/specialoptions.h
View File

@ -5,12 +5,7 @@
#include <getoptPlusPlus/getoptpp.h>
struct ColorTransform
{
double valueRed;
double valueGreen;
double valueBlue;
};
#include "colortransform.h"
typedef vlofgren::PODParameter<QColor> ColorParameter;
typedef vlofgren::PODParameter<QImage> ImageParameter;

81
src/misc.cpp
View File

@ -1,81 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <locale.h>
#include "misc.h"
using namespace std;
void PrintError(const std::string& error)
{
std::cerr << "ERROR: " << error << "\n";
}
//get the first word (separated by whitespace) from string data and place that in word
//then remove that word from string data
bool GetWord(string& data, string& word)
{
stringstream datastream(data);
string end;
datastream >> word;
if (datastream.fail())
{
data.clear();
return false;
}
size_t pos = data.find(word) + word.length();
if (pos >= data.length())
{
data.clear();
return true;
}
data = data.substr(pos);
datastream.clear();
datastream.str(data);
datastream >> end;
if (datastream.fail())
data.clear();
return true;
}
//convert . or , to the current locale for correct conversion of ascii float
void ConvertFloatLocale(std::string& strfloat)
{
static struct lconv* locale = localeconv();
size_t pos = strfloat.find_first_of(",.");
while (pos != string::npos)
{
strfloat.replace(pos, 1, 1, *locale->decimal_point);
pos++;
if (pos >= strfloat.size())
break;
pos = strfloat.find_first_of(",.", pos);
}
}

191
src/misc.h
View File

@ -1,191 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef MISCUTIL
#define MISCUTIL
#include "stdint.h"
#include <string>
#include <sstream>
#include <exception>
#include <stdexcept>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <math.h>
void PrintError(const std::string& error);
bool GetWord(std::string& data, std::string& word);
void ConvertFloatLocale(std::string& strfloat);
template <class Value>
inline std::string ToString(Value value)
{
std::string data;
std::stringstream valuestream;
valuestream << value;
valuestream >> data;
return data;
}
inline std::string GetErrno()
{
return strerror(errno);
}
inline std::string GetErrno(int err)
{
return strerror(err);
}
template <class A, class B, class C>
inline A Clamp(A value, B min, C max)
{
return value < max ? (value > min ? value : min) : max;
}
template <class A, class B>
inline A Max(A value1, B value2)
{
return value1 > value2 ? value1 : value2;
}
template <class A, class B, class C>
inline A Max(A value1, B value2, C value3)
{
return (value1 > value2) ? (value1 > value3 ? value1 : value3) : (value2 > value3 ? value2 : value3);
}
template <class A, class B>
inline A Min(A value1, B value2)
{
return value1 < value2 ? value1 : value2;
}
template <class A, class B, class C>
inline A Min(A value1, B value2, C value3)
{
return (value1 < value2) ? (value1 < value3 ? value1 : value3) : (value2 < value3 ? value2 : value3);
}
template <class T>
inline T Abs(T value)
{
return value > 0 ? value : -value;
}
template <class A, class B>
inline A Round(B value)
{
if (value == 0.0)
{
return 0;
}
else if (value > 0.0)
{
return (A)(value + 0.5);
}
else
{
return (A)(value - 0.5);
}
}
inline int32_t Round32(float value)
{
return lroundf(value);
}
inline int32_t Round32(double value)
{
return lround(value);
}
inline int64_t Round64(float value)
{
return llroundf(value);
}
inline int64_t Round64(double value)
{
return llround(value);
}
inline bool StrToInt(const std::string& data, int& value)
{
return sscanf(data.c_str(), "%i", &value) == 1;
}
inline bool StrToInt(const std::string& data, int64_t& value)
{
return sscanf(data.c_str(), "%ld", &value) == 1;
}
inline bool HexStrToInt(const std::string& data, int& value)
{
return sscanf(data.c_str(), "%x", &value) == 1;
}
inline bool HexStrToInt(const std::string& data, int64_t& value)
{
return sscanf(data.c_str(), "%x", &value) == 1;
}
inline bool StrToFloat(const std::string& data, float& value)
{
return sscanf(data.c_str(), "%f", &value) == 1;
}
inline bool StrToFloat(const std::string& data, double& value)
{
return sscanf(data.c_str(), "%lf", &value) == 1;
}
inline bool StrToBool(const std::string& data, bool& value)
{
std::string data2 = data;
std::string word;
if (!GetWord(data2, word))
return false;
if (word == "1" || word == "true" || word == "on" || word == "yes")
{
value = true;
return true;
}
else if (word == "0" || word == "false" || word == "off" || word == "no")
{
value = false;
return true;
}
else
{
int ivalue;
if (StrToInt(word, ivalue))
{
value = ivalue != 0;
return true;
}
}
return false;
}
#endif //MISCUTIL

69
src/timer.cpp
View File

@ -1,69 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "timer.h"
#include "misc.h"
#include "timeutils.h"
#include <iostream>
using namespace std;
CTimer::CTimer(volatile bool* stop /*=NULL*/)
{
m_interval = -1;
m_timerstop = stop;
}
void CTimer::SetInterval(int64_t usecs)
{
m_interval = usecs;
Reset();
}
int64_t CTimer::GetInterval()
{
return m_interval;
}
void CTimer::Reset()
{
m_time = GetTimeUs();
}
void CTimer::Wait()
{
int64_t sleeptime;
//keep looping until we have a timestamp that's not too old
int64_t now = GetTimeUs();
do
{
m_time += m_interval;
sleeptime = m_time - now;
}
while(sleeptime <= m_interval * -2LL);
if (sleeptime > m_interval * 2LL) //failsafe, m_time must be bork if we get here
{
sleeptime = m_interval * 2LL;
Reset();
}
USleep(sleeptime, m_timerstop);
}

42
src/timer.h
View File

@ -1,42 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CTIMER
#define CTIMER
#include "stdint.h"
#include <unistd.h>
class CTimer
{
public:
CTimer(volatile bool* stop = NULL);
void SetInterval(int64_t usecs);
virtual void Wait();
void Reset();
int64_t GetInterval();
protected:
int64_t m_time;
int64_t m_interval;
volatile bool* m_timerstop;
};
#endif

56
src/timeutils.cpp
View File

@ -1,56 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "timeutils.h"
void USleep(int64_t usecs, volatile bool* stop /*= NULL*/)
{
if (usecs <= 0)
{
return;
}
else if (stop && usecs > 1000000) //when a pointer to a bool is passed, check it every second and stop when it's true
{
int64_t now = GetTimeUs();
int64_t end = now + usecs;
while (now < end)
{
struct timespec sleeptime = {};
if (*stop)
return;
else if (end - now >= 1000000)
sleeptime.tv_sec = 1;
else
sleeptime.tv_nsec = ((end - now) % 1000000) * 1000;
nanosleep(&sleeptime, NULL);
now = GetTimeUs();
}
}
else
{
struct timespec sleeptime;
sleeptime.tv_sec = usecs / 1000000;
sleeptime.tv_nsec = (usecs % 1000000) * 1000;
nanosleep(&sleeptime, NULL);
}
}

49
src/timeutils.h
View File

@ -1,49 +0,0 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TIMEUTILS
#define TIMEUTILS
#include "stdint.h"
//#include "config.h"
#include <time.h>
#include <sys/time.h>
inline int64_t GetTimeUs()
{
#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
struct timespec time;
clock_gettime(CLOCK_MONOTONIC, &time);
return ((int64_t)time.tv_sec * 1000000LL) + (int64_t)(time.tv_nsec + 500) / 1000LL;
#else
struct timeval time;
gettimeofday(&time, NULL);
return ((int64_t)time.tv_sec * 1000000LL) + (int64_t)time.tv_usec;
#endif
}
template <class T>
inline T GetTimeSec()
{
return (T)GetTimeUs() / (T)1000000.0;
}
void USleep(int64_t usecs, volatile bool* stop = NULL);
#endif //TIMEUTILS

31
test/CMakeLists.txt
View File

@ -4,44 +4,33 @@ include_directories(../libsrc)
# Add the simple test executable 'TestSpi'
add_executable(TestSpi
TestSpi.cpp)
target_link_libraries(TestSpi
hyperion
hyperion-utils)
hyperion)
add_executable(TestConfigFile
TestConfigFile.cpp)
target_link_libraries(TestConfigFile
hyperion-utils
hyperion)
add_executable(Test2BobLight
Test2BobLight.cpp)
target_link_libraries(Test2BobLight
bob2hyperion)
add_executable(TestRgbImage
TestRgbImage.cpp)
target_link_libraries(TestRgbImage
hyperion-utils)
add_executable(TestColorTransform
TestColorTransform.cpp)
TestColorTransform.cpp)
target_link_libraries(TestColorTransform
hyperion)
hyperion)
# Find the libPNG
find_package(PNG REQUIRED QUIET)
#if(PNG_FOUND)
# Add additional includes dirs
include_directories(${PNG_INCLUDE_DIR})
# Add additional includes dirs
include_directories(${PNG_INCLUDE_DIR})
add_executable(TestHyperionPng
TestHyperionPng.cpp)
add_executable(TestHyperionPng
TestHyperionPng.cpp)
target_link_libraries(TestHyperionPng
hyperion-png)
#endif(PNG_FOUND)
target_link_libraries(TestHyperionPng
hyperion-png)

39
test/Test2BobLight.cpp
View File

@ -1,39 +0,0 @@
// STL includes
#include <iostream>
#include <vector>
#include <unistd.h>
// Boblight includes
#include <boblight.h>
int main()
{
void* boblight_ptr = boblight_init();
if (!boblight_ptr)
{
std::cerr << "Failed to initialise bob-light" << std::endl;
return -1;
}
const unsigned width = 112;
const unsigned height = 63;
boblight_setscanrange(boblight_ptr, width, height);
std::vector<int> rgbColor = { 255, 255, 0 };
for (unsigned iY=0; iY<height; ++iY)
{
for (unsigned iX=0; iX<width; ++iX)
{
boblight_addpixelxy(boblight_ptr, iX, iY, rgbColor.data());
}
}
boblight_sendrgb(boblight_ptr, 0, nullptr);
//sleep(5);
boblight_destroy(boblight_ptr);
return 0;
}

16
test/TestBoblightOrig.cpp
View File

@ -1,16 +0,0 @@
// STL includes
#include <iostream>
// Boblight includes
#include <boblight.h>
int main()
{
std::cout << "TestBoblightOrig started" << std::endl;
std::cout << "TestBoblightOrig finished" << std::endl;
return 0;
}

159
test/TestColorTransform.cpp
View File

@ -1,93 +1,96 @@
// STL includes
#include <iostream>
#include <cmath>
#include <hyperion/ColorTransform.h>
#include <../../libsrc/hyperion/ColorTransform.h>
using namespace hyperion;
int main()
{
{
std::cout << "Testing linear transform" << std::endl;
ColorTransform t;
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = input;
{
std::cout << "Testing linear transform" << std::endl;
ColorTransform t;
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = input;
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
{
std::cout << "Testing threshold" << std::endl;
ColorTransform t(.10, 1.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = ((i/255.0) < t.getThreshold() ? 0 : output);
{
std::cout << "Testing threshold" << std::endl;
ColorTransform t(.10, 1.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = ((i/255.0) < t.getThreshold() ? 0 : output);
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
{
std::cout << "Testing blacklevel and whitelevel" << std::endl;
ColorTransform t(0, 1.0, 0.2, 0.8);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(input * (t.getWhitelevel()-t.getBlacklevel()) + 255 * t.getBlacklevel());
{
std::cout << "Testing blacklevel and whitelevel" << std::endl;
ColorTransform t(0, 1.0, 0.2, 0.8);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(input * (t.getWhitelevel()-t.getBlacklevel()) + 255 * t.getBlacklevel());
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
{
std::cout << "Testing gamma" << std::endl;
ColorTransform t(0, 2.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(255 * std::pow(i / 255.0, 2));
{
std::cout << "Testing gamma" << std::endl;
ColorTransform t(0, 2.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(255 * std::pow(i / 255.0, 2));
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
return 0;
return 0;
}

28
test/TestConfigFile.cpp
View File

@ -23,16 +23,30 @@ int main()
}
const Json::Value& deviceConfig = config["device"];
if (deviceConfig.empty())
{
std::cout << "Missing DEVICE configuration 'device'" << std::endl;
}
const Json::Value& ledConfig = config["leds"];
if (ledConfig.empty())
{
std::cout << "Missing LEDS configuration 'leds'" << std::endl;
}
const Json::Value& colorConfig = config["color"];
if (colorConfig.empty())
{
std::cout << "Missing COLORS configuration 'colors'" << std::endl;
}
else
{
std::cout << "COLOR CONFIGURATION: " << colorConfig.toStyledString() << std::endl;
std::cout << "COLOR CONFIGURATION: " << colorConfig.toStyledString() << std::endl;
const Json::Value& redConfig = colorConfig["red"];
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);
const Json::Value& redConfig = colorConfig["red"];
double redGamma = redConfig["gamma"].asDouble();
std::cout << "RED GAMMA = " << redGamma << std::endl;
std::cout << "RED GAMMA = " << colorConfig["red.gamma"].asDouble() << std::endl;
}
return 0;
}