AudioEffects.cpp

浏览该文件的文档.

#include "audio/editing/AudioEffects.h"
 
#include <algorithm>
#include <cmath>
#include <set>
#include <utility>
 
namespace eve::audio_editing {
namespace {
const EditorValue* field(const EditorValue& value, const char* key) {
    const auto* object = value.getIf<EditorValue::Object>();
    if (!object) return nullptr;
    const auto found = object->find(key);
    return found == object->end() ? nullptr : &found->second;
}
EditorValue effectValue(const AudioEffectRecord& effect) {
    return EditorValue::Object{{"id", effect.id.value()},
                               {"type", effect.type},
                               {"bypass", effect.bypass},
                               {"mix", effect.mix},
                               {"parameters", effect.parameters}};
}
bool numberIn(const EditorValue::Object& parameters, const char* key, double minimum, double maximum) {
    const auto  found  = parameters.find(key);
    const auto* number = found == parameters.end() ? nullptr : found->second.getIf<double>();
    return number && std::isfinite(*number) && *number >= minimum && *number <= maximum;
}
Result<AudioEffectRecord> parseEffect(const EditorValue& value) {
    const auto *idEntry = field(value, "id"), *typeEntry = field(value, "type"), *bypassEntry = field(value, "bypass"),
               *mixEntry = field(value, "mix"), *parametersEntry = field(value, "parameters");
    const auto* id         = idEntry ? idEntry->getIf<std::string>() : nullptr;
    const auto* type       = typeEntry ? typeEntry->getIf<std::string>() : nullptr;
    const auto* bypass     = bypassEntry ? bypassEntry->getIf<bool>() : nullptr;
    const auto* mix        = mixEntry ? mixEntry->getIf<double>() : nullptr;
    const auto* parameters = parametersEntry ? parametersEntry->getIf<EditorValue::Object>() : nullptr;
    static const std::set<std::string> types{"gain", "low-pass", "high-pass", "delay", "reverb", "compressor"};
    bool valid = id && !id->empty() && type && types.contains(*type) && bypass && mix && std::isfinite(*mix) &&
                 *mix >= 0.0 && *mix <= 1.0 && parameters;
    if (valid && *type == "gain")
        valid = numberIn(*parameters, "decibels", -96.0, 24.0);
    else if (valid && (*type == "low-pass" || *type == "high-pass"))
        valid = numberIn(*parameters, "cutoff", 20.0, 24000.0) && numberIn(*parameters, "resonance", 0.1, 20.0);
    else if (valid && *type == "delay")
        valid = numberIn(*parameters, "seconds", 0.001, 5.0) && numberIn(*parameters, "feedback", 0.0, 0.99);
    else if (valid && *type == "reverb")
        valid = numberIn(*parameters, "room-size", 0.0, 1.0) && numberIn(*parameters, "damping", 0.0, 1.0);
    else if (valid && *type == "compressor")
        valid = numberIn(*parameters, "threshold", -96.0, 0.0) && numberIn(*parameters, "ratio", 1.0, 100.0);
    if (!valid)
        return eve::editing::failed<AudioEffectRecord>(EditorStatus::Rejected, RuleId("editor.audio.invalid-effect"),
                                                       "Effect identity, type, mix or typed parameters are invalid");
    return eve::editing::applied<AudioEffectRecord>({StableId(*id), *type, *bypass, *mix, *parametersEntry});
}
EditorValue orderValue(const std::vector<StableId>& order) {
    EditorValue::Array result;
    for (const auto& id : order) result.push_back(id.value());
    return result;
}
Result<std::vector<StableId>> parseOrder(const EditorValue& value) {
    const auto* array = value.getIf<EditorValue::Array>();
    if (!array)
        return eve::editing::failed<std::vector<StableId>>(
            EditorStatus::Rejected, RuleId("editor.audio.invalid-effect-order"), "Effect order must be an array");
    std::vector<StableId> result;
    std::set<StableId>    unique;
    for (const auto& entry : *array) {
        const auto* id = entry.getIf<std::string>();
        if (!id || id->empty() || !unique.emplace(*id).second)
            return eve::editing::failed<std::vector<StableId>>(EditorStatus::Rejected,
                                                               RuleId("editor.audio.invalid-effect-order"),
                                                               "Effect order ids must be non-empty and unique");
        result.emplace_back(*id);
    }
    return eve::editing::applied<std::vector<StableId>>(std::move(result));
}
DomainOperation operation(const char* type, const char* inverse, const std::string& target, EditorValue payload,
                          EditorValue undo, const StableId& id = {}) {
    DomainOperation result;
    result.type        = type;
    result.inverseType = inverse;
    result.target      = TargetId(target);
    result.payload     = std::move(payload);
    result.inverse     = std::move(undo);
    result.hasInverse  = true;
    if (!id.empty()) result.affectedObjects.push_back({TargetId(target), id.value(), 0});
    return result;
}
}  // namespace
 
AudioEffectChainTarget::AudioEffectChainTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor AudioEffectChainTarget::describe() const {
    return {
        TargetId(id_), "audio-effect-chain", revisionValue(), false, {CapabilityId("eve.editor.target.audio-effects")}};
}
void* AudioEffectChainTarget::queryCapability(const CapabilityId& capability) {
    return capability == CapabilityId("eve.editor.target.audio-effects") ? static_cast<AudioEffectChainTarget*>(this)
                                                                         : nullptr;
}
Result<void> AudioEffectChainTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.audio.effect-target"),
                                          "Effect operation targets another chain");
    if (op.type == "audio.effect.set.v1") {
        auto parsed = parseEffect(op.payload);
        if (!parsed.ok()) return Result<void>::failure(parsed.status());
        if (!effects_.contains(parsed.value().id)) order_.push_back(parsed.value().id);
        effects_.insert_or_assign(parsed.value().id, parsed.value());
    } else if (op.type == "audio.effect.delete.v1") {
        const auto* id = op.payload.getIf<std::string>();
        if (!id || !effects_.erase(StableId(*id)))
            return eve::editing::failed<void>(EditorStatus::NotFound, RuleId("editor.audio.effect-not-found"),
                                              "Effect was not found");
        std::erase(order_, StableId(*id));
    } else if (op.type == "audio.effect.reorder.v1") {
        auto order = parseOrder(op.payload);
        if (!order.ok() || order.value().size() != effects_.size() ||
            std::any_of(order.value().begin(), order.value().end(),
                        [&](const StableId& id) { return !effects_.contains(id); }))
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.audio.effect-order"),
                                              "Effect order must contain every effect exactly once");
        order_ = std::move(order.value());
    } else
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.audio.effect-operation"),
                                          "Unsupported effect operation");
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> AudioEffectChainTarget::cloneDomainState() const {
    return std::make_unique<AudioEffectChainTarget>(*this);
}
Result<void> AudioEffectChainTarget::commitDomainState(
    std::unique_ptr<IDomainOperationTarget> candidate) {
    auto* typed = dynamic_cast<AudioEffectChainTarget*>(candidate.get());
    if (!typed || typed->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.audio.effect-staging"),
                                          "Invalid staged effect chain");
    *this = *typed;
    return eve::editing::applied<void>();
}
std::vector<AudioEffectRecord> AudioEffectChainTarget::effects() const {
    std::vector<AudioEffectRecord> result;
    for (const auto& id : order_) result.push_back(effects_.at(id));
    return result;
}
Result<DomainOperation> AudioEffectChainTarget::makeSet(const AudioEffectRecord& effect) const {
    auto parsed = parseEffect(effectValue(effect));
    if (!parsed.ok()) return Result<DomainOperation>::failure(parsed.status());
    const auto found = effects_.find(effect.id);
    return eve::editing::applied<DomainOperation>(operation(
        "audio.effect.set.v1", found == effects_.end() ? "audio.effect.delete.v1" : "audio.effect.set.v1", id_,
        effectValue(effect), found == effects_.end() ? EditorValue(effect.id.value()) : effectValue(found->second),
        effect.id));
}
Result<DomainOperation> AudioEffectChainTarget::makeDelete(const StableId& id) const {
    const auto found = effects_.find(id);
    if (found == effects_.end())
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.audio.effect-not-found"),
                                                     "Effect was not found");
    return eve::editing::applied<DomainOperation>(
        operation("audio.effect.delete.v1", "audio.effect.set.v1", id_, id.value(), effectValue(found->second), id));
}
Result<DomainOperation> AudioEffectChainTarget::makeReorder(const std::vector<StableId>& order) const {
    if (order.size() != effects_.size()) {
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.audio.effect-order"),
                                                     "Effect order must contain every effect");
    }
    std::set<StableId> unique(order.begin(), order.end());
    if (unique.size() != order.size() ||
        std::any_of(order.begin(), order.end(), [&](const StableId& id) { return !effects_.contains(id); }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.audio.effect-order"),
                                                     "Effect order contains missing or duplicate ids");
    return eve::editing::applied<DomainOperation>(
        operation("audio.effect.reorder.v1", "audio.effect.reorder.v1", id_, orderValue(order), orderValue(order_)));
}
std::vector<EditorDiagnostic> AudioEffectChainTarget::validate() const {
    std::vector<EditorDiagnostic> result;
    if (order_.size() > 16)
        result.push_back(eve::editing::ruleDiagnostic(
            eve::DiagnosticCode::PreconditionViolation, RuleId("editor.audio.effect-budget"),
            DiagnosticSeverity::Error, "Effect chain exceeds the 16-stage safety budget"));
    int reverbs = 0;
    for (const auto& id : order_)
        if (effects_.at(id).type == "reverb") ++reverbs;
    if (reverbs > 2)
        result.push_back(eve::editing::ruleDiagnostic(
            eve::DiagnosticCode::PreconditionViolation, RuleId("editor.audio.reverb-budget"),
            DiagnosticSeverity::Warning, "More than two reverbs may be expensive"));
    return result;
}
EditorValue AudioEffectChainTarget::snapshotValue() const {
    EditorValue::Array effects;
    for (const auto& effect : this->effects()) effects.push_back(effectValue(effect));
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"effects", std::move(effects)}};
}
Result<void> AudioEffectChainTarget::loadSnapshot(const EditorValue& snapshot) {
    const auto *versionEntry = field(snapshot, "schemaVersion"), *effectsEntry = field(snapshot, "effects");
    const auto* version = versionEntry ? versionEntry->getIf<int64_t>() : nullptr;
    const auto* effects = effectsEntry ? effectsEntry->getIf<EditorValue::Array>() : nullptr;
    if (!version || *version != 1 || !effects)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.audio.effect-snapshot"),
                                          "Invalid effect snapshot envelope");
    AudioEffectChainTarget candidate(id_);
    for (const auto& entry : *effects) {
        auto parsed = parseEffect(entry);
        if (!parsed.ok() || candidate.effects_.contains(parsed.value().id))
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.audio.effect-snapshot-entry"),
                                              "Invalid or duplicate effect snapshot entry");
        candidate.effects_.emplace(parsed.value().id, parsed.value());
        candidate.order_.push_back(parsed.value().id);
    }
    const auto diagnostics = candidate.validate();
    if (std::any_of(diagnostics.begin(), diagnostics.end(), [](const EditorDiagnostic& diagnostic) {
            return diagnostic.severity() == DiagnosticSeverity::Error;
        }))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.audio.effect-snapshot-budget"),
                                          "Effect snapshot exceeds safety budget");
    effects_ = std::move(candidate.effects_);
    order_   = std::move(candidate.order_);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
