feat: Add RGBW support to LedDeviceUdpE131

This commit introduces RGBW (Red, Green, Blue, White) data handling
for the E1.31 UDP LED device.

Key changes:

1.  **LedDeviceUdpE131.h modifications:**
    *   Included `utils/ColorRgbw.h` and `utils/RgbToRgbw.h`.
    *   Added private member variables:
        *   `_whiteAlgorithm` (RGBW::WhiteAlgorithm) to store the selected white calibration mode.
        *   `_ledRGBWCount` (int) to store the total number of channels (3 for RGB, 4 for RGBW).
        *   `_temp_rgbw` (ColorRgbw) as a temporary variable for color conversion.

2.  **LedDeviceUdpE131.cpp modifications:**
    *   Constructor now initializes `_whiteAlgorithm` to `INVALID` and `_ledRGBWCount` to 0.
    *   `init()` method:
        *   Reads `whiteAlgorithm` from the device configuration (defaults to "white_off").
        *   Converts the string to `RGBW::WhiteAlgorithm`.
        *   Sets `_ledRGBWCount` based on `_ledCount` and whether a white channel is active (3 * _ledCount for RGB, 4 * _ledCount for RGBW).
    *   `write()` method:
        *   Uses `_ledRGBWCount` for `dmxChannelCount`.
        *   Creates a temporary buffer for pixel data.
        *   If `_whiteAlgorithm` is `WHITE_OFF`, copies RGB data directly.
        *   Otherwise, converts RGB to RGBW using `RGBW::Rgb_to_Rgbw` and copies R,G,B,W data.
        *   Populates E1.31 packet properties using the new (potentially RGBW) data buffer.

3.  **JSON Schema Update (libsrc/leddevice/schemas/schema-e131.json):**
    *   Added a `whiteAlgorithm` property to the E1.31 device schema.
    *   This allows users to select the white channel calibration method ("white_off", "subtractive", "additive").
    *   Includes a default value of "white_off".

**Compilation Status:**

The project successfully configures with CMake after installing numerous dependencies (Qt6, libudev, XCB libs, ALSA, CEC, libp8-platform, libusb).
However, the `make` process consistently times out after approximately 6 minutes and 40 seconds, regardless of the number of parallel jobs (`-j nproc`, `-j 2`, `-j 1`) or if a specific target (`hyperiond`) is built.

This suggests a potential hang or an extremely long compilation step for a particular file/module within the project, which could not be identified due to lack of verbose output during the timeout.

Further investigation or environment adjustments are needed to complete the full build.

Author: google-labs-jules[bot]

libsrc/leddevice/dev_net/LedDeviceUdpE131.cpp

@@ -39,6 +39,8 @@ const int DMX_MAX = 512; // 512 usable slots
 
 LedDeviceUdpE131::LedDeviceUdpE131(const QJsonObject &deviceConfig)
 	: ProviderUdp(deviceConfig)
+	, _whiteAlgorithm(RGBW::WhiteAlgorithm::INVALID)
+	, _ledRGBWCount(0)
 {
 }
 
@@ -61,6 +63,28 @@ bool LedDeviceUdpE131::init(const QJsonObject &deviceConfig)
 		_e131_source_name = deviceConfig["source-name"].toString("hyperion on "+QHostInfo::localHostName());
 		QString _json_cid = deviceConfig["cid"].toString("");
 
