code formatting, removed now unused function declaration

Author: DedeHai

wled00/FX_fcn.cpp

@@ -148,7 +148,7 @@ bool Segment::allocateData(size_t len) {
   if (len == 0) return false;    // nothing to do
   if (data && _dataLen >= len) { // already allocated enough (reduce fragmentation)
     if (call == 0) {
-      if(_dataLen < FAIR_DATA_PER_SEG) { // segment data is small
+      if (_dataLen < FAIR_DATA_PER_SEG) { // segment data is small
         //DEBUG_PRINTF_P(PSTR("--   Clearing data (%d): %p\n"), len, this);
         memset(data, 0, len);  // erase buffer if called during effect initialisation
         return true; // no need to reallocate
@@ -160,7 +160,7 @@ bool Segment::allocateData(size_t len) {
   //DEBUG_PRINTF_P(PSTR("--   Allocating data (%d): %p\n"), len, this);
   // limit to MAX_SEGMENT_DATA if there is no PSRAM, otherwise prefer functionality over speed
   #if defined(ARDUINO_ARCH_ESP32)
-  if(!(psramFound() && psramSafe))
+  if (!(psramFound() && psramSafe))
   #endif
   {
     if (Segment::getUsedSegmentData() + len - _dataLen > MAX_SEGMENT_DATA) {
@@ -214,7 +214,7 @@ void Segment::resetIfRequired() {
   if (!reset || !isActive()) return;
   //DEBUG_PRINTF_P(PSTR("-- Segment reset: %p\n"), this);
   if (data && _dataLen > 0) {
-    if(_dataLen > FAIR_DATA_PER_SEG) deallocateData(); // do not keep large allocations
+    if (_dataLen > FAIR_DATA_PER_SEG) deallocateData(); // do not keep large allocations
     else memset(data, 0, _dataLen);  // can prevent heap fragmentation
     DEBUG_PRINTF_P(PSTR("-- Segment %p reset, data cleared\n"), this);
   }

wled00/fcn_declare.h

@@ -551,9 +551,6 @@ inline uint8_t hw_random8(uint32_t upperlimit) { return (hw_random8() * upperlim
 inline uint8_t hw_random8(uint32_t lowerlimit, uint32_t upperlimit) { uint32_t range = upperlimit - lowerlimit; return lowerlimit + hw_random8(range); }; // input range 0-255
 
 // memory allocation wrappers
-#ifdef CONFIG_IDF_TARGET_ESP32
-void *pixelbuffer_malloc(size_t size, bool enforcePSRAM = false); // prefer IRAM for pixel buffers if possible
-#endif
 #if !defined(ESP8266) && !defined(CONFIG_IDF_TARGET_ESP32C3)
 extern "C" {
   void *p_malloc(size_t);           // prefer PSRAM over DRAM
@@ -589,12 +586,12 @@ inline size_t getContiguousFreeHeap() { return heap_caps_get_largest_free_block(
 inline size_t getFreeHeapSize() { return ESP.getFreeHeap(); } // returns free heap
 inline size_t getContiguousFreeHeap() { return ESP.getMaxFreeBlockSize(); } // returns largest contiguous free block
 #endif
-#define  BFRALLOC_NOBYTEACCESS    (1 << 0) // ESP32 has 32bit accessible DRAM (usually ~50kB free) that must not be byte-accessed
-#define  BFRALLOC_PREFER_DRAM     (1 << 1) // prefer DRAM over PSRAM
-#define  BFRALLOC_ENFORCE_DRAM    (1 << 2) // use DRAM only, no PSRAM
-#define  BFRALLOC_PREFER_PSRAM    (1 << 3) // prefer PSRAM over DRAM
-#define  BFRALLOC_ENFORCE_PSRAM   (1 << 4) // use PSRAM if available, otherwise fall back to DRAM
-#define  BFRALLOC_CLEAR           (1 << 5) // clear allocated buffer after allocation
+#define BFRALLOC_NOBYTEACCESS    (1 << 0) // ESP32 has 32bit accessible DRAM (usually ~50kB free) that must not be byte-accessed
+#define BFRALLOC_PREFER_DRAM     (1 << 1) // prefer DRAM over PSRAM
+#define BFRALLOC_ENFORCE_DRAM    (1 << 2) // use DRAM only, no PSRAM
+#define BFRALLOC_PREFER_PSRAM    (1 << 3) // prefer PSRAM over DRAM
+#define BFRALLOC_ENFORCE_PSRAM   (1 << 4) // use PSRAM if available, otherwise fall back to DRAM
+#define BFRALLOC_CLEAR           (1 << 5) // clear allocated buffer after allocation
 void *allocate_buffer(size_t size, uint32_t type);
 
 // RAII guard class for the JSON Buffer lock

wled00/util.cpp

@@ -723,53 +723,53 @@ void *allocate_buffer(size_t size, uint32_t type) {
   #else
   #ifdef CONFIG_IDF_TARGET_ESP32
   // only classic ESP32 has this memory type. Using it frees up normal DRAM for other purposes
-  if(type & BFRALLOC_NOBYTEACCESS) {
+  if (type & BFRALLOC_NOBYTEACCESS) {
     buffer = static_cast<uint32_t*>(heap_caps_malloc(size, MALLOC_CAP_INTERNAL | MALLOC_CAP_32BIT)); // try to allocate in 32bit DRAM region
-    if((uintptr_t)buffer < SOC_DRAM_HIGH) {
+    if ((uintptr_t)buffer < SOC_DRAM_HIGH) {
       // buffer did not fit into 32bit DRAM region (located at SOC_IRAM_LOW) and was allocated in 8bit DRAM memory or is nullptr
       // if PSRAM is available and a PSRAM type is set, free the memory and try again
-      if(psramSafe && psramFound() && (type & (BFRALLOC_PREFER_PSRAM | BFRALLOC_ENFORCE_PSRAM))) {
+      if (psramSafe && psramFound() && (type & (BFRALLOC_PREFER_PSRAM | BFRALLOC_ENFORCE_PSRAM))) {
         free(buffer);
         buffer = nullptr;
       }
     }
-    if(buffer)
+    if (buffer)
       type = type & BFRALLOC_CLEAR; // we have a valid buffer, reset any additional flags except BFRALLOC_CLEAR
   }
   #endif
-  if(psramSafe && psramFound()) {
-    if(type & BFRALLOC_PREFER_DRAM) {
+  if (psramSafe && psramFound()) {
+    if (type & BFRALLOC_PREFER_DRAM) {
       buffer = d_malloc(size);
     }
-    else if(type & BFRALLOC_ENFORCE_DRAM) {
+    else if (type & BFRALLOC_ENFORCE_DRAM) {
       buffer = heap_caps_malloc(size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT); // use DRAM only
     }
-    else if(type & BFRALLOC_PREFER_PSRAM) {
+    else if (type & BFRALLOC_PREFER_PSRAM) {
       buffer = p_malloc(size); // try to allocate in PSRAM
     }
-    else if(type & BFRALLOC_ENFORCE_PSRAM) {
+    else if (type & BFRALLOC_ENFORCE_PSRAM) {
       buffer = heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT); // use PSRAM if available
     } else {
       buffer = p_malloc(size); // use PSRAM or DRAM depending on availability
     }
   }
   else {
     #ifdef CONFIG_IDF_TARGET_ESP32
-    if(!buffer)
-        buffer = d_malloc(size); // no PSRAM available, use DRAM if not already allocated above
+    if (!buffer)
+      buffer = d_malloc(size); // no PSRAM available, use DRAM if not already allocated above
     #else
     buffer = d_malloc(size);     // no PSRAM available, use DRAM
     #endif
   }
   #endif
-  if(buffer) {
+  if (buffer) {
     // check if there is enough heap left for the UI to work
-    if(getFreeHeapSize() < MIN_HEAP_SIZE)
+    if (getFreeHeapSize() < MIN_HEAP_SIZE)
     {
       free(buffer); // free allocated buffer
       return nullptr; // return nullptr to indicate failure
     }
-    if(type & BFRALLOC_CLEAR)
+    if (type & BFRALLOC_CLEAR)
       memset(buffer, 0, size); // clear allocated buffer
   }
   return buffer;