warb 0.1.0

Unofficial Rust bindings compatible with Blackmagic Design Blackmagic RAW. Not affiliated with or endorsed by Blackmagic Design.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// Thin RAII wrappers around the BMD COM interfaces, exposed to Rust via
// cxx. The higher-level `Decoder` lives entirely in Rust on top of these.

#pragma once

#include "warb_abi.h"
#include "rust/cxx.h"

#include <memory>

// Forward-declared Rust type: the cxx-generated header gives us the
// extern "Rust" dispatch functions (on_read_complete etc.) that take
// `CallbackBridge&`.
struct CallbackBridge;

class BrawCodec;
class BrawClip;
class BrawFrame;
class BrawProcessedImage;
class BrawJob;

// Each wrapper owns one reference to its underlying COM interface via
// `warb_abi::ComPtr`, which releases on destruction. Move-only.

class BrawJob final {
public:
    explicit BrawJob(warb_abi::IBlackmagicRawJob* raw) noexcept : raw_(raw) {}

    void set_user_data(uint64_t user_data);
    void abort();

    friend void submit_job(std::unique_ptr<BrawJob>);

private:
    warb_abi::ComPtr<warb_abi::IBlackmagicRawJob> raw_;
};

class BrawFrame final {
public:
    explicit BrawFrame(warb_abi::IBlackmagicRawFrame* raw) noexcept : raw_(raw) {}

    void set_resource_format(uint32_t format);
    void set_resolution_scale(uint32_t scale);
    std::unique_ptr<BrawJob> create_job_decode_and_process();

private:
    warb_abi::ComPtr<warb_abi::IBlackmagicRawFrame> raw_;
};

class BrawProcessedImage final {
public:
    explicit BrawProcessedImage(warb_abi::IBlackmagicRawProcessedImage* raw) noexcept
        : raw_(raw) {}

    uint32_t width()      const;
    uint32_t height()     const;
    uint32_t format()     const;
    uint32_t size_bytes() const;
    // Borrowed view into the SDK's decoded pixel buffer. The buffer
    // stays live as long as this BrawProcessedImage does; cxx ties the
    // returned slice's lifetime to &self.
    rust::Slice<const uint8_t> data() const;

private:
    warb_abi::ComPtr<warb_abi::IBlackmagicRawProcessedImage> raw_;
};

class BrawClip final {
public:
    explicit BrawClip(warb_abi::IBlackmagicRawClip* raw) noexcept : raw_(raw) {}

    uint32_t width()       const;
    uint32_t height()      const;
    uint64_t frame_count() const;
    float    frame_rate()  const;
    std::unique_ptr<BrawJob> create_job_read_frame(uint64_t frame_index);

private:
    warb_abi::ComPtr<warb_abi::IBlackmagicRawClip> raw_;
};

// Implements IBlackmagicRawCallback, serialises access to the Rust-owned
// CallbackBridge box across SDK worker threads, and forwards events via cxx's
// generated `extern "Rust"` trampolines.
class CallbackDispatcher;

class BrawCodec final {
public:
    BrawCodec(warb_abi::IBlackmagicRawFactory* factory,
              warb_abi::IBlackmagicRaw* codec,
              std::unique_ptr<CallbackDispatcher> dispatcher);
    ~BrawCodec();

    BrawCodec(const BrawCodec&)            = delete;
    BrawCodec& operator=(const BrawCodec&) = delete;

    void prepare_pipeline(uint32_t pipeline);
    std::unique_ptr<BrawClip> open_clip(rust::Slice<const uint8_t> path);
    void flush_jobs();

private:
    // Declared so that implicit teardown (post-body of ~BrawCodec)
    // releases `codec_` first, then `factory_`, and destroys
    // `dispatcher_` (which owns the Rust CallbackBridge box) last.
    std::unique_ptr<CallbackDispatcher>               dispatcher_;
    warb_abi::ComPtr<warb_abi::IBlackmagicRawFactory> factory_;
    warb_abi::ComPtr<warb_abi::IBlackmagicRaw>        codec_;
};

std::unique_ptr<BrawCodec> new_codec(rust::Box<CallbackBridge> handler);
void submit_job(std::unique_ptr<BrawJob> job);