irondash_texture 0.5.0

Rust Bindings for Flutter External Textures.
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::ffi::{c_char, c_int, c_void};

use glib_sys::GType;
use gobject_sys::{GObject, GObjectClass};

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlTextureRegistrar {
    parent_instance: GObject,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlTextureRegistrarClass {
    parent_class: GObjectClass,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlTexture {
    parent_instance: GObject,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlTextureClass {
    parent_class: GObjectClass,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlPixelBufferTexture {
    parent_instance: FlTexture,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlPixelBufferTextureClass {
    parent_class: FlTextureClass,
    pub copy_pixels: Option<
        unsafe extern "C" fn(
            texture: *mut FlPixelBufferTexture,
            buffer: *mut *const u8,
            width: *mut u32,
            height: *mut u32,
            error: *mut *mut glib_sys::GError,
        ) -> glib_sys::gboolean,
    >,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlTextureGL {
    parent_instance: FlTexture,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct FlTextureGLClass {
    parent_class: FlTextureClass,
    pub populate: Option<
        unsafe extern "C" fn(
            texture: *mut FlTextureGL,
            target: *mut u32,
            name: *mut u32,
            width: *mut u32,
            height: *mut u32,
            error: *mut *mut glib_sys::GError,
        ) -> glib_sys::gboolean,
    >,
}

// Can't link to Flutter engine directly.
pub struct Functions {
    pub fl_texture_get_type: unsafe extern "C" fn() -> GType,
    pub fl_pixel_buffer_texture_get_type: unsafe extern "C" fn() -> GType,
    pub fl_texture_gl_get_type: unsafe extern "C" fn() -> GType,
    pub fl_texture_registrar_register_texture: unsafe extern "C" fn(
        registrar: *mut FlTextureRegistrar,
        texture: *mut FlTexture,
    ) -> glib_sys::gboolean,
    pub fl_texture_registrar_mark_texture_frame_available:
        unsafe extern "C" fn(
            registrar: *mut FlTextureRegistrar,
            texture_id: *mut FlTexture,
        ) -> glib_sys::gboolean,
    pub fl_texture_registrar_unregister_texture: unsafe extern "C" fn(
        registrar: *mut FlTextureRegistrar,
        texture_id: *mut FlTexture,
    ) -> glib_sys::gboolean,
}

const RTLD_LAZY: c_int = 1;

extern "C" {
    fn dlopen(filename: *const c_char, flags: c_int) -> *mut c_void;
    fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void;
}

use cstr::cstr;
use once_cell::sync::OnceCell;

static FUNCTIONS: OnceCell<Functions> = OnceCell::new();

impl Functions {
    pub fn get() -> &'static Self {
        FUNCTIONS.get_or_init(Self::new)
    }

    fn new() -> Self {
        unsafe {
            let dl = dlopen(std::ptr::null_mut(), RTLD_LAZY);
            Self {
                fl_texture_get_type: std::mem::transmute(dlsym(
                    dl,
                    cstr!("fl_texture_get_type").as_ptr(),
                )),
                fl_pixel_buffer_texture_get_type: std::mem::transmute(dlsym(
                    dl,
                    cstr!("fl_pixel_buffer_texture_get_type").as_ptr(),
                )),
                fl_texture_gl_get_type: std::mem::transmute(dlsym(
                    dl,
                    cstr!("fl_texture_gl_get_type").as_ptr(),
                )),
                fl_texture_registrar_register_texture: std::mem::transmute(dlsym(
                    dl,
                    cstr!("fl_texture_registrar_register_texture").as_ptr(),
                )),
                fl_texture_registrar_mark_texture_frame_available: std::mem::transmute(dlsym(
                    dl,
                    cstr!("fl_texture_registrar_mark_texture_frame_available").as_ptr(),
                )),
                fl_texture_registrar_unregister_texture: std::mem::transmute(dlsym(
                    dl,
                    cstr!("fl_texture_registrar_unregister_texture").as_ptr(),
                )),
            }
        }
    }
}