fix(testing): don't skip the trailing partial pixel in test patterns

Author: darylc

src/channeltester/RGBChase.cpp

@@ -90,12 +90,19 @@ int TestPatternRGBChase::SetupTest(void) {
         bzero(m_testData, m_channelCount);
     }
 
+    // A trailing partial pixel (a channel count that is not a multiple of the
+    // stride, as an arbitrary set of discrete channels gives) is filled with as
+    // much of its color as fits instead of being skipped and left dark. The
+    // pattern offset still advances by a whole stride so the wrap point is
+    // unchanged for the whole-pixel case.
     char* c = m_testData;
     int offset = 0;
-    for (int i = 0; i + stride <= m_channelCount; i += stride) {
-        for (int j = 0; j < stride; j++)
-            *(c++) = m_colorPattern[offset++];
+    for (int i = 0; i < m_channelCount; i += stride) {
+        int count = std::min(stride, m_channelCount - i);
+        for (int j = 0; j < count; j++)
+            *(c++) = m_colorPattern[offset + j];
 
+        offset += stride;
         if (offset >= m_colorPattern.size())
             offset = 0;
     }

src/channeltester/RGBCycle.cpp

@@ -81,10 +81,12 @@ int TestPatternRGBCycle::SetupTest(void) {
         m_colorPattern.push_back(0);
     }
 
+    // A trailing partial pixel (a channel count that is not a multiple of the
+    // stride, as an arbitrary set of discrete channels gives) gets the leading
+    // channels of the color rather than being skipped and left dark.
     char* c = m_testData;
-    for (int i = 0; i + stride <= m_channelCount; i += stride) {
-        for (int j = 0; j < stride; j++)
-            *(c++) = m_colorPattern[j];
+    for (int i = 0; i < m_channelCount; i++) {
+        *(c++) = m_colorPattern[i % stride];
     }
 
     m_patternOffset = 0;
@@ -102,10 +104,12 @@ void TestPatternRGBCycle::CycleData(void) {
     if (m_patternOffset >= m_colorPattern.size()) {
         m_patternOffset = 0;
     }
+    // Same trailing-partial-pixel handling as SetupTest(): unlike the chase,
+    // which shifts the whole buffer with memmove(), every cycle here rewrites
+    // the data from scratch, so skipping the tail left it dark permanently.
     char* c = m_testData;
-    for (int i = 0; i + stride <= m_channelCount; i += stride) {
-        for (int j = 0; j < stride; j++)
-            *(c++) = m_colorPattern[m_patternOffset + j];
+    for (int i = 0; i < m_channelCount; i++) {
+        *(c++) = m_colorPattern[m_patternOffset + (i % stride)];
     }
 }
 

src/channeltester/RGBFill.cpp

@@ -88,19 +88,17 @@ int TestPatternRGBFill::SetupTest(void) {
     // Stride is driven by the model/color order (3 for RGB, 4 for RGBW), not by
     // whether the white value happens to be non-zero, so RGBW pixels stay aligned
     // even when filling a pure color (W = 0).
-    if (m_channelsPerNode == 4) {
-        for (int i = 0; i + 4 <= m_channelCount; i += 4) {
-            *(c++) = m_color1;
-            *(c++) = m_color2;
-            *(c++) = m_color3;
-            *(c++) = m_color4;
-        }
-    } else {
-        for (int i = 0; i + 3 <= m_channelCount; i += 3) {
-            *(c++) = m_color1;
-            *(c++) = m_color2;
-            *(c++) = m_color3;
-        }
+    //
+    // The channel set need not be a whole number of pixels - eight discrete
+    // channels ("151;167;...;263") tested as RGB is a channelCount of 8 with a
+    // stride of 3 - so the trailing partial pixel is filled too rather than
+    // left at the bzero() value, which used to leave those channels dark for
+    // the whole test.
+    const char colors[4] = { (char)m_color1, (char)m_color2, (char)m_color3, (char)m_color4 };
+    const int stride = m_channelsPerNode;
+
+    for (int i = 0; i < m_channelCount; i++) {
+        *(c++) = colors[i % stride];
     }
 
     return TestPatternBase::SetupTest();

www/testing.php

@@ -1121,18 +1121,12 @@ function SetDMXTestMode() {
 				for (var i = 0; i < count; i++) {
 					pattern += dmxToHex(dmxValues[i]);
 				}
-				// Pad to a multiple of 6 hex chars (RGB triplet) so the pattern parser
-				// doesn't append zeros that would alter our channel count.
-				while ((pattern.length % 6) !== 0) {
-					pattern += '00';
-				}
-
+				// Neither the pattern nor the range is padded out to a whole RGB
+				// triplet: fppd fills a trailing partial pixel, so the fixture's
+				// channels are driven exactly as selected. Rounding the range up (as
+				// this did while the test patterns skipped that partial pixel) drove
+				// up to two channels past the end of the fixture.
 				var endCh = startCh + count - 1;
-				// Ensure channel range is a multiple of 3 to align with the pattern's
-				// triplet-based padding above.
-				while (((endCh - startCh + 1) % 3) !== 0) {
-					endCh++;
-				}
 
 				data = {
 					"command": "Test Start",