Result<DomainOperation> AudioEffectChainTarget::makeAssignToBus(const AudioMixerTarget& mixer,
                                                                      const ObjectId&         busId) const {
    const auto diagnostics = validate();
    if (std::any_of(diagnostics.begin(), diagnostics.end(), [](const EditorDiagnostic& diagnostic) {
            return diagnostic.severity() == DiagnosticSeverity::Error;
        }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.audio.effect-budget"),
                                                     "Invalid effect chain cannot be assigned");
    auto bus = mixer.bus(busId);
    if (!bus.ok()) return Result<DomainOperation>::failure(bus.status());
    bus.value().effects = EditorValue::Array{};
    auto* array         = bus.value().effects.getIf<EditorValue::Array>();
    for (const auto& effect : effects()) array->push_back(effectValue(effect));
    return mixer.makeReplace(bus.value());
}
Result<void> AudioEffectChainPublisher::publish(const AudioEffectChainTarget& chain, Revision expected,
                                                      IAudioEffectChainSink& sink) const {
    if (chain.revision() != expected)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.audio.effect-stale"),
                                          "Effect chain changed before publication");
    const auto diagnostics = chain.validate();
    for (const auto& diagnostic : diagnostics)
        if (diagnostic.severity() == DiagnosticSeverity::Error)
            return Result<void>::failure(eve::Status(EditorStatus::Rejected, diagnostics));
    return sink.publish(chain.targetId().value(), chain.revision(), chain.effects());
}
}  // namespace eve::audio_editing