FSEQ usermod update (resolve conflicts)

Author: Andrejchrcek

usermods/FSEQ/fseq_player.cpp

@@ -1,17 +1,32 @@
 #include "fseq_player.h"
-#include <Arduino.h>
+#include "usermod_fseq.h"
 #include "wled.h"
+#include <Arduino.h>
 
 #ifdef WLED_USE_SD_SPI
-  #include <SPI.h>
-  #include <SD.h>
+#include <SD.h>
+#include <SPI.h>
 #elif defined(WLED_USE_SD_MMC)
-  #include "SD_MMC.h"
+#include "SD_MMC.h"
+#endif
+
+// Static member definitions moved from header to avoid multiple definition
+// errors
+const char UsermodFseq::_name[] PROGMEM = "usermod FSEQ sd card";
+
+#ifdef WLED_USE_SD_SPI
+int8_t UsermodFseq::configPinSourceSelect = 5;
+int8_t UsermodFseq::configPinSourceClock = 18;
+int8_t UsermodFseq::configPinPoci = 19;
+int8_t UsermodFseq::configPinPico = 23;
 #endif
 
 File FSEQPlayer::recordingFile;
-uint8_t  FSEQPlayer::colorChannels = 3;
-int32_t  FSEQPlayer::recordingRepeats = RECORDING_REPEAT_DEFAULT;
+String FSEQPlayer::currentFileName = "";
+float FSEQPlayer::secondsElapsed = 0;
+
+uint8_t FSEQPlayer::colorChannels = 3;
+int32_t FSEQPlayer::recordingRepeats = RECORDING_REPEAT_DEFAULT;
 uint32_t FSEQPlayer::now = 0;
 uint32_t FSEQPlayer::next_time = 0;
 uint16_t FSEQPlayer::playbackLedStart = 0;
@@ -22,37 +37,42 @@ FSEQPlayer::FileHeader FSEQPlayer::file_header;
 
 inline uint32_t FSEQPlayer::readUInt32() {
   char buffer[4];
-  if (recordingFile.readBytes(buffer, 4) < 4) return 0;
-  return (uint32_t)buffer[0] | ((uint32_t)buffer[1] << 8) | ((uint32_t)buffer[2] << 16) | ((uint32_t)buffer[3] << 24);
+  if (recordingFile.readBytes(buffer, 4) < 4)
+    return 0;
+  return (uint32_t)buffer[0] | ((uint32_t)buffer[1] << 8) |
+         ((uint32_t)buffer[2] << 16) | ((uint32_t)buffer[3] << 24);
 }
 
 inline uint32_t FSEQPlayer::readUInt24() {
   char buffer[3];
-  if (recordingFile.readBytes(buffer, 3) < 3) return 0;
-  return (uint32_t)buffer[0] | ((uint32_t)buffer[1] << 8) | ((uint32_t)buffer[2] << 16);
+  if (recordingFile.readBytes(buffer, 3) < 3)
+    return 0;
+  return (uint32_t)buffer[0] | ((uint32_t)buffer[1] << 8) |
+         ((uint32_t)buffer[2] << 16);
 }
 
 inline uint16_t FSEQPlayer::readUInt16() {
   char buffer[2];
-  if (recordingFile.readBytes(buffer, 2) < 2) return 0;
+  if (recordingFile.readBytes(buffer, 2) < 2)
+    return 0;
   return (uint16_t)buffer[0] | ((uint16_t)buffer[1] << 8);
 }
 
 inline uint8_t FSEQPlayer::readUInt8() {
   char buffer[1];
-  if (recordingFile.readBytes(buffer, 1) < 1) return 0;
+  if (recordingFile.readBytes(buffer, 1) < 1)
+    return 0;
   return (uint8_t)buffer[0];
 }
 
