[fix] fix waveform duration calculation and add mask-all-zero fallback in forwardWithKnownDurations

Author: wolfgitpr

src/infer/game-infer/src/GameModel.cpp

@@ -232,19 +232,32 @@ namespace Game
 
             InferenceInput input;
             input.waveform = waveform_data;
-            // Match Python: waveform_duration = known_durations.sum(dim=1)
-            input.duration = std::accumulate(known_durations.begin(), known_durations.end(), 0.0f);
-            if (input.duration <= 0.0f) {
-                msg = "forwardWithKnownDurations: total duration is zero or negative: " +
-                    std::to_string(input.duration);
+            input.known_durations = known_durations;
+            input.language = m_language;
+
+            const float waveformDuration = static_cast<float>(waveform_data.size()) / static_cast<float>(sampleRate);
+            if (waveformDuration <= 0.0f) {
+                msg = "forwardWithKnownDurations: waveform duration is zero or negative: " +
+                    std::to_string(waveformDuration);
                 {
                     std::lock_guard lock(m_runMutex);
                     m_activeRunOptions = nullptr;
                 }
                 return false;
             }
-            input.known_durations = known_durations;
-            input.language = m_language;
+
+            const float knownDurSum = std::accumulate(known_durations.begin(), known_durations.end(), 0.0f);
+            if (knownDurSum <= 0.0f) {
+                bool allZero = true;
+                for (const auto d : known_durations) {
+                    if (d > 0.0f) { allZero = false; break; }
+                }
+                if (allZero) {
+                    input.known_durations = {};
+                }
+            }
+
+            input.duration = waveformDuration;
 
             int T = static_cast<int>(std::ceil(input.duration / m_timestep));
             if (T <= 0)
@@ -797,9 +810,11 @@ namespace Game
         }
 
         std::vector<uint8_t> maskTBool(T);
+        size_t maskTTrueCount = 0;
         for (int64_t i = 0; i < T; ++i) {
             if (maskTData) {
                 maskTBool[i] = maskTData[i] ? 1 : 0;
+                if (maskTBool[i]) ++maskTTrueCount;
             } else {
                 maskTBool[i] = false;
             }
@@ -811,7 +826,7 @@ namespace Game
         }
 
         std::vector<uint8_t> knownBoundaries;
-        if (input.known_durations.size() > 1) {
+        if (knownDurations.size() > 1) {
             knownBoundaries = formatBoundaries(knownDurations, T, maskTBool);
         } else {
             knownBoundaries.resize(T, 0);
@@ -823,9 +838,54 @@ namespace Game
             boundaries.resize(T, 0);
         }
 
+        const float wavDurFallback = static_cast<float>(input.waveform.size()) / static_cast<float>(sampleRate);
+        if (maskTTrueCount == 0 && T > 0 && wavDurFallback > 0.0f &&
+            std::fabs(input.duration - wavDurFallback) > 1e-3f) {
+            auto [xSegVal2, xEstVal2, maskTVal2] = runEncoder(input.waveform, wavDurFallback, input.language);
+            if (xSegVal2 && maskTVal2) {
+                auto maskTShape2 = maskTVal2.GetTensorTypeAndShapeInfo().GetShape();
+                int64_t T2 = maskTShape2[1];
+                const bool *d2 = maskTVal2.GetTensorData<bool>();
+                size_t count2 = 0;
+                maskTBool.resize(T2);
+                for (int64_t i = 0; i < T2; ++i) {
+                    maskTBool[i] = d2[i] ? 1 : 0;
+                    if (maskTBool[i]) ++count2;
+                }
+                if (count2 > 0) {
+                    auto xSegShape2 = xSegVal2.GetTensorTypeAndShapeInfo().GetShape();
+                    auto xSegD2 = xSegVal2.GetTensorData<float>();
+                    size_t sc2 = xSegVal2.GetTensorTypeAndShapeInfo().GetElementCount();
+                    xSegClean.assign(xSegD2, xSegD2 + sc2);
+                    xSegCleanVal = Ort::Value::CreateTensor<float>(m_memoryInfo, xSegClean.data(), xSegClean.size(),
+                                                                   xSegShape2.data(), xSegShape2.size());
+                    auto xEstD2 = xEstVal2.GetTensorData<float>();
+                    size_t ec2 = xEstVal2.GetTensorTypeAndShapeInfo().GetElementCount();
+                    xEstClean.assign(xEstD2, xEstD2 + ec2);
+                    xEstCleanVal = Ort::Value::CreateTensor<float>(m_memoryInfo, xEstClean.data(), xEstClean.size(),
+                                                                   xSegShape2.data(), xSegShape2.size());
+                    T = T2;
+                    if (knownDurations.size() > 1) {
+                        knownBoundaries = formatBoundaries(knownDurations, T, maskTBool);
+                    } else {
+                        knownBoundaries.resize(T, 0);
+                    }
+                    boundaries = runSegmenterWithConfig(xSegCleanVal, knownBoundaries, knownBoundaries,
+                                                        input.language, maskTVal2, segThreshold, segRadius, d3pmTs);
+                    if (boundaries.empty())
+                        boundaries.resize(T, 0);
+                    maskTVal = std::move(maskTVal2);
+                }
+            }
+        }
+
         auto [durations, maskN] = boundariesToDurations(boundaries, maskTBool);
         if (durations.empty() || maskN.empty()) {
-            throw std::runtime_error("inferSlice: boundariesToDurations returned empty result");
+            throw std::runtime_error("inferSlice: boundariesToDurations returned empty result"
+                                     " (T=" + std::to_string(T) + ", bd_sz=" + std::to_string(boundaries.size()) +
+                                     ", mT_sz=" + std::to_string(maskTBool.size()) +
+                                     ", mT_true=" + std::to_string(maskTTrueCount) +
+                                     ", dur=" + std::to_string(input.duration) + ")");
         }
 
         std::vector<float> presence, scores;