mirror of
https://github.com/hyperion-project/hyperion.ng.git
synced 2023-10-10 13:36:59 +02:00
Deleted all files referencing/using boblight
This commit is contained in:
T. van der Zwan
parent
39b98386dd
commit
2ec9f9202e
@ -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));
|
||||
@ -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
|
||||
|
||||
@ -19,6 +19,8 @@ namespace hyperion { class ImageToLedsMap;
|
||||
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.
|
||||
@ -61,8 +63,6 @@ private:
|
||||
|
||||
ImageProcessor(const LedString &ledString);
|
||||
|
||||
~ImageProcessor();
|
||||
|
||||
private:
|
||||
const LedString mLedString;
|
||||
|
||||
|
||||
@ -3,29 +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)
|
||||
|
||||
add_subdirectory(hyperion)
|
||||
add_subdirectory(utils)
|
||||
|
||||
# Find the libPNG
|
||||
find_package(PNG REQUIRED QUIET)
|
||||
|
||||
if (PNG_FOUND)
|
||||
# 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(hyperionpng)
|
||||
endif(PNG_FOUND)
|
||||
|
||||
|
||||
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -7,14 +7,18 @@ include_directories(${BCM_INCLUDE_DIRS})
|
||||
SET(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/hyperion)
|
||||
SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/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}/ImageProcessor.h
|
||||
${CURRENT_HEADER_DIR}/ImageProcessorFactory.h
|
||||
${CURRENT_HEADER_DIR}/PriorityMuxer.h
|
||||
${CURRENT_HEADER_DIR}/DispmanxWrapper.h
|
||||
|
||||
${CURRENT_SOURCE_DIR}/DispmanxFrameGrabber.h
|
||||
|
||||
@ -38,10 +42,11 @@ SET(Hyperion_SOURCES
|
||||
${CURRENT_SOURCE_DIR}/ColorTransform.cpp
|
||||
)
|
||||
|
||||
QT4_WRAP_CPP(Hyperion_HEADERS_MOC ${Hyperion_HEADERS})
|
||||
QT4_WRAP_CPP(Hyperion_HEADERS_MOC ${Hyperion_QT_HEADERS})
|
||||
|
||||
add_library(hyperion
|
||||
${Hyperion_HEADERS}
|
||||
${Hyperion_QT_HEADERS}
|
||||
${Hyperion_HEADERS_MOC}
|
||||
${Hyperion_SOURCES}
|
||||
)
|
||||
|
||||
@ -13,6 +13,8 @@ DispmanxFrameGrabber::DispmanxFrameGrabber(const unsigned width, const unsigned
|
||||
// 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
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
// BCM includes
|
||||
#pragma GCC system_header
|
||||
#include <bcm_host.h>
|
||||
|
||||
// STL includes
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
// Hyperion includes
|
||||
#include <hyperion/DispmanxWrapper.h>
|
||||
#include <hyperion/ImageProcessorFactory.h>
|
||||
#include <hyperion/ImageProcessor.h>
|
||||
|
||||
|
||||
// Local-Hyperion includes
|
||||
@ -12,19 +13,21 @@
|
||||
|
||||
DispmanxWrapper::DispmanxWrapper() :
|
||||
_timer(),
|
||||
_processor(ImageProcessorFactory::getInstance().newImageProcessor()),
|
||||
_frameGrabber(new DispmanxFrameGrabber(64, 64))
|
||||
_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 _frameGrabber;
|
||||
delete _processor;
|
||||
delete _frameGrabber;
|
||||
}
|
||||
|
||||
void DispmanxWrapper::start()
|
||||
|
||||
@ -989,19 +989,19 @@ void pngwriter::close()
|
||||
time(&gmt);
|
||||
png_convert_from_time_t(&mod_time, gmt);
|
||||
png_set_tIME(png_ptr, info_ptr, &mod_time);
|
||||
text_ptr[0].key = "Title";
|
||||
text_ptr[0].key = (char *)"Title";
|
||||
text_ptr[0].text = texttitle_;
|
||||
text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
|
||||
text_ptr[1].key = "Author";
|
||||
text_ptr[1].key = (char *)"Author";
|
||||
text_ptr[1].text = textauthor_;
|
||||
text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
|
||||
text_ptr[2].key = "Description";
|
||||
text_ptr[2].key = (char *)"Description";
|
||||
text_ptr[2].text = textdescription_;
|
||||
text_ptr[2].compression = PNG_TEXT_COMPRESSION_NONE;
|
||||
text_ptr[3].key = "Creation Time";
|
||||
text_ptr[3].key = (char *)"Creation Time";
|
||||
text_ptr[3].text = png_convert_to_rfc1123(png_ptr, &mod_time);
|
||||
text_ptr[3].compression = PNG_TEXT_COMPRESSION_NONE;
|
||||
text_ptr[4].key = "Software";
|
||||
text_ptr[4].key = (char *)"Software";
|
||||
text_ptr[4].text = textsoftware_;
|
||||
text_ptr[4].compression = PNG_TEXT_COMPRESSION_NONE;
|
||||
png_set_text(png_ptr, info_ptr, text_ptr, 5);
|
||||
@ -3345,11 +3345,11 @@ void pngwriter::scale_wh(int finalwidth, int finalheight)
|
||||
std::cerr << " PNGwriter::scale_wh - ERROR **: Negative or zero final width or height not allowed." << std::endl;
|
||||
}
|
||||
|
||||
double kx;
|
||||
double ky;
|
||||
// double kx;
|
||||
// double ky;
|
||||
|
||||
kx = ((double)finalwidth)/((double)width_);
|
||||
ky = ((double)finalheight)/((double)height_);
|
||||
// kx = ((double)finalwidth)/((double)width_);
|
||||
// ky = ((double)finalheight)/((double)height_);
|
||||
|
||||
pngwriter temp(finalwidth, finalheight, 0, "temp");
|
||||
|
||||
|
||||
@ -2,45 +2,12 @@
|
||||
add_executable(WriteConfig
|
||||
WriteConfig.cpp)
|
||||
|
||||
add_executable(HyperionDispmanx
|
||||
HyperionMain.cpp)
|
||||
add_executable(hyperion-d
|
||||
hyperion-d.cpp)
|
||||
|
||||
target_link_libraries(HyperionDispmanx
|
||||
target_link_libraries(hyperion-d
|
||||
hyperion)
|
||||
|
||||
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})
|
||||
|
||||
|
||||
# Find the libPNG
|
||||
find_package(PNG QUIET)
|
||||
|
||||
@ -53,8 +20,5 @@ if(PNG_FOUND)
|
||||
|
||||
target_link_libraries(ViewPng
|
||||
hyperion
|
||||
hyperion-utils
|
||||
${PNG_LIBRARIES})
|
||||
endif(PNG_FOUND)
|
||||
|
||||
add_subdirectory(dispmanx-png)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -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})
|
||||
@ -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);
|
||||
}
|
||||
@ -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";
|
||||
}
|
||||
@ -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
|
||||
@ -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 (size_t 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 (size_t 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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
81
src/misc.cpp
81
src/misc.cpp
@ -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
191
src/misc.h
@ -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(), "%lld", &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(), "%llx", &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
|
||||
@ -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
42
src/timer.h
@ -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
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -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
|
||||
@ -4,24 +4,15 @@ 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
|
||||
@ -35,7 +26,6 @@ target_link_libraries(TestColorTransform
|
||||
# Find the libPNG
|
||||
find_package(PNG REQUIRED QUIET)
|
||||
|
||||
#if(PNG_FOUND)
|
||||
# Add additional includes dirs
|
||||
include_directories(${PNG_INCLUDE_DIR})
|
||||
|
||||
@ -44,4 +34,3 @@ find_package(PNG REQUIRED QUIET)
|
||||
|
||||
target_link_libraries(TestHyperionPng
|
||||
hyperion-png)
|
||||
#endif(PNG_FOUND)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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"];
|
||||
const Json::Value& colorConfig = config["color"];
|
||||
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;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user