93 lines
4.2 KiB
C++
93 lines
4.2 KiB
C++
#pragma once
|
|
// batch_capture — the REAPER-free logic behind batch capture (one action fires N
|
|
// captures: one bank sample per selected item / per razor area).
|
|
//
|
|
// PURE MODULE: NO REAPER types, NO SWELL, NO vendor/ includes. Standard library
|
|
// only. The batch shell reads the DAW state (selected items -> exact bounds;
|
|
// each track's P_RAZOREDITS -> areas) and hands the raw ranges here:
|
|
//
|
|
// 1. planCaptureUnits: an ordered list of (start,end) ranges -> an ordered
|
|
// list of CaptureUnit, each with a 1-based ordinal and validated bounds.
|
|
// Empty/inverted ranges are dropped (mirrors the offline backend's own
|
|
// end>start guard); ordinals count only the kept units, so three valid
|
|
// items yield 1,2,3 regardless of dropped neighbors.
|
|
// 2. BatchOutcome: order-preserving aggregation of per-unit results into a
|
|
// summary (succeeded/failed counts + ordered failures) for one console
|
|
// line with no partial-corruption ambiguity.
|
|
//
|
|
// Range is the only thing that varies per unit here. FX scope (item vs track) is
|
|
// a per-action constant the shell already owns; item-batch uses item scope,
|
|
// razor-batch uses track scope, passed through unchanged from the single-capture
|
|
// path.
|
|
|
|
#include <cstddef>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace reasampler::capture {
|
|
|
|
// One capture in a batch: an exact source range plus its 1-based ordinal within
|
|
// the kept set. The ordinal disambiguates per-unit file stems (the offline
|
|
// backend's unique tag is 1-second-granular, so a fast batch could otherwise
|
|
// collide N files onto one name) and labels a failure in the summary.
|
|
struct CaptureUnit {
|
|
int ordinal = 0; // 1-based, counts kept units only
|
|
double startSeconds = 0.0; // exact — no rounding
|
|
double endSeconds = 0.0;
|
|
};
|
|
|
|
// A source range handed in by the shell (a selected item's [pos, pos+len] or one
|
|
// razor area's [start, end]). Named BatchRange (not SourceRange) to avoid
|
|
// collision with bank_model's SourceRange, which carries PPQ fields this planner
|
|
// doesn't need.
|
|
struct BatchRange {
|
|
double startSeconds = 0.0;
|
|
double endSeconds = 0.0;
|
|
};
|
|
|
|
// Validates + orders a batch's source ranges into capture units. Preserves input
|
|
// order; drops every range with end <= start; assigns 1-based ordinals over the
|
|
// kept units. An empty input yields an empty plan — the shell reports "nothing
|
|
// to batch" and writes nothing.
|
|
std::vector<CaptureUnit> planCaptureUnits(const std::vector<BatchRange>& ranges);
|
|
|
|
// The per-unit verdict the shell records after each render attempt, in unit order.
|
|
struct BatchUnitResult {
|
|
int ordinal = 0; // the CaptureUnit's ordinal this result is for
|
|
bool ok = false; // true iff the render + bank-add succeeded
|
|
std::string detail; // failure reason (empty on success) — for the summary
|
|
};
|
|
|
|
// Order-preserving aggregation of a batch's per-unit results. Built incrementally
|
|
// by the shell (record() after each unit) so a mid-batch failure doesn't abort
|
|
// the remaining units — each unit is independent.
|
|
class BatchOutcome {
|
|
public:
|
|
// Records one unit's verdict. Order of calls IS the reported order.
|
|
void record(int ordinal, bool ok, std::string detail = {});
|
|
|
|
std::size_t total() const { return results_.size(); }
|
|
std::size_t succeeded() const;
|
|
std::size_t failed() const;
|
|
|
|
const std::vector<BatchUnitResult>& results() const { return results_; }
|
|
|
|
// The ordered subset of results that failed (ok == false). For the summary line.
|
|
std::vector<BatchUnitResult> failures() const;
|
|
|
|
// A single human summary line for the console (explicit-action response — allowed
|
|
// by the console policy; a batch-completion summary with failure counts qualifies,
|
|
// per-unit success spam does not). `noun` is the unit word ("item" / "razor area").
|
|
// Examples:
|
|
// all-success, 3 items : "ReaSampler batch capture: 3 items captured."
|
|
// partial, 3 of 5 : "ReaSampler batch capture: 3 of 5 items captured "
|
|
// "(2 failed: #2, #4)."
|
|
// empty plan : "ReaSampler batch capture: nothing to capture."
|
|
std::string summaryLine(const std::string& noun) const;
|
|
|
|
private:
|
|
std::vector<BatchUnitResult> results_;
|
|
};
|
|
|
|
} // namespace reasampler::capture
|