LEDOutput.h

#pragma once
#include <FastLED.h>
 
#include "AudioLibs/AudioFFT.h"
#include "FFTDisplay.h"
 
namespace audio_tools {
 
class LEDOutput;
struct LEDOutputConfig;
 
// default callback function which implements led update
void fftLEDOutput(LEDOutputConfig *cfg, LEDOutput *matrix);
// led update for volume
void volumeLEDOutput(LEDOutputConfig *cfg, LEDOutput *matrix);
// default color
CHSV getDefaultColor(int x, int y, int magnitude);
 
struct LEDOutputConfig {
  int x = 0;
  int y = 1;
  CHSV (*color_callback)(int x, int y, int magnitude) = getDefaultColor;
  void (*update_callback)(LEDOutputConfig *cfg, LEDOutput *matrix) = nullptr;
  int update_frequency = 1;  // update every call
  bool is_serpentine_layout = true;
  bool is_matrix_vertical = true;
  int max_magnitude = 700;
};
 
class LEDOutput {
 public:
  LEDOutput() = default;
 
  LEDOutput(FFTDisplay &fft) {
    p_fft = &fft;
    cfg.update_callback = fftLEDOutput;
  }
 
  LEDOutput(VolumeOutput &vol) {
    p_vol = &vol;
    cfg.update_callback = volumeLEDOutput;
  }
 
  LEDOutputConfig defaultConfig() { return cfg; }
 
  bool begin(LEDOutputConfig config) {
    cfg = config;
    if (ledCount() == 0) {
      LOGE("x or y == 0");
      return false;
    }
 
    // allocate leds
    leds.resize(ledCount());
    for (int j = 0; j < ledCount(); j++) {
      led(j) = CRGB::Black;
    }
 
    // clear LED
    FastLED.clear();  // clear all pixel data
 
    if (p_fft != nullptr) {
      p_fft->begin();
    }
 
    max_column = -1;
 
    return true;
  }
 
  int ledCount() {
    int num_leds = cfg.x * cfg.y;
    return num_leds;
  }
 
  CRGB *ledData() {
    if (ledCount() == 0) {
      LOGE("x or y == 0");
      return nullptr;
    }
    // leds.resize(ledCount());
    return leds.data();
  }
 
  virtual void update() {
    if (cfg.update_callback != nullptr && count++ % cfg.update_frequency == 0) {
      // use custom update logic defined in config
      cfg.update_callback(&cfg, this);
    } else {
      display();
    }
  }
 
  CRGB &ledXY(uint8_t x, uint8_t y) {
    if (x > cfg.x) x = cfg.x - 1;
    if (x < 0) x = 0;
    if (y > cfg.y) y = cfg.y - 1;
    if (y < 0) y = 0;
    int index = xy(x, y);
    return leds[index];
  }
 
  CRGB &led(uint8_t index) {
    if (index > cfg.x * cfg.y) return not_valid;
    return leds[index];
  }
 
  void setColumnBar(int x, int currY) {
    // update vertical bar
    for (uint8_t y = 0; y < currY; y++) {
      // determine color
      CHSV color = cfg.color_callback(x, y, currY);
      // update LED
      ledXY(x, y) = color;
    }
    for (uint8_t y = currY; y < cfg.y; y++) {
      ledXY(x, y) = CRGB::Black;
    }
    if (x > max_column) max_column = x;
  }
 
  void setColumnBar(int currY) { setColumnBar(cfg.x - 1, currY); }
 
  void addColumnBar(int currY) {
    max_column++;
    if (max_column >= cfg.x) {
      addEmptyColumn();
    }
    if (max_column > cfg.x - 1) {
      max_column = cfg.x - 1;
    }
    setColumnBar(max_column, currY);
  }
 
  LEDOutputConfig &config() { return cfg; }
 
  virtual float getMaxMagnitude() {
    // get magnitude from
    if (p_vol != nullptr) {
      return p_vol->volume();
    }
    float max = 0;
    if (p_fft != nullptr) {
      for (int j = 0; j < cfg.x; j++) {
        float value = p_fft->getMagnitude(j);
        if (value > max) {
          max = value;
        }
      }
    }
    return max;
  }
 
  void display() {
    FastLED.show();
  }
 
  FFTDisplay &fftDisplay() { return *p_fft; }
 
 protected:
  friend class AudioFFTBase;
  CRGB not_valid;
  Vector<CRGB> leds{0};
  LEDOutputConfig cfg;
  VolumeOutput *p_vol = nullptr;
  FFTDisplay *p_fft = nullptr;
  uint64_t count = 0;
  int max_column = -1;
 
  void addEmptyColumn() {
    for (int x = 1; x < cfg.x; x++) {
      for (int y = 0; y < cfg.y; y++) {
        ledXY(x - 1, y) = ledXY(x, y);
      }
    }
    for (int y = 0; y < cfg.y; y++) {
      ledXY(cfg.x - 1, y) = CRGB::Black;
    }
  }
 
  uint16_t xy(uint8_t x, uint8_t y) {
    uint16_t i;
 
    if (cfg.is_serpentine_layout == false) {
      if (cfg.is_matrix_vertical == false) {
        i = (y * cfg.x) + x;
      } else {
        i = cfg.y * (cfg.x - (x + 1)) + y;
      }
    }
 
    if (cfg.is_serpentine_layout == true) {
      if (cfg.is_matrix_vertical == false) {
        if (y & 0x01) {
          // Odd rows run backwards
          uint8_t reverseX = (cfg.x - 1) - x;
          i = (y * cfg.x) + reverseX;
        } else {
          // Even rows run forwards
          i = (y * cfg.x) + x;
        }
      } else {  // vertical positioning
        if (x & 0x01) {
          i = cfg.y * (cfg.x - (x + 1)) + y;
        } else {
          i = cfg.y * (cfg.x - x) - (y + 1);
        }
      }
    }
 
    return i;
  }
};
 
void fftLEDOutput(LEDOutputConfig *cfg, LEDOutput *matrix) {
  // process horizontal
  LockGuard guard(fft_mux);
  for (int x = 0; x < cfg->x; x++) {
    // max y determined by magnitude
    int currY = matrix->fftDisplay().getMagnitudeScaled(x, cfg->y);
    LOGD("x: %d, y: %d", x, currY);
    matrix->setColumnBar(x, currY);
  }
  FastLED.show();
}
 
void volumeLEDOutput(LEDOutputConfig *cfg, LEDOutput *matrix) {
  float vol = matrix->getMaxMagnitude();
  int currY = mapFloat(vol, 0,
                       cfg->max_magnitude, 0.0f,
                       static_cast<float>(cfg->y));
  matrix->addColumnBar(currY);
  FastLED.show();
}
 
CHSV getDefaultColor(int x, int y, int magnitude) {
  int color = map(magnitude, 0, 7, 255, 0);
  return CHSV(color, 255, 100);  // blue CHSV(160, 255, 255
}
 
}  // namespace audio_tools