Image Player Hot Cacher

Author: troyhacks

wled00/FX.cpp

@@ -14,6 +14,7 @@
   #include "driver/ppa.h"
   #include "driver/jpeg_decode.h"
   #include "esp_h264_dec_sw.h"
+  #include "ImageCacheManager.h"
 #endif
 #ifdef WLEDMM_FASTPATH
 #undef SEGMENT
@@ -9129,93 +9130,10 @@ int get_sequence_folder(const std::string& base_path, std::string& selected_path
     return 0;
 }
 
-#if defined(ARDUINO_ARCH_ESP32P4)
-extern "C" {
-  int p4_mul16x16(uint8_t* outpacket, uint8_t* brightness, uint16_t num_loops, uint8_t* pixelbuffer);
-}
-#endif
-
 float quantize16(float value) {
     return roundf(value * 16.0f) / 16.0f;
 }
 
-#include <string>
-#include <vector>
-#include <dirent.h>
-#include <sys/stat.h>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-
-// Structure to hold image data
-struct ImageData {
-    uint8_t* buffer;
-    size_t size;
-};
-
-// Static cache and folder tracking
-static std::vector<ImageData> image_cache;
-static std::string cached_folder;
-
-// Preload all JPEG files from a folder into PSRAM
-bool preload_images(const std::string& folder_path) {
-
-    if (folder_path == cached_folder) return true; // Already loaded
-
-    long unsigned timer = micros();
-
-    // Clear previous cache
-    for (auto& img : image_cache) {
-        free(img.buffer);
-    }
-    image_cache.clear();
-
-    DIR* dir = opendir(folder_path.c_str());
-    if (!dir) return false;
-
-    struct dirent* entry;
-    struct stat st;
-    std::vector<std::string> jpeg_files;
-
-    while ((entry = readdir(dir)) != nullptr) {
-        std::string name = entry->d_name;
-        std::string full_path = folder_path + "/" + name;
-
-        if ((name.find(".jpg") != std::string::npos || name.find(".jpeg") != std::string::npos) &&
-            stat(full_path.c_str(), &st) == 0 && S_ISREG(st.st_mode)) {
-            jpeg_files.push_back(full_path);
-        }
-    }
-    closedir(dir);
-
-    for (const auto& path : jpeg_files) {
-        FILE* file = fopen(path.c_str(), "rb");
-        if (!file) continue;
-
-        fseek(file, 0, SEEK_END);
-        size_t size = ftell(file);
-        rewind(file);
-
-        uint8_t* buffer = (uint8_t*)ps_malloc(size); // PSRAM allocation
-        if (!buffer) {
-            fclose(file);
-            continue;
-        }
-
-        fread(buffer, 1, size, file);
-        fclose(file);
-
-        image_cache.push_back({ buffer, size });
-    }
-
-    cached_folder = folder_path;
-    USER_PRINTF("Caching took %0.2f seconds.\n", float((micros()-timer)/1000000));
-    return !image_cache.empty();
-} 
-
-#include <sstream>
-#include <iomanip>
-
 uint16_t IRAM_ATTR mode_PPA_TESTBED() {
   #ifdef SOC_PPA_SUPPORTED // always for PPA effects
 
@@ -9260,7 +9178,7 @@ uint16_t IRAM_ATTR mode_PPA_TESTBED() {
     return 1;
   }
 
-  static uint16_t frame = 1;
+  static uint16_t frame = 0;
   std::string folder_path;
   static std::string last_folder_path;
 
@@ -9270,34 +9188,44 @@ uint16_t IRAM_ATTR mode_PPA_TESTBED() {
     return 1;
   }
 
-  // Only preload if folder has changed
-  if (folder_path != last_folder_path) {
-    if (!preload_images(folder_path)) {
-      USER_PRINTLN("Failed to preload images");
-      delay(500);
-      return 1;
-    }
-    last_folder_path = folder_path;
+  if (frame >= ImageCacheManager::getInstance().getFolderSize(folder_path)) {
+      frame = 0;
   }
 
-  if (frame - 1 >= image_cache.size()) {
-    frame = 1;
-  }
+  ImageData* img = ImageCacheManager::getInstance().getImage(folder_path, frame);
+
+  uint8_t* file_jpeg = NULL;
+  size_t file_jpeg_size = 0;
 
-  uint8_t* file_jpeg = image_cache[frame - 1].buffer;
-  size_t file_jpeg_size = image_cache[frame - 1].size;
+  if (img) {
+    // Got the image, display it...
+    // display_jpeg(img->buffer, img->size);
+    // ESP_LOGI("APP", "Displaying %s, image %d", current_folder.c_str(), folder_path);
+    
+    file_jpeg = img->buffer;
+    file_jpeg_size = img->size;
 
+    // Move to the next image, wrapping around if necessary
+    frame++;
+    if (frame >= ImageCacheManager::getInstance().getFolderSize(folder_path)) {
+        frame = 0;
+    }
+  } else {
+    // Could not get image (it doesn't exist or loading stopped due to PSRAM limit)
+    USER_PRINTF("Could not get image %d from %s. Waiting...", frame, folder_path.c_str());
+  }
+  
   if (!file_jpeg || file_jpeg_size == 0) {
     USER_PRINTF("Cached image data missing for frame %d\n", frame);
-    frame = 1;
+    frame = 0;
     delay(500);
     return 1;
   }
 
   if (file_jpeg == NULL) {
     DEBUG_PRINTLN("NULL at JPEG pointer!");
     delay(500);
-    return 1;
+    return 0;
   }
 
   frame++;

wled00/ImageCacheManager.cpp

@@ -0,0 +1,187 @@
+#include "ImageCacheManager.h"
+#include "esp_psram.h"
+#include "esp_log.h"
+#include <dirent.h>
+#include <sys/stat.h>
+#include <algorithm>
+#include "Arduino.h"
+
+static const char* TAG = "ImageCache";
+
+// Singleton instance definition
+ImageCacheManager& ImageCacheManager::getInstance() {
+    static ImageCacheManager instance;
+    return instance;
+}
+
+// Constructor: Initialize resources
+ImageCacheManager::ImageCacheManager() :
+    preload_task_handle(NULL),
+    psram_limit(0),
+    psram_used(0)
+{
+    cache_mutex = xSemaphoreCreateMutex();
+    size_t total_psram = esp_psram_get_size();
+    psram_limit = static_cast<size_t>(total_psram * 0.8);
+    ESP_LOGI(TAG, "Total PSRAM: %u bytes, Cache Limit (80%%): %u bytes", total_psram, psram_limit);
+}
+
+// Destructor: Clean up resources
+ImageCacheManager::~ImageCacheManager() {
+    clearCache();
+    vSemaphoreDelete(cache_mutex);
+}
+
+// Start the non-blocking preload task
+void ImageCacheManager::startPreload(const std::string& root_path) {
+    if (preload_task_handle != NULL) {
+        ESP_LOGW(TAG, "Preload task is already running.");
+        return;
+    }
+    clearCache();
+    preload_root_path = root_path.c_str(); // Convert std::string to psram_string
+    xTaskCreate(_preloadTask, "preload_task", 4096, this, IMAGECACHE_BG_PRIORITY, &preload_task_handle);
+}
+
+// The main 'get' function with on-demand loading
+ImageData* ImageCacheManager::getImage(const std::string& folder_path, size_t index) {
+    psram_string ps_folder_path = folder_path.c_str();
+    xSemaphoreTake(cache_mutex, portMAX_DELAY);
+    auto it = image_cache.find(ps_folder_path);
+
+    if (it != image_cache.end() && index < it->second.size()) {
+        ImageData* data = &it->second[index];
+        xSemaphoreGive(cache_mutex);
+        return data;
+    }
+    xSemaphoreGive(cache_mutex);
+
+    ESP_LOGI(TAG, "On-demand loading folder: %s", folder_path.c_str());
+    if (_loadFolderSync(ps_folder_path)) {
+        xSemaphoreTake(cache_mutex, portMAX_DELAY);
+        it = image_cache.find(ps_folder_path);
+        if (it != image_cache.end() && index < it->second.size()) {
+            ImageData* data = &it->second[index];
+            xSemaphoreGive(cache_mutex);
+            return data;
+        }
+        xSemaphoreGive(cache_mutex);
+    }
+    return nullptr;
+}
+
+size_t ImageCacheManager::getFolderSize(const std::string& folder_path) {
+    size_t size = 0;
+    psram_string ps_folder_path = folder_path.c_str();
+    xSemaphoreTake(cache_mutex, portMAX_DELAY);
+    auto it = image_cache.find(ps_folder_path);
+    if (it != image_cache.end()) {
+        size = it->second.size();
+    }
+    xSemaphoreGive(cache_mutex);
+    return size;
+}
+
+// The background task implementation
+void ImageCacheManager::_preloadTask(void* params) {
+    ImageCacheManager* manager = static_cast<ImageCacheManager*>(params);
+    DIR* dir = opendir(manager->preload_root_path.c_str());
+    if (!dir) {
+        ESP_LOGE(TAG, "Failed to open root directory: %s", manager->preload_root_path.c_str());
+        manager->preload_task_handle = NULL;
+        vTaskDelete(NULL);
+        return;
+    }
+
+    struct dirent* entry;
+    while ((entry = readdir(dir)) != nullptr) {
+        psram_string name = entry->d_name;
+        if (entry->d_type == DT_DIR && name.rfind("sequence", 0) == 0) {
+            psram_string full_path = manager->preload_root_path + "/" + name;
+            ESP_LOGI(TAG, "Preloading folder: %s", full_path.c_str());
+            manager->_loadFolderSync(full_path);
+        }
+    }
+    closedir(dir);
+
+    ESP_LOGI(TAG, "Background preloading finished.");
+    manager->preload_task_handle = NULL;
+    vTaskDelete(NULL);
+}
+
+// The core synchronous loading logic, now using PSRAM for the temporary filename list
+bool ImageCacheManager::_loadFolderSync(const psram_string& folder_path) {
+    xSemaphoreTake(cache_mutex, portMAX_DELAY);
+    if (image_cache.count(folder_path)) {
+        xSemaphoreGive(cache_mutex);
+        return true;
+    }
+    xSemaphoreGive(cache_mutex);
+
+    DIR* dir = opendir(folder_path.c_str());
+    if (!dir) return false;
+
+    // This temporary vector and its strings are now allocated in PSRAM
+    using psram_string_vector = std::vector<psram_string, PSRAM_Allocator<psram_string>>;
+    psram_string_vector jpeg_files;
+
+    struct dirent* entry;
+    while ((entry = readdir(dir)) != nullptr) {
+        psram_string name = entry->d_name;
+        if (name.find(".jpg") != psram_string::npos || name.find(".jpeg") != psram_string::npos) {
+            jpeg_files.push_back(folder_path + "/" + name);
+        }
+    }
+    closedir(dir);
+    
+    std::sort(jpeg_files.begin(), jpeg_files.end());
+
+    xSemaphoreTake(cache_mutex, portMAX_DELAY);
+    image_cache[folder_path].reserve(jpeg_files.size());
+    xSemaphoreGive(cache_mutex);
+
+    bool loaded_any = false;
+    for (const auto& path : jpeg_files) {
+        struct stat st;
+        stat(path.c_str(), &st);
+        size_t size = st.st_size;
+
+        if (psram_used + size > psram_limit) {
+            ESP_LOGW(TAG, "PSRAM limit reached. Stopping load at %s", path.c_str());
+            break;
+        }
+
+        FILE* file = fopen(path.c_str(), "rb");
+        if (!file) continue;
+
+        uint8_t* buffer = (uint8_t*)heap_caps_malloc(size, MALLOC_CAP_SPIRAM);
+        if (!buffer) {
+            ESP_LOGE(TAG, "Failed to allocate %u bytes in PSRAM for %s", size, path.c_str());
+            fclose(file);
+            continue;
+        }
+
+        fread(buffer, 1, size, file);
+        fclose(file);
+
+        xSemaphoreTake(cache_mutex, portMAX_DELAY);
+        image_cache[folder_path].push_back({buffer, size});
+        psram_used += size;
+        xSemaphoreGive(cache_mutex);
+        loaded_any = true;
+    }
+    return loaded_any;
+}
+
+void ImageCacheManager::clearCache() {
+    xSemaphoreTake(cache_mutex, portMAX_DELAY);
+    for (auto& pair : image_cache) {
+        for (auto& img : pair.second) {
+            free(img.buffer);
+        }
+    }
+    image_cache.clear();
+    psram_used = 0;
+    xSemaphoreGive(cache_mutex);
+    ESP_LOGI(TAG, "Image cache cleared.");
+}