Fixes for over 65535 LEDs

Author: troyhacks

wled00/FX.cpp

@@ -357,9 +357,9 @@ typedef enum mapping1D2D {
 // segment, 72 bytes
 typedef struct Segment {
   public:
-    uint16_t start; // start index / start X coordinate 2D (left)
-    uint16_t stop;  // stop index / stop X coordinate 2D (right); segment is invalid if stop == 0
-    uint16_t offset;
+    uint32_t start; // start index / start X coordinate 2D (left)
+    uint32_t stop;  // stop index / stop X coordinate 2D (right); segment is invalid if stop == 0
+    uint32_t offset;
     uint8_t  speed;
     uint8_t  intensity;
     uint8_t  palette;
@@ -395,8 +395,8 @@ typedef struct Segment {
       bool    check2  : 1;        // checkmark 2
       bool    check3  : 1;        // checkmark 3
     };
-    uint16_t startY;  // start Y coodrinate 2D (top); there should be no more than 255 rows, but we cannot be sure.
-    uint16_t stopY;   // stop Y coordinate 2D (bottom); there should be no more than 255 rows, but we cannot be sure.
+    uint32_t startY;  // start Y coodrinate 2D (top); there should be no more than 255 rows, but we cannot be sure.
+    uint32_t stopY;   // stop Y coordinate 2D (bottom); there should be no more than 255 rows, but we cannot be sure.
     char *name = nullptr; // WLEDMM initialize to nullptr
 
     // runtime data
@@ -435,7 +435,7 @@ typedef struct Segment {
     uint8_t _brightness = 255; // final pixel brightness - including transitions and segment opacity
     uint16_t _2dWidth = 0;  // virtualWidth
     uint16_t _2dHeight = 0; // virtualHeight
-    uint16_t _virtuallength = 0; // virtualLength
+    uint32_t _virtuallength = 0; // virtualLength
 
     void setPixelColorXY_slow(int x, int y, uint32_t c); // set relative pixel within segment with color - full slow version
 #else
@@ -482,7 +482,7 @@ typedef struct Segment {
 
   public:
 
-    Segment(uint16_t sStart=0, uint16_t sStop=30) :
+    Segment(uint32_t sStart=0, uint32_t sStop=30) :
       start(sStart),
       stop(sStop),
       offset(0),
@@ -522,7 +522,7 @@ typedef struct Segment {
       //refreshLightCapabilities();
     }
 
-    Segment(uint16_t sStartX, uint16_t sStopX, uint16_t sStartY, uint16_t sStopY) : Segment(sStartX, sStopX) {
+    Segment(uint32_t sStartX, uint32_t sStopX, uint32_t sStartY, uint32_t sStopY) : Segment(sStartX, sStopX) {
       startY = sStartY;
       stopY  = sStopY;
     }
@@ -570,10 +570,10 @@ typedef struct Segment {
     inline bool     hasRGB(void)         const { return _isRGB; }
     inline bool     hasWhite(void)       const { return _hasW; }
     inline bool     isCCT(void)          const { return _isCCT; }
-    inline uint16_t width(void)          const { return (stop  > start)  ?  (stop - start)  : 0; } // segment width in physical pixels (length if 1D)
-    inline uint16_t height(void)         const { return (stopY > startY) ? (stopY - startY) : 0; } // segment height (if 2D) in physical pixels // WLEDMM make sure its always > 0
+    inline uint32_t width(void)          const { return (stop  > start)  ?  (stop - start)  : 0; } // segment width in physical pixels (length if 1D)
+    inline uint32_t height(void)         const { return (stopY > startY) ? (stopY - startY) : 0; } // segment height (if 2D) in physical pixels // WLEDMM make sure its always > 0
     inline uint32_t length(void)         const { return width() * height(); }     // segment length (count) in physical pixels // WLEDMM fishy ... need to double-check if this is correct
-    inline uint16_t groupLength(void)    const { return max(1, grouping + spacing); } // WLEDMM length = 0 could lead to div/0 in virtualWidth() and virtualHeight()
+    inline uint32_t groupLength(void)    const { return max(1, grouping + spacing); } // WLEDMM length = 0 could lead to div/0 in virtualWidth() and virtualHeight()
     inline uint8_t  getLightCapabilities(void) const { return _capabilities; }
 
     static size_t   getUsedSegmentData(void)    { return _usedSegmentData; } // WLEDMM size_t
@@ -582,7 +582,7 @@ typedef struct Segment {
     void    allocLeds(); //WLEDMM
     inline static const CRGBPalette16 &getCurrentPalette(void) { return Segment::_currentPalette; }
 
-    void    setUp(uint16_t i1, uint16_t i2, uint8_t grp=1, uint8_t spc=0, uint16_t ofs=UINT16_MAX, uint16_t i1Y=0, uint16_t i2Y=1);
+    void    setUp(uint32_t i1, uint32_t i2, uint8_t grp=1, uint8_t spc=0, uint16_t ofs=UINT16_MAX, uint16_t i1Y=0, uint16_t i2Y=1);
     bool    setColor(uint8_t slot, uint32_t c); //returns true if changed
     void    setCCT(uint16_t k);
     void    setOpacity(uint8_t o);
@@ -636,11 +636,11 @@ typedef struct Segment {
     void     setCurrentPalette(void);
 
     // 1D strip
-    uint16_t calc_virtualLength(void) const;
+    uint32_t calc_virtualLength(void) const;
 #ifndef WLEDMM_FASTPATH
-    inline uint16_t virtualLength(void) const {return calc_virtualLength();}
+    inline uint32_t virtualLength(void) const {return calc_virtualLength();}
 #else
-    inline uint16_t virtualLength(void) const {return _virtuallength;}
+    inline uint32_t virtualLength(void) const {return _virtuallength;}
 #endif
     void setPixelColor(uint32_t n, uint32_t c); // set relative pixel within segment with color
     inline void setPixelColor(uint32_t n, byte r, byte g, byte b, byte w = 0) { setPixelColor(n, RGBW32(r,g,b,w)); } // automatically inline
@@ -694,15 +694,15 @@ typedef struct Segment {
     inline uint16_t virtualWidth() const  { return(_2dWidth);}  // WLEDMM get pre-calculated virtualWidth
     inline uint16_t virtualHeight() const { return(_2dHeight);} // WLEDMM get pre-calculated virtualHeight
 
-    uint16_t calc_virtualWidth() const {
-      uint_fast16_t groupLen = groupLength();
-      uint_fast16_t vWidth = ((transpose ? height() : width()) + groupLen - 1) / groupLen;
+    uint32_t calc_virtualWidth() const {
+      uint_fast32_t groupLen = groupLength();
+      uint_fast32_t vWidth = ((transpose ? height() : width()) + groupLen - 1) / groupLen;
       if (mirror) vWidth = (vWidth + 1) /2;  // divide by 2 if mirror, leave at least a single LED
       return vWidth;
     }
-    uint16_t calc_virtualHeight() const {
-      uint_fast16_t groupLen = groupLength();
-      uint_fast16_t vHeight = ((transpose ? width() : height()) + groupLen - 1) / groupLen;
+    uint32_t calc_virtualHeight() const {
+      uint_fast32_t groupLen = groupLength();
+      uint_fast32_t vHeight = ((transpose ? width() : height()) + groupLen - 1) / groupLen;
       if (mirror_y) vHeight = (vHeight + 1) /2;  // divide by 2 if mirror, leave at least a single LED
       return vHeight;
     }
@@ -713,10 +713,16 @@ typedef struct Segment {
     void deletejMap(); //WLEDMM jMap
 
   #ifndef WLED_DISABLE_2D
-    [[gnu::hot]] inline uint16_t XY(uint_fast16_t x, uint_fast16_t y)  const  { // support function to get relative index within segment (for leds[]) // WLEDMM inline for speed
-      uint_fast16_t width  = max(uint16_t(1), virtualWidth());   // segment width in logical pixels  -- softhack007 avoid div/0
-      uint_fast16_t height = max(uint16_t(1), virtualHeight());  // segment height in logical pixels -- softhack007 avoid div/0
-      return (x%width) + (y%height) * width;
+    // [[gnu::hot]] inline uint32_t XY(uint_fast16_t x, uint_fast16_t y)  const  { // support function to get relative index within segment (for leds[]) // WLEDMM inline for speed
+    //   uint_fast16_t width  = max(uint16_t(1), virtualWidth());   // segment width in logical pixels  -- softhack007 avoid div/0
+    //   uint_fast16_t height = max(uint16_t(1), virtualHeight());  // segment height in logical pixels -- softhack007 avoid div/0
+    //   return (x%width) + (y%height) * width;
+    // }
+
+    [[gnu::hot]] inline uint32_t XY(uint_fast16_t x, uint_fast16_t y) const {
+      uint32_t width = max(uint16_t(1), virtualWidth());
+      uint32_t height = max(uint16_t(1), virtualHeight());
+      return (x % width) + (y % height) * width;
     }
 
 #ifdef WLEDMM_FASTPATH
@@ -984,14 +990,16 @@ class WS2812FX {  // 96 bytes
     uint16_t
       ablMilliampsMax,
       currentMilliamps,
+      getFps() const;
+
+    uint32_t
       getLengthPhysical(void) const,
       getLengthPhysical2(void) const, // WLEDMM total length including HUB75, network busses excluded
-      __attribute__((pure)) getLengthTotal(void) const, // will include virtual/nonexistent pixels in matrix //WLEDMM attribute added
-      getFps() const;
+      __attribute__((pure)) getLengthTotal(void) const; // will include virtual/nonexistent pixels in matrix //WLEDMM attribute added
 
     inline uint16_t getFrameTime(void)  const { return _frametime; }
     inline uint16_t getMinShowDelay(void)  const { return MIN_SHOW_DELAY; }
-    inline uint16_t getLength(void)  const { return _length; } // 2D matrix may have less pixels than W*H
+    inline uint32_t getLength(void)  const { return _length; } // 2D matrix may have less pixels than W*H
     inline uint16_t getTransition(void)  const { return _transitionDur; }
 
     uint32_t

wled00/FX.h

@@ -192,6 +192,7 @@ void WS2812FX::setUpMatrix() {
 void IRAM_ATTR __attribute__((hot)) WS2812FX::setPixelColorXY_fast(int x, int y, uint32_t col) //WLEDMM: IRAM_ATTR conditionally
 {
   uint_fast32_t index = y * Segment::maxWidth + x;
+
   #ifndef WLEDMM_REMAP_AT_OUTPUT
   if (this->customMappingTable != nullptr && index < this->customMappingSize) {
     index = customMappingTable[index];
@@ -307,8 +308,8 @@ void IRAM_ATTR __attribute__((hot)) Segment::setPixelColorXY_fast(int x, int y,
   if (simpleSegment) return;   // WLEDMM shortcut when no mirroring needed
 
   // handle mirroring - minimum width/height is 1 !!!
-  const int_fast16_t wid_ = max(1,stop - start);
-  const int_fast16_t hei_ = max(1, stopY - startY);
+  const int_fast32_t wid_ = max((uint32_t)1,stop - start);
+  const int_fast32_t hei_ = max((uint32_t)1, stopY - startY);
   if (mirror) { //set the corresponding horizontally mirrored pixel
     if (transpose) strip.setPixelColorXY_fast(start + x, startY + hei_ - y - 1, scaled_col);
     else           strip.setPixelColorXY_fast(start + wid_ - x - 1, startY + y, scaled_col);
@@ -369,9 +370,9 @@ void IRAM_ATTR_YN Segment::setPixelColorXY(int x, int y, uint32_t col) //WLEDMM:
     return;
   }
 
-  const uint_fast16_t glen_ = groupLength(); // WLEDMM optimization
-  const uint_fast16_t wid_ = max(uint16_t(1), width());
-  const uint_fast16_t hei_ = max(uint16_t(1), height());
+  const uint_fast32_t glen_ = groupLength(); // WLEDMM optimization
+  const uint_fast32_t wid_ = max(uint32_t(1), width());
+  const uint_fast32_t hei_ = max(uint32_t(1), height());
 
   x *= glen_; // expand to physical pixels
   y *= glen_; // expand to physical pixels
@@ -380,7 +381,7 @@ void IRAM_ATTR_YN Segment::setPixelColorXY(int x, int y, uint32_t col) //WLEDMM:
   const int grp_ = grouping; // WLEDMM optimization
   for (int j = 0; j < grp_; j++) {   // groupping vertically
     for (int g = 0; g < grp_; g++) { // groupping horizontally
-      uint_fast16_t xX = (x+g), yY = (y+j);    //WLEDMM: use fast types
+      uint_fast32_t xX = (x+g), yY = (y+j);    //WLEDMM: use fast types
       if (xX >= wid_ || yY >= hei_) continue; // we have reached one dimension's end
 
       strip.setPixelColorXY(start + xX, startY + yY, col);

wled00/FX_2Dfcn.cpp

@@ -499,7 +499,7 @@ void Segment::handleTransition() {
   }
 }
 
-void Segment::setUp(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, uint16_t ofs, uint16_t i1Y, uint16_t i2Y) {
+void Segment::setUp(uint32_t i1, uint32_t i2, uint8_t grp, uint8_t spc, uint16_t ofs, uint16_t i1Y, uint16_t i2Y) {
   //return if neither bounds nor grouping have changed
   bool boundsUnchanged = (start == i1 && stop == i2);
   #ifndef WLED_DISABLE_2D
@@ -518,7 +518,7 @@ void Segment::setUp(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, uint16_t
     return;
   }
   if (i1 < Segment::maxWidth || (i1 >= Segment::maxWidth*Segment::maxHeight && i1 < strip.getLengthTotal())) start = i1; // Segment::maxWidth equals strip.getLengthTotal() for 1D
-  stop = i2 > Segment::maxWidth*Segment::maxHeight ? min(i2,strip.getLengthTotal()) : (i2 > Segment::maxWidth ? Segment::maxWidth : max((uint16_t)1,i2));  // WLEDMM: use native min/max
+  stop = i2 > Segment::maxWidth*Segment::maxHeight ? min(i2,strip.getLengthTotal()) : (i2 > Segment::maxWidth ? Segment::maxWidth : max((uint32_t)1,i2));  // WLEDMM: use native min/max
   startY = 0;
   stopY  = 1;
   #ifndef WLED_DISABLE_2D
@@ -850,12 +850,12 @@ static int getPinwheelLength(int vW, int vH) {
 #endif
 
 // 1D strip
-uint16_t Segment::calc_virtualLength() const {
+uint32_t Segment::calc_virtualLength() const {
 #ifndef WLED_DISABLE_2D
   if (is2D()) {
-    uint16_t vW = calc_virtualWidth();
-    uint16_t vH = calc_virtualHeight();
-    uint16_t vLen = vW * vH; // use all pixels from segment
+    uint32_t vW = calc_virtualWidth();
+    uint32_t vH = calc_virtualHeight();
+    uint32_t vLen = vW * vH; // use all pixels from segment
     switch (map1D2D) {
       case M12_pBar:
         vLen = vH;
@@ -891,8 +891,8 @@ uint16_t Segment::calc_virtualLength() const {
     return vLen;
   }
 #endif
-  uint16_t groupLen = groupLength();
-  uint16_t vLength = (length() + groupLen - 1) / groupLen;
+  uint32_t groupLen = groupLength();
+  uint32_t vLength = (length() + groupLen - 1) / groupLen;
   if (mirror && width() > 1) vLength = (vLength + 1) /2;  // divide by 2 if mirror, leave at least a single LED // WLEDMM bugfix for pseudo 2d strips
   return vLength;
 }
@@ -1738,7 +1738,7 @@ void WS2812FX::finalizeInit(void)
     _hasWhiteChannel |= bus->hasWhite();
     //refresh is required to remain off if at least one of the strips requires the refresh.
     _isOffRefreshRequired |= bus->isOffRefreshRequired();
-    uint16_t busEnd = bus->getStart() + bus->getLength();
+    uint32_t busEnd = bus->getStart() + bus->getLength();
     if (busEnd > _length) _length = busEnd;
     #ifdef ESP8266
     if ((!IS_DIGITAL(bus->getType()) || IS_2PIN(bus->getType()))) continue;
@@ -2165,14 +2165,14 @@ uint8_t WS2812FX::getActiveSegmentsNum(void) const {
   return c;
 }
 
-uint16_t WS2812FX::getLengthTotal(void) const {  // WLEDMM fast int types
-  uint_fast16_t len = Segment::maxWidth * Segment::maxHeight; // will be _length for 1D (see finalizeInit()) but should cover whole matrix for 2D
+uint32_t WS2812FX::getLengthTotal(void) const {  // WLEDMM fast int types
+  uint_fast32_t len = Segment::maxWidth * Segment::maxHeight; // will be _length for 1D (see finalizeInit()) but should cover whole matrix for 2D
   if (isMatrix && _length > len) len = _length; // for 2D with trailing strip
   return len;
 }
 
-uint16_t WS2812FX::getLengthPhysical(void) const {  // WLEDMM fast int types
-  uint_fast16_t len = 0;
+uint32_t WS2812FX::getLengthPhysical(void) const {  // WLEDMM fast int types
+  uint_fast32_t len = 0;
   for (unsigned b = 0; b < busses.getNumBusses(); b++) {   //  WLEDMM use native (fast) types
     Bus *bus = busses.getBus(b);
     auto btype = bus->getType();
@@ -2183,8 +2183,8 @@ uint16_t WS2812FX::getLengthPhysical(void) const {  // WLEDMM fast int types
 }
 
 //WLEDMM - getLengthPhysical plus plysical busses not supporting ABL (i.e. HUB75)
-uint16_t WS2812FX::getLengthPhysical2(void) const {
-  uint_fast16_t len = 0;
+uint32_t WS2812FX::getLengthPhysical2(void) const {
+  uint_fast32_t len = 0;
   for (unsigned b = 0; b < busses.getNumBusses(); b++) {
     Bus *bus = busses.getBus(b);
     auto btype = bus->getType();