+		// Initialize white algorithm
+		QString whiteAlgorithmStr = deviceConfig["whiteAlgorithm"].toString("white_off");
+		_whiteAlgorithm = RGBW::stringToWhiteAlgorithm(whiteAlgorithmStr);
+		if (_whiteAlgorithm == RGBW::WhiteAlgorithm::INVALID)
+		{
+			QString errortext = QString("unknown whiteAlgorithm: %1").arg(whiteAlgorithmStr);
+			this->setInError(errortext);
+			return false;
+		}
+		Debug(_log, "whiteAlgorithm : %s", QSTRING_CSTR(whiteAlgorithmStr));
+
+		// Calculate RGBW count
+		if (_whiteAlgorithm == RGBW::WhiteAlgorithm::WHITE_OFF)
+		{
+			_ledRGBWCount = _ledCount * 3;
+		}
+		else
+		{
+			_ledRGBWCount = _ledCount * 4;
+		}
+
+
 		if (_json_cid.isEmpty())
 		{
 			_e131_cid = QUuid::createUuid();
@@ -138,10 +162,32 @@ void LedDeviceUdpE131::prepare(unsigned this_universe, unsigned this_dmxChannelC
 
 int LedDeviceUdpE131::write(const std::vector<ColorRgb> &ledValues)
 {
-	int retVal            = 0;
+	int retVal = 0;
 	int thisChannelCount = 0;
-	int dmxChannelCount  = _ledRGBCount;
-	const uint8_t * rawdata = reinterpret_cast<const uint8_t *>(ledValues.data());
+	int dmxChannelCount = _ledRGBWCount; // Use _ledRGBWCount
+
+	// Create a temporary buffer for RGB or RGBW data
+	std::vector<uint8_t> tempBuffer(dmxChannelCount);
+	uint8_t* rawDataPtr = tempBuffer.data();
+
+	int currentChannel = 0;
+	for (const ColorRgb& color : ledValues)
+	{
+		if (_whiteAlgorithm == RGBW::WhiteAlgorithm::WHITE_OFF)
+		{
+			rawDataPtr[currentChannel++] = color.red;
+			rawDataPtr[currentChannel++] = color.green;
+			rawDataPtr[currentChannel++] = color.blue;
+		}
+		else
+		{
+			RGBW::Rgb_to_Rgbw(color, &_temp_rgbw, _whiteAlgorithm);
+			rawDataPtr[currentChannel++] = _temp_rgbw.red;
+			rawDataPtr[currentChannel++] = _temp_rgbw.green;
+			rawDataPtr[currentChannel++] = _temp_rgbw.blue;
+			rawDataPtr[currentChannel++] = _temp_rgbw.white;
+		}
+	}
 
 	_e131_seq++;
 
@@ -150,16 +196,16 @@ int LedDeviceUdpE131::write(const std::vector<ColorRgb> &ledValues)
 		if (rawIdx % DMX_MAX == 0) // start of new packet
 		{
 			thisChannelCount = (dmxChannelCount - rawIdx < DMX_MAX) ? dmxChannelCount % DMX_MAX : DMX_MAX;
-//			                       is this the last packet?         ?       ^^ last packet      : ^^ earlier packets
+			// is this the last packet? ? ^^ last packet : ^^ earlier packets
 
 			prepare(_e131_universe + rawIdx / DMX_MAX, thisChannelCount);
 			e131_packet.sequence_number = _e131_seq;
 		}
 
-		e131_packet.property_values[1 + rawIdx%DMX_MAX] = rawdata[rawIdx];
+		e131_packet.property_values[1 + rawIdx % DMX_MAX] = rawDataPtr[rawIdx];
 
-//     is this the      last byte of last packet    ||   last byte of other packets
-		if ( (rawIdx == dmxChannelCount-1) || (rawIdx %DMX_MAX == DMX_MAX-1) )
+		// is this the last byte of last packet || last byte of other packets
+		if ((rawIdx == dmxChannelCount - 1) || (rawIdx % DMX_MAX == DMX_MAX - 1))
 		{
 #undef e131debug
 #if e131debug

libsrc/leddevice/dev_net/LedDeviceUdpE131.h

@@ -3,6 +3,8 @@
 
 // hyperion includes
 #include "ProviderUdp.h"
+#include "utils/ColorRgbw.h"
+#include "utils/RgbToRgbw.h"
 
 #include <QUuid>
 
@@ -142,6 +144,11 @@ class LedDeviceUdpE131 : public ProviderUdp
 	uint8_t _acn_id[12] = {0x41, 0x53, 0x43, 0x2d, 0x45, 0x31, 0x2e, 0x31, 0x37, 0x00, 0x00, 0x00 };
 	QString _e131_source_name;
 	QUuid _e131_cid;
+
+	// RGBW specific members
+	RGBW::WhiteAlgorithm _whiteAlgorithm;
+	int _ledRGBWCount;
+	ColorRgbw _temp_rgbw;
 };
 
 #endif // LEDEVICEUDPE131_H

libsrc/leddevice/schemas/schema-e131.json

@@ -36,6 +36,24 @@
       "type": "string",
       "title": "edt_dev_spec_cid_title",
       "propertyOrder": 5
+    },
+    "whiteAlgorithm": {
+      "type": "string",
+      "title": "edt_dev_spec_white_algorithm_title",
+      "enum": [
+        "white_off",
+        "subtractive",
+        "additive"
+      ],
+      "default": "white_off",
+      "propertyOrder": 6,
+      "options": {
+        "enum_titles": [
+          "edt_dev_spec_white_algorithm_white_off",
+          "edt_dev_spec_white_algorithm_subtractive",
+          "edt_dev_spec_white_algorithm_additive"
+        ]
+      }
     }
   },
   "additionalProperties": true