-bool FSEQPlayer::fileOnSD(const char* filepath) {
+bool FSEQPlayer::fileOnSD(const char *filepath) {
   uint8_t cardType = SD_ADAPTER.cardType();
-  if(cardType == CARD_NONE) return false;
+  if (cardType == CARD_NONE)
+    return false;
   return SD_ADAPTER.exists(filepath);
 }
 
-bool FSEQPlayer::fileOnFS(const char* filepath) {
-  return false;
-}
+bool FSEQPlayer::fileOnFS(const char *filepath) { return false; }
 
 void FSEQPlayer::printHeaderInfo() {
   DEBUG_PRINTLN("FSEQ file header:");
@@ -68,18 +88,21 @@ void FSEQPlayer::printHeaderInfo() {
 
 void FSEQPlayer::processFrameData() {
   uint16_t packetLength = file_header.channel_count;
-  uint16_t lastLed = min(playbackLedStop, uint16_t(playbackLedStart + (packetLength / 3)));
+  uint16_t lastLed =
+      min(playbackLedStop, uint16_t(playbackLedStart + (packetLength / 3)));
   char frame_data[buffer_size];
-  CRGB* crgb = reinterpret_cast<CRGB*>(frame_data);
+  CRGB *crgb = reinterpret_cast<CRGB *>(frame_data);
   uint16_t bytes_remaining = packetLength;
   uint16_t index = playbackLedStart;
   while (index < lastLed && bytes_remaining > 0) {
     uint16_t length = min(bytes_remaining, buffer_size);
     recordingFile.readBytes(frame_data, length);
     bytes_remaining -= length;
     for (uint16_t offset = 0; offset < length / 3; offset++) {
-      setRealtimePixel(index, crgb[offset].r, crgb[offset].g, crgb[offset].b, 0);
-      if (++index > lastLed) break;
+      setRealtimePixel(index, crgb[offset].r, crgb[offset].g, crgb[offset].b,
+                       0);
+      if (++index > lastLed)
+        break;
     }
   }
   strip.show();
@@ -110,7 +133,8 @@ bool FSEQPlayer::stopBecauseAtTheEnd() {
 }
 
 void FSEQPlayer::playNextRecordingFrame() {
-  if (stopBecauseAtTheEnd()) return;
+  if (stopBecauseAtTheEnd())
+    return;
   uint32_t offset = file_header.channel_count * frame++;
   offset += file_header.channel_data_offset;
   if (!recordingFile.seek(offset)) {
@@ -124,12 +148,15 @@ void FSEQPlayer::playNextRecordingFrame() {
 
 void FSEQPlayer::handlePlayRecording() {
   now = millis();
-  if (realtimeMode != REALTIME_MODE_FSEQ) return;
-  if (now < next_time) return;
+  if (realtimeMode != REALTIME_MODE_FSEQ)
+    return;
+  if (now < next_time)
+    return;
   playNextRecordingFrame();
 }
 
-void FSEQPlayer::loadRecording(const char* filepath, uint16_t startLed, uint16_t stopLed, float secondsElapsed) {
+void FSEQPlayer::loadRecording(const char *filepath, uint16_t startLed,
+                               uint16_t stopLed, float secondsElapsed) {
   if (recordingFile.available()) {
     clearLastPlayback();
     recordingFile.close();
@@ -141,14 +168,19 @@ void FSEQPlayer::loadRecording(const char* filepath, uint16_t startLed, uint16_t
     playbackLedStart = sg.start;
     playbackLedStop = sg.stop;
   }
-  DEBUG_PRINTF("FSEQ load animation on LED %d to %d\n", playbackLedStart, playbackLedStop);
+  DEBUG_PRINTF("FSEQ load animation on LED %d to %d\n", playbackLedStart,
+               playbackLedStop);
   if (fileOnSD(filepath)) {
     DEBUG_PRINTF("Read file from SD: %s\n", filepath);
     recordingFile = SD_ADAPTER.open(filepath, "rb");
+    currentFileName = String(filepath);
+    if (currentFileName.startsWith("/"))
+      currentFileName = currentFileName.substring(1);
   } else if (fileOnFS(filepath)) {
     DEBUG_PRINTF("Read file from FS: %s\n", filepath);
   } else {
-    DEBUG_PRINTF("File %s not found (%s)\n", filepath, USED_STORAGE_FILESYSTEMS);
+    DEBUG_PRINTF("File %s not found (%s)\n", filepath,
+                 USED_STORAGE_FILESYSTEMS);
     return;
   }
   if ((uint64_t)recordingFile.available() < sizeof(file_header)) {
@@ -170,17 +202,23 @@ void FSEQPlayer::loadRecording(const char* filepath, uint16_t startLed, uint16_t
   printHeaderInfo();
   if (file_header.identifier[0] != 'P' || file_header.identifier[1] != 'S' ||
       file_header.identifier[2] != 'E' || file_header.identifier[3] != 'Q') {
-    DEBUG_PRINTF("Error reading FSEQ file %s header, invalid identifier\n", filepath);
+    DEBUG_PRINTF("Error reading FSEQ file %s header, invalid identifier\n",
+                 filepath);
     recordingFile.close();
     return;
   }
-  if (((uint64_t)file_header.channel_count * (uint64_t)file_header.frame_count) + file_header.header_length > UINT32_MAX) {
-    DEBUG_PRINTF("Error reading FSEQ file %s header, file too long (max 4gb)\n", filepath);
+  if (((uint64_t)file_header.channel_count *
+       (uint64_t)file_header.frame_count) +
+          file_header.header_length >
+      UINT32_MAX) {
+    DEBUG_PRINTF("Error reading FSEQ file %s header, file too long (max 4gb)\n",
+                 filepath);
     recordingFile.close();
     return;
   }
   if (file_header.step_time < 1) {
-    DEBUG_PRINTF("Invalid step time %d, using default %d instead\n", file_header.step_time, FSEQ_DEFAULT_STEP_TIME);
+    DEBUG_PRINTF("Invalid step time %d, using default %d instead\n",
+                 file_header.step_time, FSEQ_DEFAULT_STEP_TIME);
     file_header.step_time = FSEQ_DEFAULT_STEP_TIME;
   }
   if (realtimeOverride == REALTIME_OVERRIDE_ONCE) {
@@ -197,37 +235,59 @@ void FSEQPlayer::loadRecording(const char* filepath, uint16_t startLed, uint16_t
     recordingRepeats = RECORDING_REPEAT_DEFAULT;
   }
   playNextRecordingFrame();
+  playNextRecordingFrame();
 }
 
 void FSEQPlayer::clearLastPlayback() {
   for (uint16_t i = playbackLedStart; i < playbackLedStop; i++) {
     setRealtimePixel(i, 0, 0, 0, 0);
   }
   frame = 0;
+  currentFileName = "";
 }
 
 bool FSEQPlayer::isPlaying() {
   return recordingFile && recordingFile.available();
 }
 
+String FSEQPlayer::getFileName() { return currentFileName; }
+
+float FSEQPlayer::getElapsedSeconds() {
+  if (!isPlaying())
+    return 0;
+  // Calculate approximate elapsed seconds based on frame and step time
+  // Or if secondsElapsed is updated elsewhere, return it.
+  // Ideally secondsElapsed should be updated during playback.
+  // But for now, let's just calculate it from frame count
+  return (float)frame * (float)file_header.step_time / 1000.0f;
+}
+
 void FSEQPlayer::syncPlayback(float secondsElapsed) {
   if (!isPlaying()) {
     DEBUG_PRINTLN("[FSEQ] Sync: Playback not active, cannot sync.");
     return;
   }
-  
-  uint32_t expectedFrame = (uint32_t)((secondsElapsed * 1000.0f) / file_header.step_time);
+
+  // Update internal secondsElapsed if we were tracking it
+  // FSEQPlayer::secondsElapsed = secondsElapsed; // If we were tracking it
+
+  uint32_t expectedFrame =
+      (uint32_t)((secondsElapsed * 1000.0f) / file_header.step_time);
   int32_t diff = (int32_t)expectedFrame - (int32_t)frame;
-  
+
   if (abs(diff) > 2) {
     frame = expectedFrame;
-    uint32_t offset = file_header.channel_data_offset + file_header.channel_count * frame;
+    uint32_t offset =
+        file_header.channel_data_offset + file_header.channel_count * frame;
     if (recordingFile.seek(offset)) {
-      DEBUG_PRINTF("[FSEQ] Sync: Adjusted frame to %lu (diff=%ld)\n", expectedFrame, diff);
+      DEBUG_PRINTF("[FSEQ] Sync: Adjusted frame to %lu (diff=%ld)\n",
+                   expectedFrame, diff);
     } else {
       DEBUG_PRINTLN("[FSEQ] Sync: Failed to seek to new frame");
     }
   } else {
-    DEBUG_PRINTF("[FSEQ] Sync: No adjustment needed (current frame: %lu, expected: %lu)\n", frame, expectedFrame);
+    DEBUG_PRINTF("[FSEQ] Sync: No adjustment needed (current frame: %lu, "
+                 "expected: %lu)\n",
+                 frame, expectedFrame);
   }
 }

usermods/FSEQ/fseq_player.cpp.header_add

@@ -0,0 +1,30 @@
+#include "fseq_player.h"
+#include "usermod_fseq.h"
+#include "wled.h"
+#include <Arduino.h>
+
+#ifdef WLED_USE_SD_SPI
+#include <SD.h>
+#include <SPI.h>
+#endif
+
+// Static member definitions moved from header to avoid multiple definition errors
+const char UsermodFseq::_name[] PROGMEM = "usermod FSEQ sd card";
+
+#ifdef WLED_USE_SD_SPI
+int8_t UsermodFseq::configPinSourceSelect = 5;
+int8_t UsermodFseq::configPinSourceClock  = 18;
+int8_t UsermodFseq::configPinPoci         = 19;
+int8_t UsermodFseq::configPinPico         = 23;
+#endif
+
+File FSEQPlayer::recordingFile;
+uint8_t FSEQPlayer::colorChannels = 3;
+int32_t FSEQPlayer::recordingRepeats = RECORDING_REPEAT_DEFAULT;
+uint32_t FSEQPlayer::now = 0;
+uint32_t FSEQPlayer::next_time = 0;
+uint16_t FSEQPlayer::playbackLedStart = 0;
+uint16_t FSEQPlayer::playbackLedStop = uint16_t(-1);
+uint32_t FSEQPlayer::frame = 0;
+float FSEQPlayer::secondsElapsed = 0;
+// ... (rest of file content logic is not here, I should append or use replace)

usermods/FSEQ/fseq_player.h

@@ -2,51 +2,56 @@
 #define FSEQ_PLAYER_H
 
 #ifndef RECORDING_REPEAT_LOOP
-  #define RECORDING_REPEAT_LOOP -1
+#define RECORDING_REPEAT_LOOP -1
 #endif
 #ifndef RECORDING_REPEAT_DEFAULT
-  #define RECORDING_REPEAT_DEFAULT 0
+#define RECORDING_REPEAT_DEFAULT 0
 #endif
 #ifndef REALTIME_MODE_FSEQ
-  #define REALTIME_MODE_FSEQ 3
+#define REALTIME_MODE_FSEQ 3
 #endif
 
 #include "wled.h"
 #ifdef WLED_USE_SD_SPI
-  #include <SPI.h>
-  #include <SD.h>
+#include <SD.h>
+#include <SPI.h>
 #elif defined(WLED_USE_SD_MMC)
-  #include "SD_MMC.h"
+#include "SD_MMC.h"
 #endif
 
 class FSEQPlayer {
 public:
   struct FileHeader {
-    uint8_t  identifier[4];
+    uint8_t identifier[4];
     uint16_t channel_data_offset;
-    uint8_t  minor_version;
-    uint8_t  major_version;
+    uint8_t minor_version;
+    uint8_t major_version;
     uint16_t header_length;
     uint32_t channel_count;
     uint32_t frame_count;
-    uint8_t  step_time;
-    uint8_t  flags;
+    uint8_t step_time;
+    uint8_t flags;
   };
 
-  static void loadRecording(const char* filepath, uint16_t startLed, uint16_t stopLed, float secondsElapsed = 0.0f);
+  static void loadRecording(const char *filepath, uint16_t startLed,
+                            uint16_t stopLed, float secondsElapsed = 0.0f);
   static void handlePlayRecording();
   static void clearLastPlayback();
   static void syncPlayback(float secondsElapsed);
   static bool isPlaying();
+  static String getFileName();
+  static float getElapsedSeconds();
 
 private:
   FSEQPlayer() {}
 
   static const int FSEQ_DEFAULT_STEP_TIME = 50;
 
-  static File     recordingFile;
-  static uint8_t  colorChannels;
-  static int32_t  recordingRepeats;
+  static File recordingFile;
+  static String currentFileName;
+  static float secondsElapsed;
+  static uint8_t colorChannels;
+  static int32_t recordingRepeats;
   static uint32_t now;
   static uint32_t next_time;
   static uint16_t playbackLedStart;
@@ -60,8 +65,8 @@ class FSEQPlayer {
   static inline uint16_t readUInt16();
   static inline uint8_t readUInt8();
 
-  static bool fileOnSD(const char* filepath);
-  static bool fileOnFS(const char* filepath);
+  static bool fileOnSD(const char *filepath);
+  static bool fileOnFS(const char *filepath);
   static void printHeaderInfo();
   static void processFrameData();
   static bool stopBecauseAtTheEnd();

usermods/FSEQ/register_usermod.cpp

@@ -0,0 +1,13 @@
+#include "usermod_fpp.h"
+#include "usermod_fseq.h"
+#include "wled.h"
+
+#ifdef USERMOD_FSEQ
+UsermodFseq usermodFseq;
+REGISTER_USERMOD(usermodFseq);
+#endif
+
+#ifdef USERMOD_FPP
+UsermodFPP usermodFpp;
+REGISTER_USERMOD(usermodFpp);
+#endif