post PR3904 fixes and improvements

* fix compiler warnings (uninitialized vars, ambiguous  functions calls)
* restore some lost function prototypes
* avoid negative pixel indices
* only use "fast" color_add when there is no risk of  "overshooting" results
* minor optimizations

Author: softhack007

wled00/FX.cpp

@@ -5627,7 +5627,7 @@ uint16_t mode_2DPlasmaball(void) {                   // By: Stepko https://edito
                                     (rows - 1 - cy == 0)) ? ColorFromPalette(SEGPALETTE, beat8(5), thisVal, LINEARBLEND) : CRGB::Black);
     }
   }
-  SEGMENT.blur(SEGMENT.custom2>>5);
+  SEGMENT.blur(SEGMENT.custom2>>5, (SEGMENT.custom2 > 132));  // WLEDMM
 
   return FRAMETIME;
 } // mode_2DPlasmaball()

wled00/FX.h

@@ -661,11 +661,11 @@ typedef struct Segment {
     inline void setPixelColorXY(unsigned x, unsigned y, uint32_t c)               { setPixelColorXY(int(x), int(y), c); }
     inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColorXY(x, y, RGBW32(r,g,b,w)); }
     inline void setPixelColorXY(int x, int y, CRGB c)                             { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0)); }
-    #ifdef WLED_USE_AA_PIXELS
-    void setPixelColorXY(float x, float y, uint32_t c, bool aa = true);
+    //#ifdef WLED_USE_AA_PIXELS
+    void setPixelColorXY(float x, float y, uint32_t c, bool aa = true, bool fast=true);
     inline void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColorXY(x, y, RGBW32(r,g,b,w), aa); }
     inline void setPixelColorXY(float x, float y, CRGB c, bool aa = true)                             { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0), aa); }
-    #endif
+    //#endif
     uint32_t __attribute__((pure)) getPixelColorXY(int x, int y);
     // 2D support functions
     void blendPixelColorXY(uint16_t x, uint16_t y, uint32_t color, uint8_t blend);
@@ -700,11 +700,11 @@ typedef struct Segment {
     inline void setPixelColorXY(unsigned x, unsigned y, uint32_t c)               { setPixelColor(int(x), c); }
     inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColor(x, RGBW32(r,g,b,w)); }
     inline void setPixelColorXY(int x, int y, CRGB c)                             { setPixelColor(x, RGBW32(c.r,c.g,c.b,0)); }
-    #ifdef WLED_USE_AA_PIXELS
+    //#ifdef WLED_USE_AA_PIXELS
     inline void setPixelColorXY(float x, float y, uint32_t c, bool aa = true)     { setPixelColor(x, c, aa); }
     inline void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColor(x, RGBW32(r,g,b,w), aa); }
     inline void setPixelColorXY(float x, float y, CRGB c, bool aa = true)         { setPixelColor(x, RGBW32(c.r,c.g,c.b,0), aa); }
-    #endif
+    //#endif
     inline uint32_t getPixelColorXY(uint16_t x, uint16_t y)                       { return getPixelColor(x); }
     inline void blendPixelColorXY(uint16_t x, uint16_t y, uint32_t c, uint8_t blend) { blendPixelColor(x, c, blend); }
     inline void blendPixelColorXY(uint16_t x, uint16_t y, CRGB c, uint8_t blend)  { blendPixelColor(x, RGBW32(c.r,c.g,c.b,0), blend); }

wled00/FX_2Dfcn.cpp

