device_placement.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/timeline/assets.hpp>
#include <pulp/timeline/item_id.hpp>
 
#include <bit>
#include <cmath>
#include <compare>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
 
namespace pulp::timeline {


enum class DeviceChainPosition : std::uint8_t {
    PreFader,
    PostFader
};

enum class DeviceSlotKind : std::uint8_t {
    EventToEvent,
    EventToAudio,
    AudioToAudio
};

enum class DeviceKind : std::uint8_t {
    Unresolved,
    BuiltIn,
    External,
    Generated
};

inline constexpr std::size_t kMaximumDeviceBindingKeyBytes = 1024;

struct DeviceConfiguration {
    DeviceChainPosition position = DeviceChainPosition::PreFader;
    DeviceSlotKind slot_kind = DeviceSlotKind::AudioToAudio;
    DeviceKind device_kind = DeviceKind::Unresolved;
    std::string binding_key;
    bool bypassed = false;
    std::uint32_t wet_dry_bits = std::bit_cast<std::uint32_t>(1.0f);

    bool valid() const noexcept {
        switch (position) {
        case DeviceChainPosition::PreFader:
        case DeviceChainPosition::PostFader:
            break;
        default:
            return false;
        }
        switch (slot_kind) {
        case DeviceSlotKind::EventToEvent:
        case DeviceSlotKind::EventToAudio:
        case DeviceSlotKind::AudioToAudio:
            break;
        default:
            return false;
        }
        switch (device_kind) {
        case DeviceKind::Unresolved:
            if (!binding_key.empty())
                return false;
            break;
        case DeviceKind::BuiltIn:
        case DeviceKind::External:
        case DeviceKind::Generated:
            if (binding_key.empty())
                return false;
            break;
        default:
            return false;
        }
        if (binding_key.size() > kMaximumDeviceBindingKeyBytes)
            return false;
        for (const unsigned char byte : binding_key)
            if (byte < 0x20 || byte == 0x7f)
                return false;
        const auto wet_dry = std::bit_cast<float>(wet_dry_bits);
        return std::isfinite(wet_dry) && wet_dry >= 0.0f && wet_dry <= 1.0f;
    }
 
    auto operator<=>(const DeviceConfiguration&) const = default;
};

struct DevicePlacement {
    ItemId id;
    DeviceConfiguration configuration;
    std::optional<ContentHash> state_ref;

    bool valid() const noexcept {
        return id.valid() && configuration.valid() &&
               (!state_ref || state_ref->valid());
    }
 
    auto operator<=>(const DevicePlacement&) const = default;
};

 
} // namespace pulp::timeline