QVAC-21921 audiogen-cpp: report per-step progress from LM and DiT

Add optional on_step hooks so the engine can surface real generation
progress to its ProgressFn, driving a determinate UI progress bar
instead of an indeterminate spinner.

- dit_ggml: DitSampleParams.on_step(step, num_steps), fired at the start
  of each Euler step; returning false requests cooperative cancellation.
- lm_pipeline: LmSampleParams.on_step(cur, max_tokens), fired throttled
  (every 8 tokens) in the Phase-2 code loop. This is the longest stage on
  CPU, so it drives most of the bar. Informational only (no cancel).
- engine: wire both hooks to the existing ProgressFn as report("lm", ...)
  and report("dit", ...).

No public API change: only the internal DitSampleParams/LmSampleParams
gain a default-empty callback; engine.h's ProgressFn is reused as-is.

Author: freddy311082

audiogen-cpp/src/acestep/dit_ggml.cpp

@@ -709,6 +709,7 @@ bool dit_sample(DitModel * m, const DitSampleParams & p, std::vector<float> & la
 
     std::vector<float> vt;
     for (int step = 0; step < p.num_steps; step++) {
+        if (p.on_step && !p.on_step(step, p.num_steps)) return false;
         const float t_curr = p.schedule[step];
 
         // splice x_t into the trailing Oc channels of the DiT input

audiogen-cpp/src/acestep/dit_ggml.h

@@ -16,6 +16,7 @@
 
 #include "ggml-backend.h"
 
+#include <functional>
 #include <string>
 #include <vector>
 
@@ -88,6 +89,12 @@ struct DitSampleParams {
     const float * schedule        = nullptr;  // [num_steps] descending timesteps
     int           num_steps       = 0;
     const int *   real_enc_S      = nullptr;  // [N] valid encoder lengths; null = all enc_S
+
+    // Optional per-step progress hook, fired at the start of each Euler step
+    // with (step, num_steps). Return false to request cancellation (the sampler
+    // then aborts and dit_sample returns false). The diffusion loop is the bulk
+    // of generation time, so this is the signal that drives real UI progress.
+    std::function<bool(int step, int total)> on_step;
 };
 
 // Writes the denoised latent [out_channels, T, N] to `latent_out`. Rebuilds the

audiogen-cpp/src/acestep/engine.cpp

@@ -266,6 +266,9 @@ GenerateResult Engine::generate(const GenerateParams & params, const ProgressFn
         // the full int64 seed (Philox, torch.randn parity), which it gets below.
         lp.seed        = (uint32_t) seed;
         lp.verbose     = m->opts.verbose;
+        // Surface incremental Phase-2 progress (the longest stage) so the UI bar
+        // advances while the LM writes audio codes, not only during the DiT.
+        lp.on_step     = [&](int cur, int total) { report("lm", cur, total); };
 
         // Phase 1: fill missing metadata (bpm/keyscale/duration/timesignature)
         // from the caption via the FSM, so a bare caption matches the CLI.
@@ -399,6 +402,9 @@ GenerateResult Engine::generate(const GenerateParams & params, const ProgressFn
     sp.schedule        = schedule.data();
     sp.num_steps       = n_steps;
     sp.real_enc_S      = &enc_S;
+    // Surface per-step diffusion progress (the long pole) to the caller's
+    // ProgressFn; returning false here also honours cooperative cancellation.
+    sp.on_step         = [&](int step, int total) { return report("dit", step, total); };
 
     std::vector<float> latent;
     if (!dit_sample(m->dit, sp, latent)) throw std::runtime_error("acestep engine: DiT sample failed");

audiogen-cpp/src/acestep/lm_pipeline.cpp

@@ -506,6 +506,11 @@ bool lm_generate_codes(LMModel *              m,
         if (params.verbose && (step + 1) % 100 == 0) {
             fprintf(stderr, "[lm-pipeline]   step %d, %zu codes\n", step + 1, codes_out.size());
         }
+        // Throttled progress: every 8 tokens (each step is a full LM forward, so
+        // this is cheap relative to the work) plus the final step.
+        if (params.on_step && ((step & 7) == 0 || step == max_tokens - 1)) {
+            params.on_step(step + 1, max_tokens);
+        }
     }
 
     if (params.verbose) {

audiogen-cpp/src/acestep/lm_pipeline.h

@@ -14,6 +14,7 @@
 #include "lm_ggml.h"
 
 #include <cstdint>
+#include <functional>
 #include <random>
 #include <string>
 #include <vector>
@@ -39,6 +40,11 @@ struct LmSampleParams {
     uint32_t seed           = 0;
     int      max_new_tokens = 0;      // 0 => derive from duration (dur*5 + 100)
     bool     verbose        = false;  // gate progress/metadata/code-dump logs
+
+    // Optional progress hook for the Phase-2 code loop, fired periodically with
+    // (tokens_generated, max_tokens). This is the longest stage on CPU, so it
+    // drives the bulk of the UI progress bar. Purely informational (no cancel).
+    std::function<void(int cur, int total)> on_step;
 };
 
 // Temperature -> top_k -> top_p -> softmax -> multinomial. Mutates `logits`.