@@ -214,7 +214,7 @@ uint32_t WS2812FX::getPixelColorXY(uint16_t x, uint16_t y) {
 void IRAM_ATTR_YN Segment::setPixelColorXY(int x, int y, uint32_t col) //WLEDMM: IRAM_ATTR conditionally
 {
   if (Segment::maxHeight==1) return; // not a matrix set-up
-  if (x >= virtualWidth() || y >= virtualHeight() || x<0 || y<0) return;  // if pixel would fall out of virtual segment just exit
+  if (x<0 || y<0 || x >= virtualWidth() || y >= virtualHeight()) return;  // if pixel would fall out of virtual segment just exit
 
   if (ledsrgb) ledsrgb[XY(x,y)] = col;
 
@@ -307,7 +307,7 @@ void Segment::setPixelColorXY(float x, float y, uint32_t col, bool aa, bool fast
 
 // returns RGBW values of pixel
 uint32_t IRAM_ATTR_YN Segment::getPixelColorXY(int x, int y) {
-  if (!isActive()) return 0; // not active
+  if (x<0 || y<0 || !isActive()) return 0; // not active or out-of range
   int i = XY(x,y);
   if (ledsrgb) return RGBW32(ledsrgb[i].r, ledsrgb[i].g, ledsrgb[i].b, 0);
   if (reverse  ) x = virtualWidth()  - x - 1;
@@ -353,7 +353,7 @@ void Segment::fadePixelColorXY(uint16_t x, uint16_t y, uint8_t fade) {
 
 // blurRow: perform a blur on a row of a rectangular matrix
 void Segment::blurRow(uint32_t row, fract8 blur_amount, bool smear){
-  if (!isActive() || blur_amount == 0) return; // not active
+  if (!isActive()) return; // not active
   const uint_fast16_t cols = virtualWidth();
   const uint_fast16_t rows = virtualHeight();
 
@@ -364,30 +364,30 @@ void Segment::blurRow(uint32_t row, fract8 blur_amount, bool smear){
   uint32_t carryover = BLACK;
   uint32_t lastnew;
   uint32_t last;
-  uint32_t curnew;
+  uint32_t curnew = 0;
   for (unsigned x = 0; x < cols; x++) {
     uint32_t cur = getPixelColorXY(x, row);
     uint32_t part = color_fade(cur, seep);
     curnew = color_fade(cur, keep);
     if (x > 0) {
       if (carryover)
-        curnew = color_add(curnew, carryover, true);
-      uint32_t prev = color_add(lastnew, part, true);
+        curnew = color_add(curnew, carryover, !smear); // WLEDMM don't use "fast" when smear==true (better handling of bright colors)
+      uint32_t prev = color_add(lastnew, part, !smear);// WLEDMM
       if (last != prev) // optimization: only set pixel if color has changed
-        setPixelColorXY(x - 1, row, prev);
+        setPixelColorXY(int(x - 1), int(row), prev);
     }
     else // first pixel
-      setPixelColorXY(x, row, curnew);
+      setPixelColorXY(int(x), int(row), curnew);
     lastnew = curnew;
     last = cur; // save original value for comparison on next iteration
     carryover = part;
   }
-  setPixelColorXY(cols-1, row, curnew); // set last pixel
+  setPixelColorXY(int(cols-1), int(row), curnew); // set last pixel
 }
 
 // blurCol: perform a blur on a column of a rectangular matrix
 void Segment::blurCol(uint32_t col, fract8 blur_amount, bool smear) {
-  if (!isActive() || blur_amount == 0) return; // not active
+  if (!isActive()) return; // not active
   const uint_fast16_t cols = virtualWidth();
   const uint_fast16_t rows = virtualHeight();
 
@@ -398,25 +398,25 @@ void Segment::blurCol(uint32_t col, fract8 blur_amount, bool smear) {
   uint32_t carryover = BLACK;
   uint32_t lastnew;
   uint32_t last;
-  uint32_t curnew;
+  uint32_t curnew = 0;
   for (unsigned y = 0; y < rows; y++) {
     uint32_t cur = getPixelColorXY(col, y);
     uint32_t part = color_fade(cur, seep);
     curnew = color_fade(cur, keep);
     if (y > 0) {
       if (carryover)
-        curnew = color_add(curnew, carryover, true);
-      uint32_t prev = color_add(lastnew, part, true);      
+        curnew = color_add(curnew, carryover, !smear);  // WLEDMM don't use "fast" when smear==true (better handling of bright colors)
+      uint32_t prev = color_add(lastnew, part, !smear); // WLEDMM
       if (last != prev) // optimization: only set pixel if color has changed
-        setPixelColorXY(col, y - 1, prev);
+        setPixelColorXY(int(col), int(y - 1), prev);
     }
     else // first pixel
-      setPixelColorXY(col, y, curnew);
+      setPixelColorXY(int(col), int(y), curnew);
     lastnew = curnew;
     last = cur; //save original value for comparison on next iteration
     carryover = part;        
   }
-  setPixelColorXY(col, rows - 1, curnew);
+  setPixelColorXY(int(col), int(rows - 1), curnew);
 }
 
 // 1D Box blur (with added weight - blur_amount: [0=no blur, 255=max blur])

wled00/FX_fcn.cpp

@@ -1358,10 +1358,10 @@ void Segment::blur(uint8_t blur_amount, bool smear) {
 #ifndef WLED_DISABLE_2D
   if (is2D()) {
     // compatibility with 2D
-    const unsigned cols = virtualWidth();
-    const unsigned rows = virtualHeight();
-    for (unsigned i = 0; i < rows; i++) blurRow(i, blur_amount, smear); // blur all rows
-    for (unsigned k = 0; k < cols; k++) blurCol(k, blur_amount, smear); // blur all columns
+    const uint_fast32_t cols = virtualWidth();
+    const uint_fast32_t rows = virtualHeight();
+    for (uint_fast32_t i = 0; i < rows; i++) blurRow(i, blur_amount, smear); // blur all rows
+    for (uint_fast32_t k = 0; k < cols; k++) blurCol(k, blur_amount, smear); // blur all columns
     return;
   }
 #endif
@@ -1371,25 +1371,25 @@ void Segment::blur(uint8_t blur_amount, bool smear) {
   uint32_t carryover = BLACK;
   uint32_t lastnew;
   uint32_t last;
-  uint32_t curnew;
+  uint32_t curnew = 0;
   for (unsigned i = 0; i < vlength; i++) {
     uint32_t cur = getPixelColor(i);
     uint32_t part = color_fade(cur, seep);
     curnew = color_fade(cur, keep);
     if (i > 0) {
       if (carryover)
-        curnew = color_add(curnew, carryover, true);
-      uint32_t prev = color_add(lastnew, part, true);
+        curnew = color_add(curnew, carryover, !smear);  // WLEDMM
+      uint32_t prev = color_add(lastnew, part, !smear); // WLEDMM
       if (last != prev) // optimization: only set pixel if color has changed
-        setPixelColor(i - 1, prev);
+        setPixelColor(int(i - 1), prev);
     }
     else // first pixel
-      setPixelColor(i, curnew);
+      setPixelColor(int(i), curnew);
     lastnew = curnew;
     last = cur; // save original value for comparison on next iteration
     carryover = part;
   }
-  setPixelColor(vlength - 1, curnew);
+  setPixelColor(int(vlength - 1), curnew);
 }
 
 /*

wled00/colors.cpp

@@ -35,8 +35,11 @@ IRAM_ATTR_YN uint32_t color_blend(uint32_t color1, uint32_t color2, uint_fast16_
  * color add function that preserves ratio
  * idea: https://github.com/Aircoookie/WLED/pull/2465 by https://github.com/Proto-molecule
  */
-IRAM_ATTR_YN uint32_t color_add(uint32_t c1, uint32_t c2)   // WLEDMM added IRAM_ATTR_YN
+IRAM_ATTR_YN uint32_t color_add(uint32_t c1, uint32_t c2, bool fast)   // WLEDMM added IRAM_ATTR_YN
 {
+  if (c2 == 0) return c1;  // WLEDMM shortcut
+  if (c1 == 0) return c2;  // WLEDMM shortcut
+
   if (fast) {
     uint8_t r = R(c1);
     uint8_t g = G(c1);
@@ -52,7 +55,7 @@ IRAM_ATTR_YN uint32_t color_add(uint32_t c1, uint32_t c2)   // WLEDMM added IRAM
     uint32_t g = G(c1) + G(c2);
     uint32_t b = B(c1) + B(c2);
     uint32_t w = W(c1) + W(c2);
-    uint_fast16_t max = r;
+    uint32_t max = r;
     if (g > max) max = g;
     if (b > max) max = b;
     if (w > max) max = w;
@@ -66,8 +69,10 @@ IRAM_ATTR_YN uint32_t color_add(uint32_t c1, uint32_t c2)   // WLEDMM added IRAM
  * if using "video" method the resulting color will never become black unless it is already black
  */
 
-uint32_t color_fade(uint32_t c1, uint8_t amount, bool video)
+IRAM_ATTR_YN uint32_t color_fade(uint32_t c1, uint8_t amount, bool video)
 {
+  if (amount == 0) return 0; // WLEDMM shortcut
+
   uint32_t scaledcolor; // color order is: W R G B from MSB to LSB
   uint32_t r = R(c1);
   uint32_t g = G(c1);
@@ -78,15 +83,15 @@ uint32_t color_fade(uint32_t c1, uint8_t amount, bool video)
     scaledcolor = (((r * scale) >> 8) << 16) + ((r && scale) ? 1 : 0);
     scaledcolor |= (((g * scale) >> 8) << 8) + ((g && scale) ? 1 : 0);
     scaledcolor |= ((b * scale) >> 8) + ((b && scale) ? 1 : 0);
-    scaledcolor |= (((w * scale) >> 8) << 24) + ((w && scale) ? 1 : 0);
+    if (w>0) scaledcolor |= (((w * scale) >> 8) << 24) + ((scale) ? 1 : 0);  // WLEDMM small speedup when no white channel
     return scaledcolor;
   }
   else  {
     uint32_t scale = 1 + amount;
     scaledcolor = ((r * scale) >> 8) << 16;
     scaledcolor |= ((g * scale) >> 8) << 8;
     scaledcolor |= (b * scale) >> 8;
-    scaledcolor |= ((w * scale) >> 8) << 24;
+    if (w>0) scaledcolor |= ((w * scale) >> 8) << 24;                              // WLEDMM small speedup when no white channel
     return scaledcolor;
   }
 }

wled00/fcn_declare.h

@@ -51,7 +51,8 @@ bool getJsonValue(const JsonVariant& element, DestType& destination, const Defau
 
 //colors.cpp
 uint32_t __attribute__((const)) color_blend(uint32_t,uint32_t,uint_fast16_t,bool b16=false);  // WLEDMM: added attribute const
-uint32_t  __attribute__((const)) color_add(uint32_t,uint32_t);                                // WLEDMM: added attribute const
+uint32_t __attribute__((const)) color_add(uint32_t,uint32_t, bool fast=false);                // WLEDMM: added attribute const
+uint32_t __attribute__((const)) color_fade(uint32_t c1, uint8_t amount, bool video=false);
 inline uint32_t colorFromRgbw(byte* rgbw) { return uint32_t((byte(rgbw[3]) << 24) | (byte(rgbw[0]) << 16) | (byte(rgbw[1]) << 8) | (byte(rgbw[2]))); }
 void colorHStoRGB(uint16_t hue, byte sat, byte* rgb); //hue, sat to rgb
 void colorKtoRGB(uint16_t kelvin, byte* rgb);

wled00/wled.h

@@ -8,7 +8,7 @@
  */
 
 // version code in format yymmddb (b = daily build)
-#define VERSION 2404161
+#define VERSION 2404181
 
 // WLEDMM  - you can check for this define in usermods, to only enabled WLEDMM specific code in the "right" fork. Its not defined in AC WLED.
 #define _MoonModules_WLED_