frodovdr/hyperion.ng
1
0
Fork 0
mirror of https://github.com/hyperion-project/hyperion.ng.git synced 2023-10-10 13:36:59 +02:00
Code Issues Releases Wiki Activity

Merge remote-tracking branch 'remotes/origin/add_effect_engine' into add_effect_engine

Browse Source 
Conflicts:
	CMakeLists.txt
	config/hyperion.config.json
	include/hyperion/Hyperion.h
	libsrc/hyperion/Hyperion.cpp
	libsrc/jsonserver/JsonClientConnection.cpp

Former-commit-id: 8661412367827b888827e762750ab0ed36c806ec
This commit is contained in:
T. van der Zwan 2013-12-05 22:12:56 +01:00
commit df1eaaaecc
10 changed files with 678 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CMakeLists.txt
View File

@ -1,5 +1,5 @@
# Define the main-project name # Define the main-project name
project(hyperion) project(Hyperion)
# define the minimum cmake version (as required by cmake) # define the minimum cmake version (as required by cmake)
cmake_minimum_required(VERSION 2.8) cmake_minimum_required(VERSION 2.8)
@ -44,6 +44,13 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -Wall")
# Configure the use of QT4 # Configure the use of QT4
find_package(Qt4 COMPONENTS QtCore QtGui QtNetwork REQUIRED QUIET) find_package(Qt4 COMPONENTS QtCore QtGui QtNetwork REQUIRED QUIET)
# add protocol buffers
find_package(Protobuf REQUIRED)
#add libusb and pthreads
find_package(libusb-1.0 REQUIRED)
find_package(Threads REQUIRED)
include(${QT_USE_FILE}) include(${QT_USE_FILE})
add_definitions(${QT_DEFINITIONS}) add_definitions(${QT_DEFINITIONS})
link_directories(${CMAKE_FIND_ROOT_PATH}/lib/arm-linux-gnueabihf) link_directories(${CMAKE_FIND_ROOT_PATH}/lib/arm-linux-gnueabihf)

12
bin/install_hyperion.sh
View File

@ -17,27 +17,27 @@ fi
/sbin/initctl stop hyperion /sbin/initctl stop hyperion
# Get the Hyperion executable # Get the Hyperion executable
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperiond -P /usr/bin/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperiond -P /usr/bin/
chmod +x /usr/bin/hyperiond chmod +x /usr/bin/hyperiond
# Get the Hyperion command line utility # Get the Hyperion command line utility
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperion-remote -P /usr/bin/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperion-remote -P /usr/bin/
chmod +x /usr/bin/hyperion-remote chmod +x /usr/bin/hyperion-remote
# Copy the gpio changer (gpio->spi) to the /usr/bin # Copy the gpio changer (gpio->spi) to the /usr/bin
if [ $IS_XBIAN -eq 0 ]; then if [ $IS_XBIAN -eq 0 ]; then
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/gpio2spi -P /usr/bin/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/gpio2spi -P /usr/bin/
chmod +x /usr/bin/gpio2spi chmod +x /usr/bin/gpio2spi
fi fi
# Copy the hyperion configuration file to /etc # Copy the hyperion configuration file to /etc
wget -N github.com/tvdzwan/hyperion/raw/master/config/hyperion.config.json -P /etc/ wget -N https://raw.github.com/tvdzwan/hyperion/master/config/hyperion.config.json -P /etc/
# Copy the service control configuration to /etc/int # Copy the service control configuration to /etc/int
if [ $IS_XBIAN -eq 0 ]; then if [ $IS_XBIAN -eq 0 ]; then
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperion.conf -P /etc/init/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperion.conf -P /etc/init/
else else
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperion.xbian.conf -O /etc/init/hyperion.conf wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperion.xbian.conf -O /etc/init/hyperion.conf
fi fi
# Start the hyperion daemon # Start the hyperion daemon

10
bin/update_hyperion.sh
View File

@ -17,24 +17,24 @@ fi
/sbin/initctl stop hyperion /sbin/initctl stop hyperion
# Get the Hyperion executable # Get the Hyperion executable
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperiond -P /usr/bin/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperiond -P /usr/bin/
chmod +x /usr/bin/hyperiond chmod +x /usr/bin/hyperiond
# Get the Hyperion command line utility # Get the Hyperion command line utility
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperion-remote -P /usr/bin/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperion-remote -P /usr/bin/
chmod +x /usr/bin/hyperion-remote chmod +x /usr/bin/hyperion-remote
# Copy the gpio changer (gpio->spi) to the /usr/bin # Copy the gpio changer (gpio->spi) to the /usr/bin
if [ $IS_XBIAN -eq 0 ]; then if [ $IS_XBIAN -eq 0 ]; then
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/gpio2spi -P /usr/bin/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/gpio2spi -P /usr/bin/
chmod +x /usr/bin/gpio2spi chmod +x /usr/bin/gpio2spi
fi fi
# Copy the service control configuration to /etc/int # Copy the service control configuration to /etc/int
if [ $IS_XBIAN -eq 0 ]; then if [ $IS_XBIAN -eq 0 ]; then
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperion.conf -P /etc/init/ wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperion.conf -P /etc/init/
else else
wget -N github.com/tvdzwan/hyperion/raw/master/deploy/hyperion.xbian.conf -P /etc/init/ -O hyperion.conf wget -N https://raw.github.com/tvdzwan/hyperion/master/deploy/hyperion.xbian.conf -P /etc/init/ -O hyperion.conf
fi fi
# Start the hyperion daemon # Start the hyperion daemon

41
config/hyperion.config.json
View File

