diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/boblight-functions.h | 41 | ||||
| -rw-r--r-- | lib/boblight.cpp | 120 | ||||
| -rw-r--r-- | lib/boblight.h | 103 | ||||
| -rw-r--r-- | lib/boblight_client.cpp | 704 | ||||
| -rw-r--r-- | lib/boblight_client.h | 115 | ||||
| -rw-r--r-- | lib/options.h | 41 |
6 files changed, 1124 insertions, 0 deletions
diff --git a/lib/boblight-functions.h b/lib/boblight-functions.h new file mode 100644 index 0000000..0e0731e --- /dev/null +++ b/lib/boblight-functions.h @@ -0,0 +1,41 @@ +/* + * 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)); diff --git a/lib/boblight.cpp b/lib/boblight.cpp new file mode 100644 index 0000000..6c52136 --- /dev/null +++ b/lib/boblight.cpp @@ -0,0 +1,120 @@ +/* + * 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 "boblight.h" +#include "boblight_client.h" + +using namespace boblight; + +//C wrapper for C++ class + +void* boblight_init() +{ + CBoblight* boblight = new CBoblight; + return reinterpret_cast<void*>(boblight); +} + +void boblight_destroy(void* vpboblight) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + delete boblight; +} + +int boblight_connect(void* vpboblight, const char* address, int port, int usectimeout) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->Connect(address, port, usectimeout); +} + +int boblight_setpriority(void* vpboblight, int priority) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->SetPriority(priority); +} + +const char* boblight_geterror(void* vpboblight) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->GetError(); +} + +int boblight_getnrlights(void* vpboblight) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->GetNrLights(); +} + +const char* boblight_getlightname(void* vpboblight, int lightnr) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->GetLightName(lightnr); +} + +int boblight_getnroptions(void* vpboblight) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->GetNrOptions(); +} + +const char* boblight_getoptiondescript(void* vpboblight, int option) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->GetOptionDescription(option); +} + +int boblight_setoption(void* vpboblight, int lightnr, const char* option) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->SetOption(lightnr, option); +} + +int boblight_getoption(void* vpboblight, int lightnr, const char* option, const char** output) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->GetOption(lightnr, option, output); +} + +void boblight_setscanrange(void* vpboblight, int width, int height) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + boblight->SetScanRange(width, height); +} + +int boblight_addpixel(void* vpboblight, int lightnr, int* rgb) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->AddPixel(lightnr, rgb); +} + +void boblight_addpixelxy(void* vpboblight, int x, int y, int* rgb) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + boblight->AddPixel(rgb, x, y); +} + +int boblight_sendrgb(void* vpboblight, int sync, int* outputused) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->SendRGB(sync, outputused); +} + +int boblight_ping(void* vpboblight, int* outputused) +{ + CBoblight* boblight = reinterpret_cast<CBoblight*>(vpboblight); + return boblight->Ping(outputused, true); +} diff --git a/lib/boblight.h b/lib/boblight.h new file mode 100644 index 0000000..c596357 --- /dev/null +++ b/lib/boblight.h @@ -0,0 +1,103 @@ +/* + * 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 + diff --git a/lib/boblight_client.cpp b/lib/boblight_client.cpp new file mode 100644 index 0000000..dfab262 --- /dev/null +++ b/lib/boblight_client.cpp @@ -0,0 +1,704 @@ +/* + * 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 "util/inclstdint.h" + +#include <string> +#include <iostream> //debug +#include <sstream> + +#include "boblight_client.h" +#include "util/misc.h" +#include "util/timeutils.h" +#include "protocolversion.h" + +using namespace std; +using namespace boblight; + +#define GAMMASIZE (sizeof(m_gammacurve) / sizeof(m_gammacurve[0])) + +CLight::CLight() +{ + #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) variable = default; + #include "options.h" + #undef BOBLIGHT_OPTION + + m_singlechange = 0.0; + + m_width = -1; + m_height = -1; + + memset(m_rgb, 0, sizeof(m_rgb)); + m_rgbcount = 0; + memset(m_prevrgb, 0, sizeof(m_prevrgb)); + memset(m_hscanscaled, 0, sizeof(m_hscanscaled)); + memset(m_vscanscaled, 0, sizeof(m_vscanscaled)); + + for (int i = 0; i < GAMMASIZE; i++) + m_gammacurve[i] = i; +} + +string CLight::SetOption(const char* option, bool& send) +{ + string stroption = option; + string strname; + + send = false; + + if (!GetWord(stroption, strname)) + return "emtpy option"; //string with only whitespace + + #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \ + if (strname == #name) \ + { \ + type value; \ + if (#type == "bool")\ + {\ + if (!StrToBool(stroption, *(bool*)(&value)))\ + return "invalid value " + stroption + " for option " + strname + " with type " + #type; \ + }\ + else\ + {\ + stringstream stream; \ + stream << stroption; \ + stream >> value; \ + if (stream.fail()) return "invalid value " + stroption + " for option " + strname + " with type " + #type; \ + \ + }\ + variable = value; \ + postprocess\ + \ + return ""; \ + } + #include "options.h" + #undef BOBLIGHT_OPTION + + return "unknown option " + strname; +} + +std::string CLight::GetOption(const char* option, std::string& output) +{ + string stroption = option; + string strname; + + if (!GetWord(stroption, strname)) + return "emtpy option"; //string with only whitespace + + #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \ + if (#name == strname)\ + {\ + output = ToString(variable);\ + return "";\ + } + #include "options.h" + #undef BOBLIGHT_OPTION + + return "unknown option"; +} + +void CLight::AddPixel(int* rgb) +{ + if (rgb[0] >= m_threshold || rgb[1] >= m_threshold || rgb[2] >= m_threshold) + { + if (m_gamma == 1.0) + { + m_rgb[0] += Clamp(rgb[0], 0, 255); + m_rgb[1] += Clamp(rgb[1], 0, 255); + m_rgb[2] += Clamp(rgb[2], 0, 255); + } + else + { + m_rgb[0] += m_gammacurve[Clamp(rgb[0], 0, GAMMASIZE - 1)]; + m_rgb[1] += m_gammacurve[Clamp(rgb[1], 0, GAMMASIZE - 1)]; + m_rgb[2] += m_gammacurve[Clamp(rgb[2], 0, GAMMASIZE - 1)]; + } + } + m_rgbcount++; +} + +void CLight::GetRGB(float* rgb) +{ + //if no pixels are set, the denominator is 0, so just return black + if (m_rgbcount == 0) + { + for (int i = 0; i < 3; i++) + { + rgb[i] = 0.0f; + m_rgb[i] = 0.0f; + } + + return; + } + + //convert from numerator/denominator to float + for (int i = 0; i < 3; i++) + { + rgb[i] = Clamp(m_rgb[i] / (float)m_rgbcount / 255.0f, 0.0f, 1.0f); + m_rgb[i] = 0.0f; + } + m_rgbcount = 0; + + //this tries to set the speed based on how fast the input is changing + //it needs sync mode to work properly + if (m_autospeed > 0.0) + { + float change = Abs(rgb[0] - m_prevrgb[0]) + Abs(rgb[1] - m_prevrgb[1]) + Abs(rgb[2] - m_prevrgb[2]); + change /= 3.0; + + //only apply singlechange if it's large enough, otherwise we risk sending it continously + if (change > 0.001) + m_singlechange = Clamp(change * m_autospeed / 10.0, 0.0, 1.0); + else + m_singlechange = 0.0; + } + + memcpy(m_prevrgb, rgb, sizeof(m_prevrgb)); + + //we need some hsv adjustments + if (m_value != 1.0 || m_valuerange[0] != 0.0 || m_valuerange[1] != 1.0 || + m_saturation != 1.0 || m_satrange[0] != 0.0 || m_satrange[1] != 1.0) + { + //rgb - hsv conversion, thanks wikipedia! + float hsv[3]; + float max = Max(rgb[0], rgb[1], rgb[2]); + float min = Min(rgb[0], rgb[1], rgb[2]); + + if (min == max) //grayscale + { + hsv[0] = -1.0f; //undefined + hsv[1] = 0.0; //no saturation + hsv[2] = min; //value + } + else + { + if (max == rgb[0]) //red zone + { + hsv[0] = (60.0f * ((rgb[1] - rgb[2]) / (max - min)) + 360.0f); + while (hsv[0] >= 360.0f) + hsv[0] -= 360.0f; + } + else if (max == rgb[1]) //green zone + { + hsv[0] = 60.0f * ((rgb[2] - rgb[0]) / (max - min)) + 120.0f; + } + else if (max == rgb[2]) //blue zone + { + hsv[0] = 60.0f * ((rgb[0] - rgb[1]) / (max - min)) + 240.0f; + } + + hsv[1] = (max - min) / max; //saturation + hsv[2] = max; //value + } + + //saturation and value adjustment + hsv[1] = Clamp(hsv[1] * m_saturation, m_satrange[0], m_satrange[1]); + hsv[2] = Clamp(hsv[2] * m_value, m_valuerange[0], m_valuerange[1]); + + if (hsv[0] == -1.0f) //grayscale + { + for (int i = 0; i < 3; i++) + rgb[i] = hsv[2]; + } + else + { + int hi = (int)(hsv[0] / 60.0f) % 6; + float f = (hsv[0] / 60.0f) - (float)(int)(hsv[0] / 60.0f); + + float s = hsv[1]; + float v = hsv[2]; + float p = v * (1.0f - s); + float q = v * (1.0f - f * s); + float t = v * (1.0f - (1.0f - f) * s); + + if (hi == 0) + { rgb[0] = v; rgb[1] = t; rgb[2] = p; } + else if (hi == 1) + { rgb[0] = q; rgb[1] = v; rgb[2] = p; } + else if (hi == 2) + { rgb[0] = p; rgb[1] = v; rgb[2] = t; } + else if (hi == 3) + { rgb[0] = p; rgb[1] = q; rgb[2] = v; } + else if (hi == 4) + { rgb[0] = t; rgb[1] = p; rgb[2] = v; } + else if (hi == 5) + { rgb[0] = v; rgb[1] = p; rgb[2] = q; } + } + + for (int i = 0; i < 3; i++) + rgb[i] = Clamp(rgb[i], 0.0f, 1.0f); + } +} + +//scale the light's scanrange to the dimensions set with boblight_setscanrange() +void CLight::SetScanRange(int width, int height) +{ + m_width = width; + m_height = height; + + m_hscanscaled[0] = Round32(m_hscan[0] / 100.0 * ((float)width - 1)); + m_hscanscaled[1] = Round32(m_hscan[1] / 100.0 * ((float)width - 1)); + m_vscanscaled[0] = Round32(m_vscan[0] / 100.0 * ((float)height - 1)); + m_vscanscaled[1] = Round32(m_vscan[1] / 100.0 * ((float)height - 1)); +} + +int CBoblight::Connect(const char* address, int port, int usectimeout) +{ + CMessage message; + CTcpData data; + int64_t now; + int64_t target; + string word; + + //set address + m_usectimeout = usectimeout; + if (address) + m_address = address; + else + m_address = "127.0.0.1"; + + //set port + if (port >= 0) + m_port = port; + else + m_port = 19333; + + //try to open a tcp connection + if (m_socket.Open(m_address, m_port, m_usectimeout) != SUCCESS) + { + m_error = m_socket.GetError(); + return 0; + } + + //write hello to the server, we should get hello back + if (!WriteDataToSocket("hello\n")) + return 0; + + if (!ReadDataToQueue()) + return 0; + + message = m_messagequeue.GetMessage(); + if (!ParseWord(message, "hello")) + { + m_error = m_address + ":" + ToString(m_port) + " sent gibberish"; + return 0; + } + + //get the protocol version from the server + if (!WriteDataToSocket("get version\n")) + return 0; + + if (!ReadDataToQueue()) + return 0; + + message = m_messagequeue.GetMessage(); + + if (!ParseWord(message, "version") || !GetWord(message.message, word)) + { + m_error = m_address + ":" + ToString(m_port) + " sent gibberish"; + return 0; + } + + //if we don't get the same protocol version back as we have, we can't work together + if (word != PROTOCOLVERSION) + { + m_error = "version mismatch, " + m_address + ":" + ToString(m_port) + " has version \"" + word + + "\", libboblight has version \"" + PROTOCOLVERSION + "\""; + return 0; + } + + //get lights info, like number, names and area + if (!WriteDataToSocket("get lights\n")) + return 0; + + if (!ReadDataToQueue()) + return 0; + + message = m_messagequeue.GetMessage(); + if (!ParseLights(message)) + { + m_error = m_address + ":" + ToString(m_port) + " sent gibberish"; + return 0; + } + + return 1; +} + +CBoblight::CBoblight() +{ + int padsize = 1; + //get option name pad size so it looks pretty + #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \ + if (strlen(#name) + 1 > padsize)\ + padsize = strlen(#name) + 1; + #include "options.h" + #undef BOBLIGHT_OPTION + + //stick in a line that describes the options + string option = "name"; + option.append(Max(padsize - option.length(), 1), ' '); + option += "type min max default"; + m_options.push_back(option); + + //fill vector with option strings + #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \ + {\ + string option = #name;\ + option.append(padsize - strlen(#name), ' ');\ + \ + option += #type;\ + option.append(Max(8 - strlen(#type), 1), ' ');\ + \ + option += #min;\ + option.append(Max(8 - strlen(#min), 1), ' ');\ + \ + option += #max;\ + option.append(Max(8 - strlen(#max), 1), ' ');\ + \ + if (strcmp(#default, "-1.0") == 0)\ + option += "set by boblightd";\ + else\ + option += #default;\ + \ + m_options.push_back(option);\ + } + #include "options.h" + #undef BOBLIGHT_OPTION +} + +//reads from socket until timeout or one message has arrived +bool CBoblight::ReadDataToQueue() +{ + CTcpData data; + int64_t now = GetTimeUs(); + int64_t target = now + m_usectimeout; + int nrmessages = m_messagequeue.GetNrMessages(); + + while (now < target && m_messagequeue.GetNrMessages() == nrmessages) + { + if (m_socket.Read(data) != SUCCESS) + { + m_error = m_socket.GetError(); + return false; + } + + m_messagequeue.AddData(data.GetData()); + + if (m_messagequeue.GetRemainingDataSize() > MAXDATA) + { + m_error = m_address + ":" + ToString(m_port) + " sent too much data"; + return false; + } + + now = GetTimeUs(); + } + + if (nrmessages == m_messagequeue.GetNrMessages()) + { + m_error = m_address + ":" + ToString(m_port) + " read timed out"; + return false; + } + return true; +} + +bool CBoblight::WriteDataToSocket(std::string strdata) +{ + CTcpData data; + data.SetData(strdata); + + if (m_socket.Write(data) != SUCCESS) + { + m_error = m_socket.GetError(); + return false; + } + + return true; +} + +//removes one word from the string in the messages, and compares it to wordtocmp +bool CBoblight::ParseWord(CMessage& message, std::string wordtocmp) +{ + string readword; + if (!GetWord(message.message, readword) || readword != wordtocmp) + return false; + + return true; +} + +bool CBoblight::ParseLights(CMessage& message) +{ + string word; + int nrlights; + + //first word in the message is "lights", second word is the number of lights + if (!ParseWord(message, "lights") || !GetWord(message.message, word) || !StrToInt(word, nrlights) || nrlights < 1) + return false; + + for (int i = 0; i < nrlights; i++) + { + CLight light; + + //read some data to the message queue if we have no messages + if (m_messagequeue.GetNrMessages() == 0) + { + if (!ReadDataToQueue()) + return false; + } + + message = m_messagequeue.GetMessage(); + + //first word sent is "light, second one is the name + if (!ParseWord(message, "light") || !GetWord(message.message, light.m_name)) + { + return false; + } + + //third one is "scan" + if (!ParseWord(message, "scan")) + return false; + + //now we read the scanrange + string scanarea; + for (int i = 0; i < 4; i++) + { + if (!GetWord(message.message, word)) + return false; + + scanarea += word + " "; + } + + ConvertFloatLocale(scanarea); //workaround for locale mismatch (, and .) + + if (sscanf(scanarea.c_str(), "%f %f %f %f", light.m_vscan, light.m_vscan + 1, light.m_hscan, light.m_hscan + 1) != 4) + return false; + + m_lights.push_back(light); + } + return true; +} + +const char* CBoblight::GetLightName(int lightnr) +{ + if (lightnr < 0) //negative lights don't exist, so we set it to an invalid number to get the error message + lightnr = m_lights.size(); + + if (CheckLightExists(lightnr)) + return m_lights[lightnr].m_name.c_str(); + + return NULL; +} + +int CBoblight::SetPriority(int priority) +{ + string data = "set priority " + ToString(priority) + "\n"; + + return WriteDataToSocket(data); +} + +bool CBoblight::CheckLightExists(int lightnr, bool printerror /*= true*/) +{ + if (lightnr >= (int)m_lights.size()) + { + if (printerror) + { + m_error = "light " + ToString(lightnr) + " doesn't exist (have " + ToString(m_lights.size()) + " lights)"; + } + return false; + } + return true; +} + +void CBoblight::SetScanRange(int width, int height) +{ + for (int i = 0; i < m_lights.size(); i++) + { + m_lights[i].SetScanRange(width, height); + } +} + +int CBoblight::AddPixel(int lightnr, int* rgb) +{ + if (!CheckLightExists(lightnr)) + return 0; + + if (lightnr < 0) + { + for (int i = 0; i < m_lights.size(); i++) + m_lights[i].AddPixel(rgb); + } + else + { + m_lights[lightnr].AddPixel(rgb); + } + + return 1; +} + +void CBoblight::AddPixel(int* rgb, int x, int y) +{ + for (int i = 0; i < m_lights.size(); i++) + { + if (x >= m_lights[i].m_hscanscaled[0] && x <= m_lights[i].m_hscanscaled[1] && + y >= m_lights[i].m_vscanscaled[0] && y <= m_lights[i].m_vscanscaled[1]) + { + m_lights[i].AddPixel(rgb); + } + } +} + +int CBoblight::SendRGB(int sync, int* outputused) +{ + string data; + + for (int i = 0; i < m_lights.size(); i++) + { + float rgb[3]; + m_lights[i].GetRGB(rgb); + data += "set light " + m_lights[i].m_name + " rgb " + ToString(rgb[0]) + " " + ToString(rgb[1]) + " " + ToString(rgb[2]) + "\n"; + if (m_lights[i].m_autospeed > 0.0 && m_lights[i].m_singlechange > 0.0) + data += "set light " + m_lights[i].m_name + " singlechange " + ToString(m_lights[i].m_singlechange) + "\n"; + } + + //send a message that we want devices to sync to our input + if (sync) + data += "sync\n"; + + //if we want to check if our output is used, send a ping message + if (outputused) + data += "ping\n"; + + if (!WriteDataToSocket(data)) + return 0; + + if (outputused) + return Ping(outputused, false); + else + return 1; +} + +int CBoblight::Ping(int* outputused, bool send) +{ + string word; + + if (send) + { + if (!WriteDataToSocket("ping\n")) + return 0; + } + + if (!ReadDataToQueue()) + return 0; + + CMessage message = m_messagequeue.GetMessage(); + + if (!GetWord(message.message, word) || word != "ping") + { + m_error = m_address + ":" + ToString(m_port) + " sent gibberish"; + return 0; + } + + //client can set outputused to NULL + if (outputused) + { + if (!GetWord(message.message, word) || !StrToInt(word, *outputused)) + { + m_error = m_address + ":" + ToString(m_port) + " sent gibberish"; + return 0; + } + } + + return 1; +} + +int CBoblight::GetNrOptions() +{ + return m_options.size(); +} + +const char* CBoblight::GetOptionDescription(int option) +{ + if (option < 0 || option >= m_options.size()) + return NULL; + + return m_options[option].c_str(); +} + +int CBoblight::SetOption(int lightnr, const char* option) +{ + string error; + string data; + bool send; + + if (!CheckLightExists(lightnr)) + return 0; + + if (lightnr < 0) + { + for (int i = 0; i < m_lights.size(); i++) + { + error = m_lights[i].SetOption(option, send); + if (!error.empty()) + { + m_error = error; + return 0; + } + if (send) + { + data += "set light " + m_lights[i].m_name + " " + option + "\n"; + } + } + } + else + { + error = m_lights[lightnr].SetOption(option, send); + if (!error.empty()) + { + m_error = error; + return 0; + } + if (send) + { + data += "set light " + m_lights[lightnr].m_name + " " + option + "\n"; + } + } + + if (!WriteDataToSocket(data)) + return 0; + + return 1; +} + +int CBoblight::GetOption(int lightnr, const char* option, const char** output) +{ + if (lightnr < 0) //negative lights don't exist, so we set it to an invalid number to get the error message + lightnr = m_lights.size(); + + if (!CheckLightExists(lightnr)) + return 0; + + string error = m_lights[lightnr].GetOption(option, m_lastoption); + if (!error.empty()) + { + m_error = error; + return 0; + } + + *output = m_lastoption.c_str(); + + return 1; +} diff --git a/lib/boblight_client.h b/lib/boblight_client.h new file mode 100644 index 0000000..aac141d --- /dev/null +++ b/lib/boblight_client.h @@ -0,0 +1,115 @@ +/* + * 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 CBOBLIGHT +#define CBOBLIGHT + +#include <string> +#include <vector> + +#include "util/tcpsocket.h" +#include "util/messagequeue.h" + +namespace boblight +{ + class CLight + { + public: + CLight(); + + std::string SetOption(const char* option, bool& send); + std::string GetOption(const char* option, std::string& output); + + void SetScanRange(int width, int height); + void AddPixel(int* rgb); + + std::string m_name; + float m_speed; + float m_autospeed; + float m_singlechange; + + bool m_interpolation; + bool m_use; + + float m_value; + float m_valuerange[2]; + float m_saturation; + float m_satrange[2]; + int m_threshold; + float m_gamma; + float m_gammacurve[256]; + + float m_rgb[3]; + int m_rgbcount; + float m_prevrgb[3]; + void GetRGB(float* rgb); + + float m_hscan[2]; + float m_vscan[2]; + int m_width; + int m_height; + int m_hscanscaled[2]; + int m_vscanscaled[2]; + }; + + class CBoblight + { + public: + CBoblight(); + + int Connect(const char* address, int port, int usectimeout); + const char* GetError() { return m_error.c_str(); } + + int GetNrLights() { return m_lights.size(); } + const char* GetLightName (int lightnr); + + int SetPriority (int priority); + void SetScanRange (int width, int height); + + int AddPixel(int lightnr, int* rgb); + void AddPixel(int* rgb, int x, int y); + + int SendRGB(int sync, int* outputused); + int Ping(int* outputused, bool send); + + int GetNrOptions(); + const char* GetOptionDescription(int option); + int SetOption(int lightnr, const char* option); + int GetOption(int lightnr, const char* option, const char** output); + + private: + CTcpClientSocket m_socket; + std::string m_address; + int m_port; + std::string m_error; + CMessageQueue m_messagequeue; + int m_usectimeout; + + bool ReadDataToQueue(); + bool WriteDataToSocket(std::string strdata); + bool ParseWord(CMessage& message, std::string wordtocmp); + bool ParseLights(CMessage& message); + bool CheckLightExists(int lightnr, bool printerror = true); + + std::vector<CLight> m_lights; + + std::vector<std::string> m_options; + std::string m_lastoption; //place to store the last option retrieved by GetOption + }; +} +#endif //CBOBLIGHT diff --git a/lib/options.h b/lib/options.h new file mode 100644 index 0000000..05c3e82 --- /dev/null +++ b/lib/options.h @@ -0,0 +1,41 @@ +/* + * 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/>. + */ + +// name type min max default variable post-process +BOBLIGHT_OPTION(speed, float, 0.0, 100.0, 100.0, m_speed, m_speed = Clamp(m_speed, 0.0, 100.0); send = true;) +BOBLIGHT_OPTION(autospeed, float, 0, 100.0, 0.0, m_autospeed, m_autospeed = Max(m_autospeed, 0.0);) +BOBLIGHT_OPTION(interpolation, bool, false, true, false, m_interpolation, send = true;) +BOBLIGHT_OPTION(use, bool, false, true, true, m_use, send = true;) +BOBLIGHT_OPTION(saturation, float, 0.0, 20.0, 1.0, m_saturation, m_saturation = Max(m_saturation, 0.0);) +BOBLIGHT_OPTION(saturationmin, float, 0.0, 1.0, 0.0, m_satrange[0], m_satrange[0] = Clamp(m_satrange[0], 0.0, m_satrange[1]);) +BOBLIGHT_OPTION(saturationmax, float, 0.0, 1.0, 1.0, m_satrange[1], m_satrange[1] = Clamp(m_satrange[1], m_satrange[0], 1.0);) +BOBLIGHT_OPTION(value, float, 0.0, 20.0, 1.0, m_value, m_value = Max(m_value, 0.0);) +BOBLIGHT_OPTION(valuemin, float, 0.0, 1.0, 0.0, m_valuerange[0], m_valuerange[0] = Clamp(m_valuerange[0], 0.0, m_valuerange[1]);) +BOBLIGHT_OPTION(valuemax, float, 0.0, 1.0, 1.0, m_valuerange[1], m_valuerange[1] = Clamp(m_valuerange[1], m_valuerange[0], 1.0);) +BOBLIGHT_OPTION(threshold, int, 0, 255, 0, m_threshold, m_threshold = Clamp(m_threshold, 0, 255);) + +BOBLIGHT_OPTION(gamma, float, 0.0, 10.0, 1.0, m_gamma, m_gamma = Max(m_gamma, 0.0); \ + for (int i = 0; i < GAMMASIZE; i++) \ + m_gammacurve[i] = pow((float)i / ((float)GAMMASIZE - 1.0f), m_gamma) * (GAMMASIZE - 1.0f);) + +BOBLIGHT_OPTION(hscanstart, float, 0.0, 100.0, -1.0, m_hscan[0], m_hscan[0] = Clamp(m_hscan[0], 0.0, m_hscan[1]); SetScanRange(m_width, m_height);) +BOBLIGHT_OPTION(hscanend, float, 0.0, 100.0, -1.0, m_hscan[1], m_hscan[1] = Clamp(m_hscan[1], m_hscan[0], 100.0); SetScanRange(m_width, m_height);) +BOBLIGHT_OPTION(vscanstart, float, 0.0, 100.0, -1.0, m_vscan[0], m_vscan[0] = Clamp(m_vscan[0], 0.0, m_vscan[1]); SetScanRange(m_width, m_height);) +BOBLIGHT_OPTION(vscanend, float, 0.0, 100.0, -1.0, m_vscan[1], m_vscan[1] = Clamp(m_vscan[1], m_vscan[0], 100.0); SetScanRange(m_width, m_height);) + + |