make slicing more robust

Author: jamesb93

ReacomaExtension/Algorithms/FlucomaAlgorithmBase.h

@@ -36,20 +36,23 @@ template <typename ClientType> class FlucomaAlgorithm : public IAlgorithm {
     bool StartProcessItemAsync(MediaItem *item) override final {
 
         SetMediaItemInfo_Value(item, "C_LOCK", true);
-        UpdateTimeline();
 
         if (!item || !mApiProvider)
             return false;
         mIsFinishedFlag = false;
         mProgress = 0.0;
 
         MediaItem_Take *take = GetActiveTake(item);
-        if (!take)
+        if (!take) {
+            SetMediaItemInfo_Value(item, "C_LOCK", false);
             return false;
+        }
 
         PCM_source *source = GetMediaItemTake_Source(take);
-        if (!source)
+        if (!source) {
+            SetMediaItemInfo_Value(item, "C_LOCK", false);
             return false;
+        }
 
         const int sampleRate = GetMediaSourceSampleRate(source);
         const int numChannels = GetMediaSourceNumChannels(source);
@@ -113,6 +116,8 @@ template <typename ClientType> class FlucomaAlgorithm : public IAlgorithm {
         if (!mItemForAsync || item != mItemForAsync)
             return false;
 
+        SetMediaItemInfo_Value(item, "C_LOCK", false);
+
         bool success = HandleResults(mItemForAsync, mTakeForAsync,
                                      mNumChannelsForAsync, mSampleRateForAsync);
 
@@ -123,8 +128,6 @@ template <typename ClientType> class FlucomaAlgorithm : public IAlgorithm {
         mItemForAsync = nullptr;
         mTakeForAsync = nullptr;
 
-        SetMediaItemInfo_Value(item, "C_LOCK", false);
-
         if (success) {
             UpdateTimeline();
         }
@@ -159,8 +162,10 @@ template <typename ClientType> class FlucomaAlgorithm : public IAlgorithm {
             return;
 
         double itemPos = GetMediaItemInfo_Value(item, "D_POSITION");
+        double itemLen = GetMediaItemInfo_Value(item, "D_LENGTH");
         double startOffs = GetMediaItemTakeInfo_Value(take, "D_STARTOFFS");
         double playrate = GetMediaItemTakeInfo_Value(take, "D_PLAYRATE");
+        double epsilon = 0.0001; // Avoid splitting at the very start or end
 
         // Collect marker positions (in source time) and convert to project time
         std::vector<double> splitPositions;
@@ -171,11 +176,19 @@ template <typename ClientType> class FlucomaAlgorithm : public IAlgorithm {
                 // project_time = item_position + (marker_source_time -
                 // take_offset) / playrate
                 double projectTime = itemPos + (srcPos - startOffs) / playrate;
-                splitPositions.push_back(projectTime);
+
+                // Only split if within item bounds (with small epsilon)
+                if (projectTime > itemPos + epsilon &&
+                    projectTime < itemPos + itemLen - epsilon) {
+                    splitPositions.push_back(projectTime);
+                }
             }
         }
 
         std::sort(splitPositions.begin(), splitPositions.end());
+        splitPositions.erase(
+            std::unique(splitPositions.begin(), splitPositions.end()),
+            splitPositions.end());
 
         // Split from right to left so earlier positions remain valid
         for (int i = static_cast<int>(splitPositions.size()) - 1; i >= 0; i--) {
@@ -282,6 +295,8 @@ class AudioOutputAlgorithm : public FlucomaAlgorithm<ClientType> {
                 GetSetMediaItemTakeInfo(newTake, "P_SOURCE", newSource);
                 GetSetMediaItemTakeInfo(newTake, "P_NAME",
                                         (char *)takeName.c_str());
+                double zero = 0.0;
+                GetSetMediaItemTakeInfo(newTake, "D_STARTOFFS", &zero);
             }
         }
     }

ReacomaExtension/Algorithms/SlicingAlgorithm.h

@@ -41,13 +41,19 @@ class SlicingAlgorithm : public FlucomaAlgorithm<ClientType> {
             DeleteTakeMarker(take, i);
 
         double itemLength = GetMediaItemInfo_Value(item, "D_LENGTH");
+        double takeOffset = GetMediaItemTakeInfo_Value(take, "D_STARTOFFS");
+        double playrate = GetMediaItemTakeInfo_Value(take, "D_PLAYRATE");
+        double maxSourceTime = itemLength * playrate;
+
         auto view = reader.samps(0);
         for (fluid::index i = 0; i < view.size(); i++) {
-            if (view(i) > 0) {
-                double markerTimeInSeconds =
+            if (view(i) >= 0) {
+                double timeInSeconds =
                     static_cast<double>(view(i)) / sampleRate;
-                if (markerTimeInSeconds < itemLength)
-                    SetTakeMarker(take, -1, "", &markerTimeInSeconds, nullptr);
+                if (timeInSeconds < maxSourceTime) {
+                    double srcPos = takeOffset + timeInSeconds;
+                    SetTakeMarker(take, -1, "", &srcPos, nullptr);
+                }
             }
         }
     }
@@ -64,6 +70,10 @@ class SlicingAlgorithm : public FlucomaAlgorithm<ClientType> {
 
         double itemPos = GetMediaItemInfo_Value(item, "D_POSITION");
         double itemLen = GetMediaItemInfo_Value(item, "D_LENGTH");
+        MediaItem_Take *take = GetActiveTake(item);
+        double playrate =
+            take ? GetMediaItemTakeInfo_Value(take, "D_PLAYRATE") : 1.0;
+        double maxSourceTime = itemLen * playrate;
 
         auto view = reader.samps(0);
         std::vector<double> sliceTimes;
@@ -74,11 +84,15 @@ class SlicingAlgorithm : public FlucomaAlgorithm<ClientType> {
 
         // Collect all slice points and convert from samples to seconds
         for (fluid::index i = 0; i < view.size(); i++) {
-            if (view(i) > 0) {
+            if (view(i) >= 0) {
                 double timeInSeconds =
                     static_cast<double>(view(i)) / sampleRate;
-                if (timeInSeconds < itemLen)
-                    sliceTimes.push_back(timeInSeconds);
+                if (timeInSeconds < maxSourceTime) {
+                    // Convert source time relative to start of buffer to
+                    // project time relative to item start
+                    double projectTimeRelative = timeInSeconds / playrate;
+                    sliceTimes.push_back(projectTimeRelative);
+                }
             }
         }