Some optimisations (O2)

Author: blazoncek

wled00/bus_manager.cpp

@@ -248,8 +248,7 @@ void BusDigital::setPixelColor(unsigned pix, uint32_t c) {
   if (!_valid || pix >= _len) return;
   if (hasWhite()) c = autoWhiteCalc(c);
   if (Bus::_cct >= 1900) c = colorBalanceFromKelvin(Bus::_cct, c); //color correction from CCT
-  uint8_t adjBri = _scale != 100 ? scaleBri(_bri, _scale) : _bri;
-  c = gamma32Func(color_fade(c, adjBri, true));
+  c = gamma32Func(color_fade(c, scaleBri(_bri, _scale), true));
 
   // pre-calcualte power usage for per-output ABL (a single bus should never have over 2000 LEDs so uint32_t is enough for _busPowerSum)
   // WARNING: assumes pixel is not modified agin until show() is called
@@ -466,7 +465,7 @@ void BusPwm::show() {
 
   // use CIE brightness formula (linear + cubic) to approximate human eye perceived brightness
   // see: https://en.wikipedia.org/wiki/Lightness
-  unsigned pwmBri = _scale != 100 ? scaleBri(_bri, _scale) : _bri;
+  unsigned pwmBri = scaleBri(_bri, _scale);
   if (pwmBri < 21) {                                   // linear response for values [0-20]
     pwmBri = (pwmBri * maxBri + 2300 / 2) / 2300 ;     // adding '0.5' before division for correct rounding, 2300 gives a good match to CIE curve
   } else {                                             // cubic response for values [21-255]
@@ -642,8 +641,7 @@ void BusNetwork::setPixelColor(unsigned pix, uint32_t c) {
 void BusNetwork::show() {
   if (!_valid || !canShow()) return;
   _broadcastLock = true;
-  uint8_t adjBri = _scale != 100 ? scaleBri(_bri, _scale) : _bri;
-  realtimeBroadcast(_UDPtype, _client, _len, _data, adjBri, hasWhite());
+  realtimeBroadcast(_UDPtype, _client, _len, _data, scaleBri(_bri, _scale), hasWhite());
   _broadcastLock = false;
 }
 
@@ -1013,8 +1011,7 @@ void BusHub75Matrix::setPixelColor(unsigned pix, uint32_t c) {
 void BusHub75Matrix::setBrightness(uint8_t b) {
   Bus::setBrightness(b);
   if (!_valid) return;
-  uint8_t adjBri = _scale != 100 ? scaleBri(_bri, _scale) : _bri;
-  display->setBrightness(adjBri);
+  display->setBrightness(scaleBri(_bri, _scale));
 }
 
 void BusHub75Matrix::show(void) {

wled00/bus_manager.h

@@ -242,7 +242,11 @@ class Bus {
     static uint8_t _cctBlend;
 
     uint32_t autoWhiteCalc(uint32_t c) const;
-    static inline uint8_t scaleBri(uint8_t bri, uint8_t multiplier) { unsigned b = ((unsigned)bri*multiplier)/100; return b > 255 ? 255 : b; }
+    static inline unsigned __attribute__((optimize("O2"))) scaleBri(unsigned bri, unsigned multiplier) {
+      if (multiplier == 100) return bri;
+      unsigned b = (bri * multiplier) / 100;
+      return b > 255 ? 255 : b;
+    }
 };
 
 

wled00/colors.cpp

@@ -15,7 +15,7 @@ CRGBA& CRGBA::nscale8(uint8_t scale) {
   return *this;
 }
 
-CRGBA& CRGBA::nadd(CRGBA c, bool preserveCR) {
+CRGBA& __attribute__((optimize("O2"))) CRGBA::nadd(CRGBA c, bool preserveCR) {
   uint32_t c2 = c.color32 & 0x00FFFFFF;             // ignore alpha/white of color2
   if (c.a < 255) fast_color_scale(c2, c.a);         // scale color2 by its alpha
   uint32_t c1 = color32 & 0x00FFFFFF;               // ignore alpha/white of color1
@@ -48,7 +48,7 @@ CRGBA& CRGBA::nadd(CRGBA c, bool preserveCR) {
  * color blend function, based on FastLED blend function
  * the calculation for each color is: result = (A*(amountOfA) + A + B*(amountOfB) + B) / 256 with amountOfA = 255 - amountOfB
  */
-uint32_t color_blend(uint32_t color1, uint32_t color2, uint8_t blend) {
+uint32_t __attribute__((optimize("O2"))) color_blend(uint32_t color1, uint32_t color2, uint8_t blend) {
   // min / max blend checking is omitted: calls with 0 or 255 are rare, checking lowers overall performance
   uint32_t rb1 =  color1       & TWO_CHANNEL_MASK;  // extract R & B channels from color1
   uint32_t wg1 = (color1 >> 8) & TWO_CHANNEL_MASK;  // extract W & G channels from color1 (shifted for multiplication later)
@@ -64,7 +64,7 @@ uint32_t color_blend(uint32_t color1, uint32_t color2, uint8_t blend) {
  * original idea: https://github.com/wled/WLED/pull/2465 by https://github.com/Proto-molecule
  * speed optimisations by @dedehai
  */
-uint32_t color_add(uint32_t c1, uint32_t c2, bool preserveCR) {
+uint32_t __attribute__((optimize("O2"))) color_add(uint32_t c1, uint32_t c2, bool preserveCR) {
   if (preserveCR) { fast_color_add(c1, c2); return c1; }
   if (c1 == BLACK) return c2;
   if (c2 == BLACK) return c1;
@@ -78,15 +78,15 @@ uint32_t color_add(uint32_t c1, uint32_t c2, bool preserveCR) {
 }
 
 // fast color scale function (scales c1 as c1 * scale / 256)
-void fast_color_scale(uint32_t &c1, uint8_t scale) {
+void __attribute__((optimize("O2"))) fast_color_scale(uint32_t &c1, uint8_t scale) {
   uint32_t s = scale + 1;
   uint32_t rb = ((( c1     & TWO_CHANNEL_MASK) * s) >> 8) &  TWO_CHANNEL_MASK;
   uint32_t wg =  (((c1>>8) & TWO_CHANNEL_MASK) * s)       & ~TWO_CHANNEL_MASK;
   c1 = rb | wg;
 }
 
 // fast color add function that preserves ratio
-void fast_color_add(uint32_t &c1, uint32_t c2, uint8_t scale) {
+void __attribute__((optimize("O2"))) fast_color_add(uint32_t &c1, uint32_t c2, uint8_t scale) {
   if (c2 == BLACK) return;                              // adding black does nothing
   if (scale < 255) fast_color_scale(c2, scale);         // scale added color
   if (c1 == BLACK) { c1 = c2; return; }                 // source is black, just assign c2
@@ -108,7 +108,7 @@ void fast_color_add(uint32_t &c1, uint32_t c2, uint8_t scale) {
  * fades color toward black
  * 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) {
+uint32_t __attribute__((optimize("O2"))) color_fade(uint32_t c1, uint8_t amount, bool video) {
   if (amount == 255) return c1; // no fading
   uint32_t addRemains = 0;
   if (video && amount) { // video scaling: make sure colors do not dim to zero if they started non-zero
@@ -126,7 +126,7 @@ uint32_t color_fade(uint32_t c1, uint8_t amount, bool video) {
 // Blending also occurs between the 16th and 1st elements when blendType is LINEARBLEND, producing wrap-around palette.
 // If you do not want wrap-around, use LINEARBLEND_NOWRAP which effectively reduces color entris count to 240.
 // If you do not want any blending at all, use NOBLEND which effectively reduces color entries count to 16.
-CRGBA ColorFromPaletteWLED(const CRGBPalette16& pal, uint8_t index, uint8_t brightness, TBlendType blendType) {
+CRGBA __attribute__((optimize("O2"))) ColorFromPaletteWLED(const CRGBPalette16& pal, uint8_t index, uint8_t brightness, TBlendType blendType) {
   if (blendType == LINEARBLEND_NOWRAP) {
     index = (index*241) >> 8; // Blend range is affected by lo4 blend of values, remap to avoid wrapping
   }