@ -34,11 +34,6 @@
/// - 'updateFrequency' The update frequency of the leds in Hz /// - 'updateFrequency' The update frequency of the leds in Hz
"color" : "color" :
{ {
"transform" :
[
{
"id" : "device_1",
"leds" : "0-24",
"hsv" : "hsv" :
{ {
"saturationGain" : 1.0000, "saturationGain" : 1.0000,
@ -64,42 +59,10 @@
"gamma" : 2.0000, "gamma" : 2.0000,
"blacklevel" : 0.0000, "blacklevel" : 0.0000,
"whitelevel" : 1.0000 "whitelevel" : 1.0000
}
}, },
{
"id" : "device_2",
"leds" : "25-49",
"hsv" :
{
"saturationGain" : 1.0000,
"valueGain" : 1.5000
},
"red" :
{
"threshold" : 0.1000,
"gamma" : 2.0000,
"blacklevel" : 0.0000,
"whitelevel" : 0.8000
},
"green" :
{
"threshold" : 0.1000,
"gamma" : 2.0000,
"blacklevel" : 0.0000,
"whitelevel" : 1.0000
},
"blue" :
{
"threshold" : 0.1000,
"gamma" : 2.0000,
"blacklevel" : 0.0000,
"whitelevel" : 1.0000
}
}
],
"smoothing" : "smoothing" :
{ {
"type" : "linear", "type" : "none",
"time_ms" : 200, "time_ms" : 200,
"updateFrequency" : 20.0000 "updateFrequency" : 20.0000
} }
@ -376,7 +339,7 @@
}, },
/// The boot-sequence configuration, contains the following items: /// The boot-sequence configuration, contains the following items:
/// * type : The type of the boot-sequence ('rainbow', 'knight_rider', 'none') /// * type : The type of the boot-sequence ('rainbow', 'knightrider', 'none')
/// * duration_ms : The length of the boot-sequence [ms] /// * duration_ms : The length of the boot-sequence [ms]
"bootsequence" : "bootsequence" :
{ {

409
config/hyperion_test.config.json Normal file
View File

@ -0,0 +1,409 @@
// Automatically generated configuration file for 'Hyperion daemon'
// Generated by: HyperCon (The Hyperion deamon configuration file builder
{
/// Device configuration contains the following fields:
/// * 'name' : The user friendly name of the device (only used for display purposes)
/// * 'type' : The type of the device or leds (known types for now are 'ws2801', 'ldp8806',
/// 'lpd6803', 'sedu', 'adalight', 'lightpack', 'test' and 'none')
/// * 'output' : The output specification depends on selected device. This can for example be the
/// device specifier, device serial number, or the output file name
/// * 'rate' : The baudrate of the output to the device
/// * 'colorOrder' : The order of the color bytes ('rgb', 'rbg', 'bgr', etc.).
"device" :
{
"name" : "MyPi",
"type" : "ws2801",
"output" : "/dev/spidev0.0",
"rate" : 500000,
"colorOrder" : "rgb"
},
/// Color manipulation configuration used to tune the output colors to specific surroundings. Contains the following fields:
/// * 'hsv' : The manipulation in the Hue-Saturation-Value color domain with the following tuning parameters:
/// - 'saturationGain' The gain adjustement of the saturation
/// - 'valueGain' The gain adjustement of the value
/// * 'red'/'green'/'blue' : The manipulation in the Red-Green-Blue color domain with the following tuning parameters for each channel:
/// - 'threshold' The minimum required input value for the channel to be on (else zero)
/// - 'gamma' The gamma-curve correction factor
/// - 'blacklevel' The lowest possible value (when the channel is black)
/// - 'whitelevel' The highest possible value (when the channel is white)
/// * 'smoothing' : Smoothing of the colors in the time-domain with the following tuning parameters:
/// - 'type' The type of smoothing algorithm ('linear' or 'none')
/// - 'time_ms' The time constant for smoothing algorithm in milliseconds
/// - 'updateFrequency' The update frequency of the leds in Hz
"color" :
{
"transform" :
[
{
"id" : "MyPi device",
"leds" : "0-49",
"hsv" :
{
"saturationGain" : 1.0000,
"valueGain" : 1.5000
},
"red" :
{
"threshold" : 0.1000,
"gamma" : 2.0000,
"blacklevel" : 0.0000,
"whitelevel" : 0.8000
},
"green" :
{
"threshold" : 0.1000,
"gamma" : 2.0000,
"blacklevel" : 0.0000,
"whitelevel" : 1.0000
},
"blue" :
{
"threshold" : 0.1000,
"gamma" : 2.0000,
"blacklevel" : 0.0000,
"whitelevel" : 1.0000
}
}
],
"smoothing" :
{
"type" : "linear",
"time_ms" : 200,
"updateFrequency" : 20.0000
}
},
/// The configuration for each individual led. This contains the specification of the area
/// averaged of an input image for each led to determine its color. Each item in the list
/// contains the following fields:
/// * index: The index of the led. This determines its location in the string of leds; zero
/// being the first led.
/// * hscan: The fractional part of the image along the horizontal used for the averaging
/// (minimum and maximum inclusive)
/// * vscan: The fractional part of the image along the vertical used for the averaging
/// (minimum and maximum inclusive)
"leds" :
[
{
"index" : 0,
"hscan" : { "minimum" : 0.4375, "maximum" : 0.5000 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 1,
"hscan" : { "minimum" : 0.3750, "maximum" : 0.4375 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 2,
"hscan" : { "minimum" : 0.3125, "maximum" : 0.3750 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 3,
"hscan" : { "minimum" : 0.2500, "maximum" : 0.3125 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 4,
"hscan" : { "minimum" : 0.1875, "maximum" : 0.2500 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 5,
"hscan" : { "minimum" : 0.1250, "maximum" : 0.1875 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 6,
"hscan" : { "minimum" : 0.0625, "maximum" : 0.1250 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 7,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0625 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 8,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 9,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.8571, "maximum" : 1.0000 }
},
{
"index" : 10,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.7143, "maximum" : 0.8571 }
},
{
"index" : 11,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.5714, "maximum" : 0.7143 }
},
{
"index" : 12,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.4286, "maximum" : 0.5714 }
},
{
"index" : 13,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.2857, "maximum" : 0.4286 }
},
{
"index" : 14,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.1429, "maximum" : 0.2857 }
},
{
"index" : 15,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.1429 }
},
{
"index" : 16,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0500 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 17,
"hscan" : { "minimum" : 0.0000, "maximum" : 0.0625 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 18,
"hscan" : { "minimum" : 0.0625, "maximum" : 0.1250 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 19,
"hscan" : { "minimum" : 0.1250, "maximum" : 0.1875 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 20,
"hscan" : { "minimum" : 0.1875, "maximum" : 0.2500 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 21,
"hscan" : { "minimum" : 0.2500, "maximum" : 0.3125 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 22,
"hscan" : { "minimum" : 0.3125, "maximum" : 0.3750 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 23,
"hscan" : { "minimum" : 0.3750, "maximum" : 0.4375 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 24,
"hscan" : { "minimum" : 0.4375, "maximum" : 0.5000 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 25,
"hscan" : { "minimum" : 0.5000, "maximum" : 0.5625 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 26,
"hscan" : { "minimum" : 0.5625, "maximum" : 0.6250 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 27,
"hscan" : { "minimum" : 0.6250, "maximum" : 0.6875 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 28,
"hscan" : { "minimum" : 0.6875, "maximum" : 0.7500 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 29,
"hscan" : { "minimum" : 0.7500, "maximum" : 0.8125 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 30,
"hscan" : { "minimum" : 0.8125, "maximum" : 0.8750 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 31,
"hscan" : { "minimum" : 0.8750, "maximum" : 0.9375 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 32,
"hscan" : { "minimum" : 0.9375, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 33,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.0800 }
},
{
"index" : 34,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.0000, "maximum" : 0.1429 }
},
{
"index" : 35,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.1429, "maximum" : 0.2857 }
},
{
"index" : 36,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.2857, "maximum" : 0.4286 }
},
{
"index" : 37,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.4286, "maximum" : 0.5714 }
},
{
"index" : 38,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.5714, "maximum" : 0.7143 }
},
{
"index" : 39,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.7143, "maximum" : 0.8571 }
},
{
"index" : 40,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.8571, "maximum" : 1.0000 }
},
{
"index" : 41,
"hscan" : { "minimum" : 0.9500, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 42,
"hscan" : { "minimum" : 0.9375, "maximum" : 1.0000 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 43,
"hscan" : { "minimum" : 0.8750, "maximum" : 0.9375 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 44,
"hscan" : { "minimum" : 0.8125, "maximum" : 0.8750 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 45,
"hscan" : { "minimum" : 0.7500, "maximum" : 0.8125 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 46,
"hscan" : { "minimum" : 0.6875, "maximum" : 0.7500 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 47,
"hscan" : { "minimum" : 0.6250, "maximum" : 0.6875 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 48,
"hscan" : { "minimum" : 0.5625, "maximum" : 0.6250 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
},
{
"index" : 49,
"hscan" : { "minimum" : 0.5000, "maximum" : 0.5625 },
"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
}
],
/// The black border configuration, contains the following items:
/// * enable : true if the detector should be activated
"blackborderdetector" :
{
"enable" : true
},
/// The boot-sequence configuration, contains the following items:
/// * type : The type of the boot-sequence ('rainbow', 'knightrider', 'none')
/// The boot-sequence configuration, contains the following items:
/// * type : The type of the boot-sequence ('rainbow', 'knight_rider', 'none')
/// * duration_ms : The length of the boot-sequence [ms]
"bootsequence" :
{
"type" : "Rainbow",
"duration_ms" : 3000
},
/// The configuration for the frame-grabber, contains the following items:
/// * width : The width of the grabbed frames [pixels]
/// * height : The height of the grabbed frames [pixels]
/// * frequency_Hz : The frequency of the frame grab [Hz]
"framegrabber" :
{
"width" : 64,
"height" : 64,
"frequency_Hz" : 10.0
},
/// The configuration of the XBMC connection used to enable and disable the frame-grabber. Contains the following fields:
/// * xbmcAddress : The IP address of the XBMC-host
/// * xbmcTcpPort : The TCP-port of the XBMC-server
/// * grabVideo : Flag indicating that the frame-grabber is on(true) during video playback
/// * grabPictures : Flag indicating that the frame-grabber is on(true) during picture show
/// * grabAudio : Flag indicating that the frame-grabber is on(true) during audio playback
/// * grabMenu : Flag indicating that the frame-grabber is on(true) in the XBMC menu
"xbmcVideoChecker" :
{
"xbmcAddress" : "127.0.0.1",
"xbmcTcpPort" : 9090,
"grabVideo" : true,
"grabPictures" : true,
"grabAudio" : true,
"grabMenu" : false
},
/// The configuration of the Json server which enables the json remote interface
/// * port : Port at which the json server is started
"jsonServer" :
{
"port" : 19444
},
/// The configuration of the Proto server which enables the protobuffer remote interface
/// * port : Port at which the protobuffer server is started
"protoServer" :
{
"port" : 19445
},
/// The configuration of the boblight server which enables the boblight remote interface
/// * port : Port at which the boblight server is started
// "boblightServer" :
// {
// "port" : 19333
// },
"end-of-json" : "end-of-json"
}

BIN
deploy/dispmanx2png Executable file
View File

Binary file not shown.

60
include/hyperion/Hyperion.h
View File

@ -19,9 +19,11 @@
#include <effectengine/EffectDefinition.h> #include <effectengine/EffectDefinition.h>
// Forward class declaration // Forward class declaration
class HsvTransform;
class ColorTransform; class ColorTransform;
class EffectEngine; class EffectEngine;
class HsvTransform;
class RgbChannelTransform;
class MultiColorTransform;
/// ///
/// The main class of Hyperion. This gives other 'users' access to the attached LedDevice through /// The main class of Hyperion. This gives other 'users' access to the attached LedDevice through
@ -37,7 +39,7 @@ public:
/// ///
/// RGB-Color channel enumeration /// RGB-Color channel enumeration
/// ///
enum Color enum RgbChannel
{ {
RED, GREEN, BLUE, INVALID RED, GREEN, BLUE, INVALID
}; };
@ -73,18 +75,6 @@ public:
/// ///
unsigned getLedCount() const; unsigned getLedCount() const;
///
/// Returns the value of a specific color transform
///
/// @param[in] transform The type of transform
/// @param[in] color The color channel to which the transform applies (only applicable for
/// Transform::THRESHOLD, Transform::GAMMA, Transform::BLACKLEVEL,
/// Transform::WHITELEVEL)
///
/// @return The value of the specified color transform
///
double getTransform(Transform transform, Color color) const;
/// ///
/// Returns a list of active priorities /// Returns a list of active priorities
/// ///
@ -127,15 +117,19 @@ public slots:
void setColors(int priority, const std::vector<ColorRgb> &ledColors, const int timeout_ms); void setColors(int priority, const std::vector<ColorRgb> &ledColors, const int timeout_ms);
/// ///
/// Sets/Updates a part of the color transformation. /// Returns the list with unique transform identifiers
/// @return The list with transform identifiers
/// ///
/// @param[in] transform The type of transform to configure const std::vector<std::string> & getTransformIds() const;
/// @param[in] color The color channel to which the transform applies (only applicable for
/// Transform::THRESHOLD, Transform::GAMMA, Transform::BLACKLEVEL,
/// Transform::WHITELEVEL)
/// @param[in] value The new value for the given transform
/// ///
void setTransform(Transform transform, Color color, double value); /// Returns the ColorTransform with the given identifier
/// @return The transform with the given identifier (or nullptr if the identifier does not exist)
///
ColorTransform * getTransform(const std::string& id);
/// Tell Hyperion that the transforms have changed and the leds need to be updated
void transformsUpdated();
/// ///
/// Clears the given priority channel. This will switch the led-colors to the colors of the next /// Clears the given priority channel. This will switch the led-colors to the colors of the next
@ -174,8 +168,12 @@ public:
static LedDevice * createDevice(const Json::Value & deviceConfig); static LedDevice * createDevice(const Json::Value & deviceConfig);
static ColorOrder createColorOrder(const Json::Value & deviceConfig); static ColorOrder createColorOrder(const Json::Value & deviceConfig);
static LedString createLedString(const Json::Value & ledsConfig); static LedString createLedString(const Json::Value & ledsConfig);
static MultiColorTransform * createLedColorsTransform(const unsigned ledCnt, const Json::Value & colorTransformConfig);
static ColorTransform * createColorTransform(const Json::Value & transformConfig);
static HsvTransform * createHsvTransform(const Json::Value & hsvConfig); static HsvTransform * createHsvTransform(const Json::Value & hsvConfig);
static ColorTransform * createColorTransform(const Json::Value & colorConfig); static RgbChannelTransform * createRgbChannelTransform(const Json::Value& colorConfig);
static LedDevice * createColorSmoothing(const Json::Value & smoothingConfig, LedDevice * ledDevice); static LedDevice * createColorSmoothing(const Json::Value & smoothingConfig, LedDevice * ledDevice);
signals: signals:
@ -195,28 +193,14 @@ private slots:
void update(); void update();
private: private:
///
/// Applies all color transmforms to the given list of colors. The transformation is performed
/// in place.
///
/// @param colors The colors to be transformed
///
void applyTransform(std::vector<ColorRgb>& colors) const;
/// The specifiation of the led frame construction and picture integration /// The specifiation of the led frame construction and picture integration
LedString _ledString; LedString _ledString;
/// The priority muxer /// The priority muxer
PriorityMuxer _muxer; PriorityMuxer _muxer;
/// The HSV Transform for applying Saturation and Value transforms /// The transformation from raw colors to led colors
HsvTransform * _hsvTransform; MultiColorTransform * _raw2ledTransform;
/// The RED-Channel (RGB) transform
ColorTransform * _redTransform;
/// The GREEN-Channel (RGB) transform
ColorTransform * _greenTransform;
/// The BLUE-Channel (RGB) transform
ColorTransform * _blueTransform;
/// Value with the desired color byte order /// Value with the desired color byte order
ColorOrder _colorOrder; ColorOrder _colorOrder;

228
libsrc/hyperion/Hyperion.cpp
View File

@ -5,6 +5,9 @@
// QT includes // QT includes
#include <QDateTime> #include <QDateTime>
#include <QThread> #include <QThread>
#include <QRegExp>
#include <QString>
#include <QStringList>
// JsonSchema include // JsonSchema include
#include <utils/jsonschema/JsonFactory.h> #include <utils/jsonschema/JsonFactory.h>
@ -23,11 +26,9 @@
#include "device/LedDeviceLightpack.h" #include "device/LedDeviceLightpack.h"
#include "device/LedDeviceMultiLightpack.h" #include "device/LedDeviceMultiLightpack.h"
#include "MultiColorTransform.h"
#include "LinearColorSmoothing.h" #include "LinearColorSmoothing.h"
#include <utils/ColorTransform.h>
#include <utils/HsvTransform.h>
// effect engine includes // effect engine includes
#include <effectengine/EffectEngine.h> #include <effectengine/EffectEngine.h>
@ -159,6 +160,98 @@ Hyperion::ColorOrder Hyperion::createColorOrder(const Json::Value &deviceConfig)
return ORDER_RGB; return ORDER_RGB;
} }
ColorTransform * Hyperion::createColorTransform(const Json::Value & transformConfig)
{
const std::string id = transformConfig.get("id", "default").asString();
RgbChannelTransform * redTransform = createRgbChannelTransform(transformConfig["red"]);
RgbChannelTransform * greenTransform = createRgbChannelTransform(transformConfig["green"]);
RgbChannelTransform * blueTransform = createRgbChannelTransform(transformConfig["blue"]);
HsvTransform * hsvTransform = createHsvTransform(transformConfig["hsv"]);
ColorTransform * transform = new ColorTransform();
transform->_id = id;
transform->_rgbRedTransform = *redTransform;
transform->_rgbGreenTransform = *greenTransform;
transform->_rgbBlueTransform = *blueTransform;
transform->_hsvTransform = *hsvTransform;
// Cleanup the allocated individual transforms
delete redTransform;
delete greenTransform;
delete blueTransform;
delete hsvTransform;
return transform;
}
MultiColorTransform * Hyperion::createLedColorsTransform(const unsigned ledCnt, const Json::Value & colorConfig)
{
// Create the result, the transforms are added to this
MultiColorTransform * transform = new MultiColorTransform(ledCnt);
const Json::Value transformConfig = colorConfig.get("transform", Json::nullValue);
if (transformConfig.isNull())
{
// Old style color transformation config (just one for all leds)
ColorTransform * colorTransform = createColorTransform(colorConfig);
transform->addTransform(colorTransform);
transform->setTransformForLed(colorTransform->_id, 0, ledCnt-1);
}
else if (!transformConfig.isArray())
{
ColorTransform * colorTransform = createColorTransform(transformConfig);
transform->addTransform(colorTransform);
transform->setTransformForLed(colorTransform->_id, 0, ledCnt-1);
}
else
{
const QRegExp overallExp("([0-9]+(\\-[0-9]+)?)(,[ ]*([0-9]+(\\-[0-9]+)?))*");
for (Json::UInt i = 0; i < transformConfig.size(); ++i)
{
const Json::Value & config = transformConfig[i];
ColorTransform * colorTransform = createColorTransform(config);
transform->addTransform(colorTransform);
const QString ledIndicesStr = config.get("leds", "").asCString();
if (!overallExp.exactMatch(ledIndicesStr))
{
std::cerr << "Given led indices " << i << " not correct format: " << ledIndicesStr.toStdString() << std::endl;
continue;
}
std::cout << "ColorTransform '" << colorTransform->_id << "' => [";
const QStringList ledIndexList = ledIndicesStr.split(",");
for (int i=0; i<ledIndexList.size(); ++i) {
if (i > 0)
{
std::cout << ", ";
}
if (ledIndexList[i].contains("-"))
{
QStringList ledIndices = ledIndexList[i].split("-");
int startInd = ledIndices[0].toInt();
int endInd = ledIndices[1].toInt();
transform->setTransformForLed(colorTransform->_id, startInd, endInd);
std::cout << startInd << "-" << endInd;
}
else
{
int index = ledIndexList[i].toInt();
transform->setTransformForLed(colorTransform->_id, index, index);
std::cout << index;
}
}
std::cout << "]" << std::endl;
}
}
return transform;
}
HsvTransform * Hyperion::createHsvTransform(const Json::Value & hsvConfig) HsvTransform * Hyperion::createHsvTransform(const Json::Value & hsvConfig)
{ {
const double saturationGain = hsvConfig.get("saturationGain", 1.0).asDouble(); const double saturationGain = hsvConfig.get("saturationGain", 1.0).asDouble();
@ -167,14 +260,14 @@ HsvTransform * Hyperion::createHsvTransform(const Json::Value & hsvConfig)
return new HsvTransform(saturationGain, valueGain); return new HsvTransform(saturationGain, valueGain);
} }
ColorTransform* Hyperion::createColorTransform(const Json::Value& colorConfig) RgbChannelTransform* Hyperion::createRgbChannelTransform(const Json::Value& colorConfig)
{ {
const double threshold = colorConfig.get("threshold", 0.0).asDouble(); const double threshold = colorConfig.get("threshold", 0.0).asDouble();
const double gamma = colorConfig.get("gamma", 1.0).asDouble(); const double gamma = colorConfig.get("gamma", 1.0).asDouble();
const double blacklevel = colorConfig.get("blacklevel", 0.0).asDouble(); const double blacklevel = colorConfig.get("blacklevel", 0.0).asDouble();
const double whitelevel = colorConfig.get("whitelevel", 1.0).asDouble(); const double whitelevel = colorConfig.get("whitelevel", 1.0).asDouble();
ColorTransform* transform = new ColorTransform(threshold, gamma, blacklevel, whitelevel); RgbChannelTransform* transform = new RgbChannelTransform(threshold, gamma, blacklevel, whitelevel);
return transform; return transform;
} }
@ -250,15 +343,16 @@ LedDevice * Hyperion::createColorSmoothing(const Json::Value & smoothingConfig,
Hyperion::Hyperion(const Json::Value &jsonConfig) : Hyperion::Hyperion(const Json::Value &jsonConfig) :
_ledString(createLedString(jsonConfig["leds"])), _ledString(createLedString(jsonConfig["leds"])),
_muxer(_ledString.leds().size()), _muxer(_ledString.leds().size()),
_hsvTransform(createHsvTransform(jsonConfig["color"]["hsv"])), _raw2ledTransform(createLedColorsTransform(_ledString.leds().size(), jsonConfig["color"])),
_redTransform(createColorTransform(jsonConfig["color"]["red"])),
_greenTransform(createColorTransform(jsonConfig["color"]["green"])),
_blueTransform(createColorTransform(jsonConfig["color"]["blue"])),
_colorOrder(createColorOrder(jsonConfig["device"])), _colorOrder(createColorOrder(jsonConfig["device"])),
_device(createDevice(jsonConfig["device"])), _device(createDevice(jsonConfig["device"])),
_effectEngine(nullptr), _effectEngine(nullptr),
_timer() _timer()
{ {
if (!_raw2ledTransform->verifyTransforms())
{
throw std::runtime_error("Color transformation incorrectly set");
}
// initialize the image processor factory // initialize the image processor factory
ImageProcessorFactory::getInstance().init(_ledString, jsonConfig["blackborderdetector"].get("enable", true).asBool()); ImageProcessorFactory::getInstance().init(_ledString, jsonConfig["blackborderdetector"].get("enable", true).asBool());
@ -289,13 +383,8 @@ Hyperion::~Hyperion()
// Delete the Led-String // Delete the Led-String
delete _device; delete _device;
// delete he hsv transform // delete the color transform
delete _hsvTransform; delete _raw2ledTransform;
// Delete the color-transform
delete _blueTransform;
delete _greenTransform;
delete _redTransform;
} }
unsigned Hyperion::getLedCount() const unsigned Hyperion::getLedCount() const
@ -330,55 +419,18 @@ void Hyperion::setColors(int priority, const std::vector<ColorRgb>& ledColors, c
} }
} }
void Hyperion::setTransform(Hyperion::Transform transform, Hyperion::Color color, double value) const std::vector<std::string> & Hyperion::getTransformIds() const
{ {
// select the transform of the requested color return _raw2ledTransform->getTransformIds();
ColorTransform * t = nullptr; }
switch (color)
{
case RED:
t = _redTransform;
break;
case GREEN:
t = _greenTransform;
break;
case BLUE:
t = _blueTransform;
break;
default:
break;
}
// set transform value ColorTransform * Hyperion::getTransform(const std::string& id)
switch (transform) {
{ return _raw2ledTransform->getTransform(id);
case SATURATION_GAIN: }
_hsvTransform->setSaturationGain(value);
break;
case VALUE_GAIN:
_hsvTransform->setValueGain(value);
break;
case THRESHOLD:
assert (t != nullptr);
t->setThreshold(value);
break;
case GAMMA:
assert (t != nullptr);
t->setGamma(value);
break;
case BLACKLEVEL:
assert (t != nullptr);
t->setBlacklevel(value);
break;
case WHITELEVEL:
assert (t != nullptr);
t->setWhitelevel(value);
break;
default:
assert(false);
}
// update the led output void Hyperion::transformsUpdated()
{
update(); update();
} }
@ -411,51 +463,6 @@ void Hyperion::clearall()
_effectEngine->allChannelsCleared(); _effectEngine->allChannelsCleared();
} }
double Hyperion::getTransform(Hyperion::Transform transform, Hyperion::Color color) const
{
// select the transform of the requested color
ColorTransform * t = nullptr;
switch (color)
{
case RED:
t = _redTransform;
break;
case GREEN:
t = _greenTransform;
break;
case BLUE:
t = _blueTransform;
break;
default:
break;
}
// set transform value
switch (transform)
{
case SATURATION_GAIN:
return _hsvTransform->getSaturationGain();
case VALUE_GAIN:
return _hsvTransform->getValueGain();
case THRESHOLD:
assert (t != nullptr);
return t->getThreshold();
case GAMMA:
assert (t != nullptr);
return t->getGamma();
case BLACKLEVEL:
assert (t != nullptr);
return t->getBlacklevel();
case WHITELEVEL:
assert (t != nullptr);
return t->getWhitelevel();
default:
assert(false);
}
return 999.0;
}
QList<int> Hyperion::getActivePriorities() const QList<int> Hyperion::getActivePriorities() const
{ {
return _muxer.getPriorities(); return _muxer.getPriorities();
@ -496,14 +503,9 @@ void Hyperion::update()
const PriorityMuxer::InputInfo & priorityInfo = _muxer.getInputInfo(priority); const PriorityMuxer::InputInfo & priorityInfo = _muxer.getInputInfo(priority);
// Apply the transform to each led and color-channel // Apply the transform to each led and color-channel
std::vector<ColorRgb> ledColors(priorityInfo.ledColors); std::vector<ColorRgb> ledColors = _raw2ledTransform->applyTransform(priorityInfo.ledColors);
for (ColorRgb& color : ledColors) for (ColorRgb& color : ledColors)
{ {
_hsvTransform->transform(color.red, color.green, color.blue);
color.red = _redTransform->transform(color.red);
color.green = _greenTransform->transform(color.green);
color.blue = _blueTransform->transform(color.blue);
// correct the color byte order // correct the color byte order
switch (_colorOrder) switch (_colorOrder)
{ {

98
libsrc/jsonserver/JsonClientConnection.cpp
View File

@ -12,9 +12,10 @@
#include <QDateTime> #include <QDateTime>
// hyperion util includes // hyperion util includes
#include "hyperion/ImageProcessorFactory.h" #include <hyperion/ImageProcessorFactory.h>
#include "hyperion/ImageProcessor.h" #include <hyperion/ImageProcessor.h>
#include "utils/ColorRgb.h" #include <hyperion/ColorTransform.h>
#include <utils/ColorRgb.h>
// project includes // project includes
#include "JsonClientConnection.h" #include "JsonClientConnection.h"
@ -197,25 +198,39 @@ void JsonClientConnection::handleServerInfoCommand(const Json::Value &)
} }
// collect transform information // collect transform information
Json::Value & transform = info["transform"] = Json::Value(Json::objectValue); Json::Value & transformArray = info["transform"];
transform["saturationGain"] = _hyperion->getTransform(Hyperion::SATURATION_GAIN, Hyperion::INVALID); for (const std::string& transformId : _hyperion->getTransformIds())
transform["valueGain"] = _hyperion->getTransform(Hyperion::VALUE_GAIN, Hyperion::INVALID); {
const ColorTransform * colorTransform = _hyperion->getTransform(transformId);
if (colorTransform == nullptr)
{
std::cerr << "Incorrect color transform id: " << transformId << std::endl;
continue;
}
Json::Value & transform = transformArray.append(Json::Value());
transform["id"] = transformId;
transform["saturationGain"] = colorTransform->_hsvTransform.getSaturationGain();
transform["valueGain"] = colorTransform->_hsvTransform.getValueGain();
Json::Value & threshold = transform["threshold"]; Json::Value & threshold = transform["threshold"];
threshold.append(_hyperion->getTransform(Hyperion::THRESHOLD, Hyperion::RED)); threshold.append(colorTransform->_rgbRedTransform.getThreshold());
threshold.append(_hyperion->getTransform(Hyperion::THRESHOLD, Hyperion::GREEN)); threshold.append(colorTransform->_rgbGreenTransform.getThreshold());
threshold.append(_hyperion->getTransform(Hyperion::THRESHOLD, Hyperion::BLUE)); threshold.append(colorTransform->_rgbBlueTransform.getThreshold());
Json::Value & gamma = transform["gamma"]; Json::Value & gamma = transform["gamma"];
gamma.append(_hyperion->getTransform(Hyperion::GAMMA, Hyperion::RED)); gamma.append(colorTransform->_rgbRedTransform.getGamma());
gamma.append(_hyperion->getTransform(Hyperion::GAMMA, Hyperion::GREEN)); gamma.append(colorTransform->_rgbGreenTransform.getGamma());
gamma.append(_hyperion->getTransform(Hyperion::GAMMA, Hyperion::BLUE)); gamma.append(colorTransform->_rgbBlueTransform.getGamma());
Json::Value & blacklevel = transform["blacklevel"]; Json::Value & blacklevel = transform["blacklevel"];
blacklevel.append(_hyperion->getTransform(Hyperion::BLACKLEVEL, Hyperion::RED)); blacklevel.append(colorTransform->_rgbRedTransform.getBlacklevel());
blacklevel.append(_hyperion->getTransform(Hyperion::BLACKLEVEL, Hyperion::GREEN)); blacklevel.append(colorTransform->_rgbGreenTransform.getBlacklevel());
blacklevel.append(_hyperion->getTransform(Hyperion::BLACKLEVEL, Hyperion::BLUE)); blacklevel.append(colorTransform->_rgbBlueTransform.getBlacklevel());
Json::Value & whitelevel = transform["whitelevel"]; Json::Value & whitelevel = transform["whitelevel"];
whitelevel.append(_hyperion->getTransform(Hyperion::WHITELEVEL, Hyperion::RED)); whitelevel.append(colorTransform->_rgbRedTransform.getWhitelevel());
whitelevel.append(_hyperion->getTransform(Hyperion::WHITELEVEL, Hyperion::GREEN)); whitelevel.append(colorTransform->_rgbGreenTransform.getWhitelevel());
whitelevel.append(_hyperion->getTransform(Hyperion::WHITELEVEL, Hyperion::BLUE)); whitelevel.append(colorTransform->_rgbBlueTransform.getWhitelevel());
}
// collect effect info // collect effect info
Json::Value & effects = info["effects"] = Json::Value(Json::arrayValue); Json::Value & effects = info["effects"] = Json::Value(Json::arrayValue);
@ -259,48 +274,59 @@ void JsonClientConnection::handleTransformCommand(const Json::Value &message)
{ {
const Json::Value & transform = message["transform"]; const Json::Value & transform = message["transform"];
const std::string transformId = transform.get("id", _hyperion->getTransformIds().front()).asString();
ColorTransform * colorTransform = _hyperion->getTransform(transformId);
if (colorTransform == nullptr)
{
//sendErrorReply(std::string("Incorrect transform identifier: ") + transformId);
return;
}
if (transform.isMember("saturationGain")) if (transform.isMember("saturationGain"))
{ {
_hyperion->setTransform(Hyperion::SATURATION_GAIN, Hyperion::INVALID, transform["saturationGain"].asDouble()); colorTransform->_hsvTransform.setSaturationGain(transform["saturationGain"].asDouble());
} }
if (transform.isMember("valueGain")) if (transform.isMember("valueGain"))
{ {
_hyperion->setTransform(Hyperion::VALUE_GAIN, Hyperion::INVALID, transform["valueGain"].asDouble()); colorTransform->_hsvTransform.setValueGain(transform["valueGain"].asDouble());
} }
if (transform.isMember("threshold")) if (transform.isMember("threshold"))
{ {
const Json::Value & threshold = transform["threshold"]; const Json::Value & values = transform["threshold"];
_hyperion->setTransform(Hyperion::THRESHOLD, Hyperion::RED, threshold[0u].asDouble()); colorTransform->_rgbRedTransform .setThreshold(values[0u].asDouble());
_hyperion->setTransform(Hyperion::THRESHOLD, Hyperion::GREEN, threshold[1u].asDouble()); colorTransform->_rgbGreenTransform.setThreshold(values[1u].asDouble());
_hyperion->setTransform(Hyperion::THRESHOLD, Hyperion::BLUE, threshold[2u].asDouble()); colorTransform->_rgbBlueTransform .setThreshold(values[2u].asDouble());
} }
if (transform.isMember("gamma")) if (transform.isMember("gamma"))
{ {
const Json::Value & threshold = transform["gamma"]; const Json::Value & values = transform["gamma"];
_hyperion->setTransform(Hyperion::GAMMA, Hyperion::RED, threshold[0u].asDouble()); colorTransform->_rgbRedTransform .setGamma(values[0u].asDouble());
_hyperion->setTransform(Hyperion::GAMMA, Hyperion::GREEN, threshold[1u].asDouble()); colorTransform->_rgbGreenTransform.setGamma(values[1u].asDouble());
_hyperion->setTransform(Hyperion::GAMMA, Hyperion::BLUE, threshold[2u].asDouble()); colorTransform->_rgbBlueTransform .setGamma(values[2u].asDouble());
} }
if (transform.isMember("blacklevel")) if (transform.isMember("blacklevel"))
{ {
const Json::Value & threshold = transform["blacklevel"]; const Json::Value & values = transform["blacklevel"];
_hyperion->setTransform(Hyperion::BLACKLEVEL, Hyperion::RED, threshold[0u].asDouble()); colorTransform->_rgbRedTransform .setBlacklevel(values[0u].asDouble());
_hyperion->setTransform(Hyperion::BLACKLEVEL, Hyperion::GREEN, threshold[1u].asDouble()); colorTransform->_rgbGreenTransform.setBlacklevel(values[1u].asDouble());
_hyperion->setTransform(Hyperion::BLACKLEVEL, Hyperion::BLUE, threshold[2u].asDouble()); colorTransform->_rgbBlueTransform .setBlacklevel(values[2u].asDouble());
} }
if (transform.isMember("whitelevel")) if (transform.isMember("whitelevel"))
{ {
const Json::Value & threshold = transform["whitelevel"]; const Json::Value & values = transform["whitelevel"];
_hyperion->setTransform(Hyperion::WHITELEVEL, Hyperion::RED, threshold[0u].asDouble()); colorTransform->_rgbRedTransform .setWhitelevel(values[0u].asDouble());
_hyperion->setTransform(Hyperion::WHITELEVEL, Hyperion::GREEN, threshold[1u].asDouble()); colorTransform->_rgbGreenTransform.setWhitelevel(values[1u].asDouble());
_hyperion->setTransform(Hyperion::WHITELEVEL, Hyperion::BLUE, threshold[2u].asDouble()); colorTransform->_rgbBlueTransform .setWhitelevel(values[2u].asDouble());
} }
// commit the changes
_hyperion->transformsUpdated();
sendSuccessReply(); sendSuccessReply();
} }

10
test/dispmanx2png/dispmanx2png.cpp
View File

@ -27,6 +27,7 @@ int main(int argc, char** argv)
signal(SIGINT, signal_handler); signal(SIGINT, signal_handler);
int grabFlags = 0; int grabFlags = 0;
int grabCount = -1;
try try
{ {
// create the option parser and initialize all parameters // create the option parser and initialize all parameters
@ -35,6 +36,8 @@ int main(int argc, char** argv)
QString flagDescr = QString("Set the grab flags of the dispmanx frame grabber [default: 0x%1]").arg(grabFlags, 8, 16, QChar('0')); QString flagDescr = QString("Set the grab flags of the dispmanx frame grabber [default: 0x%1]").arg(grabFlags, 8, 16, QChar('0'));
StringParameter & argFlags = parameters.add<StringParameter> ('f', "flags", flagDescr.toAscii().constData()); StringParameter & argFlags = parameters.add<StringParameter> ('f', "flags", flagDescr.toAscii().constData());
IntParameter & argCount = parameters.add<IntParameter> ('n', "count", "Number of images to capture (default infinite)");
argCount.setDefault(grabCount);
SwitchParameter<> & argList = parameters.add<SwitchParameter<> >('l', "list", "List the possible flags"); SwitchParameter<> & argList = parameters.add<SwitchParameter<> >('l', "list", "List the possible flags");
SwitchParameter<> & argHelp = parameters.add<SwitchParameter<> >('h', "help", "Show this help message and exit"); SwitchParameter<> & argHelp = parameters.add<SwitchParameter<> >('h', "help", "Show this help message and exit");
@ -90,6 +93,8 @@ int main(int argc, char** argv)
return -1; return -1;
} }
} }
grabCount = argCount.getValue();
} }
catch (const std::runtime_error & e) catch (const std::runtime_error & e)
{ {
@ -106,7 +111,7 @@ int main(int argc, char** argv)
QImage qImage(64, 64, QImage::Format_ARGB32); QImage qImage(64, 64, QImage::Format_ARGB32);
Image<ColorRgba> imageRgba(64, 64); Image<ColorRgba> imageRgba(64, 64);
while(running) for (int i=0; i<grabCount || grabCount < 0; ++i)
{ {
frameGrabber.grabFrame(imageRgba); frameGrabber.grabFrame(imageRgba);
@ -117,7 +122,7 @@ int main(int argc, char** argv)
} }
const QImage qImageSwp = qImage.rgbSwapped(); const QImage qImageSwp = qImage.rgbSwapped();
qImageSwp.save(QString("HYPERION_%3.png").arg(iFrame)); qImageSwp.save(QString("HYPERION_f0x%1_%2.png").arg(grabFlags, 8, 16, QChar('0')).arg(iFrame));
++iFrame; ++iFrame;
timespec sleepTime; timespec sleepTime;
@ -128,3 +133,4 @@ int main(int argc, char** argv)
return 0; return 0;
} }