mlt-ffi 0.2.3

Diplomat FFI bindings for mlt-core
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

#ifndef MltConverter_HPP
#define MltConverter_HPP

#include "MltConverter.d.hpp"

#include "ConvertError.hpp"
#include "MltBuffer.hpp"
#include "MltEncoderOptions.hpp"
#include "diplomat_runtime.hpp"
#include <cstdlib>
#include <functional>
#include <memory>
#include <optional>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

namespace diplomat {
namespace capi {
extern "C" {

typedef struct MltConverter_mlt_to_mvt_result {
    union {
        diplomat::capi::MltBuffer* ok;
        diplomat::capi::ConvertError* err;
    };
    bool is_ok;
} MltConverter_mlt_to_mvt_result;
MltConverter_mlt_to_mvt_result MltConverter_mlt_to_mvt(diplomat::capi::DiplomatU8View mlt);

typedef struct MltConverter_mlt_to_mvt_with_limit_result {
    union {
        diplomat::capi::MltBuffer* ok;
        diplomat::capi::ConvertError* err;
    };
    bool is_ok;
} MltConverter_mlt_to_mvt_with_limit_result;
MltConverter_mlt_to_mvt_with_limit_result MltConverter_mlt_to_mvt_with_limit(diplomat::capi::DiplomatU8View mlt,
                                                                             uint32_t max_bytes);

typedef struct MltConverter_mvt_to_mlt_result {
    union {
        diplomat::capi::MltBuffer* ok;
        diplomat::capi::ConvertError* err;
    };
    bool is_ok;
} MltConverter_mvt_to_mlt_result;
MltConverter_mvt_to_mlt_result MltConverter_mvt_to_mlt(diplomat::capi::DiplomatU8View mvt,
                                                       const diplomat::capi::MltEncoderOptions* options);

void MltConverter_destroy(MltConverter* self);

} // extern "C"
} // namespace capi
} // namespace diplomat

inline diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>> MltConverter::mlt_to_mvt(
    diplomat::span<const uint8_t> mlt) {
    auto result = diplomat::capi::MltConverter_mlt_to_mvt({mlt.data(), mlt.size()});
    return result.is_ok ? diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>>(
                              diplomat::Ok<std::unique_ptr<MltBuffer>>(
                                  std::unique_ptr<MltBuffer>(MltBuffer::FromFFI(result.ok))))
                        : diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>>(
                              diplomat::Err<std::unique_ptr<ConvertError>>(
                                  std::unique_ptr<ConvertError>(ConvertError::FromFFI(result.err))));
}

inline diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>> MltConverter::mlt_to_mvt_with_limit(
    diplomat::span<const uint8_t> mlt, uint32_t max_bytes) {
    auto result = diplomat::capi::MltConverter_mlt_to_mvt_with_limit({mlt.data(), mlt.size()}, max_bytes);
    return result.is_ok ? diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>>(
                              diplomat::Ok<std::unique_ptr<MltBuffer>>(
                                  std::unique_ptr<MltBuffer>(MltBuffer::FromFFI(result.ok))))
                        : diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>>(
                              diplomat::Err<std::unique_ptr<ConvertError>>(
                                  std::unique_ptr<ConvertError>(ConvertError::FromFFI(result.err))));
}

inline diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>> MltConverter::mvt_to_mlt(
    diplomat::span<const uint8_t> mvt, const MltEncoderOptions& options) {
    auto result = diplomat::capi::MltConverter_mvt_to_mlt({mvt.data(), mvt.size()}, options.AsFFI());
    return result.is_ok ? diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>>(
                              diplomat::Ok<std::unique_ptr<MltBuffer>>(
                                  std::unique_ptr<MltBuffer>(MltBuffer::FromFFI(result.ok))))
                        : diplomat::result<std::unique_ptr<MltBuffer>, std::unique_ptr<ConvertError>>(
                              diplomat::Err<std::unique_ptr<ConvertError>>(
                                  std::unique_ptr<ConvertError>(ConvertError::FromFFI(result.err))));
}

inline const diplomat::capi::MltConverter* MltConverter::AsFFI() const {
    return reinterpret_cast<const diplomat::capi::MltConverter*>(this);
}

inline diplomat::capi::MltConverter* MltConverter::AsFFI() {
    return reinterpret_cast<diplomat::capi::MltConverter*>(this);
}

inline const MltConverter* MltConverter::FromFFI(const diplomat::capi::MltConverter* ptr) {
    return reinterpret_cast<const MltConverter*>(ptr);
}

inline MltConverter* MltConverter::FromFFI(diplomat::capi::MltConverter* ptr) {
    return reinterpret_cast<MltConverter*>(ptr);
}

inline void MltConverter::operator delete(void* ptr) {
    diplomat::capi::MltConverter_destroy(reinterpret_cast<diplomat::capi::MltConverter*>(ptr));
}

#endif // MltConverter_HPP