plugkit 0.0.9

Deplug Package Development Kit
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
142
143
144
145
146
147
148

//! Macros for defining plugin functions.

/// Define file importer
#[macro_export]
macro_rules! plugkit_api_file_import {
    ( $x:ident ) => {
        #[no_mangle]
        pub extern "C" fn plugkit_v1_file_importer_is_supported(c: *mut Context, p: *const libc::c_char) -> bool {
            use std::ffi::CStr;
            use std::str;
            use std::path::Path;
            let path = unsafe {
                let slice = CStr::from_ptr(p);
                Path::new(str::from_utf8_unchecked(slice.to_bytes()))
            };
            let ctx = unsafe { &mut *c };
            $x::is_supported(ctx, path)
        }

        #[no_mangle]
        pub extern "C" fn plugkit_v1_file_importer_start(c: *mut Context, p: *const libc::c_char, d: *mut RawFrame,
                s: libc::size_t, callback: extern "C" fn (*mut Context, libc::size_t, f64)) -> plugkit::file::Status {
            use std::ffi::CStr;
            use std::{str,slice};
            use std::path::Path;
            use plugkit::file::Status;
            let path = unsafe {
                let slice = CStr::from_ptr(p);
                Path::new(str::from_utf8_unchecked(slice.to_bytes()))
            };
            let dst = unsafe {
                slice::from_raw_parts_mut(d, s as usize)
            };
            let ctx = unsafe { &mut *c };

            let result = $x::start(ctx, path, dst, &|ctx, len, prog| {
                callback(ctx as *mut Context, len, prog);
            });
            callback(c, 0, 1.0);
            if result.is_err() {
                Status::Error
            } else {
                Status::Done
            }
        }
    };
}

/// Define file exporter
#[macro_export]
macro_rules! plugkit_api_file_export {
    ( $x:ident ) => {
        #[no_mangle]
        pub extern "C" fn plugkit_v1_file_exporter_is_supported(c: *mut Context, p: *const libc::c_char) -> bool {
            use std::ffi::CStr;
            use std::str;
            use std::path::Path;
            let path = unsafe {
                let slice = CStr::from_ptr(p);
                Path::new(str::from_utf8_unchecked(slice.to_bytes()))
            };
            let ctx = unsafe { &mut *c };
            $x::is_supported(ctx, path)
        }

        #[no_mangle]
        pub extern "C" fn plugkit_v1_file_exporter_start(c: *mut Context, p: *const libc::c_char,
            callback: extern "C" fn (*mut Context, *mut libc::size_t) -> *const RawFrame) -> plugkit::file::Status {
            use std::ffi::CStr;
            use std::{str,slice};
            use std::path::Path;
            use plugkit::file::Status;
            let path = unsafe {
                let slice = CStr::from_ptr(p);
                Path::new(str::from_utf8_unchecked(slice.to_bytes()))
            };
            let ctx = unsafe { &mut *c };
            let result = $x::start(ctx, path, &|ctx| {
                let mut len : libc::size_t = 0;
                unsafe {
                    let ptr = &*callback(ctx as *mut Context, &mut len as *mut libc::size_t);
                    slice::from_raw_parts(ptr, len as usize)
                }
            });
            if result.is_err() {
                Status::Error
            } else {
                Status::Done
            }
        }
    };
}

/// Define layer hints
#[macro_export]
macro_rules! plugkit_api_layer_hints {
    ( $( $x:expr ), * ) => {
        #[no_mangle]
        pub extern "C" fn plugkit_v1_layer_hints(index: u32) -> u32 {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec.push(0);
            temp_vec[index as usize]
        }
    };
}

/// Define worker
#[macro_export]
macro_rules! plugkit_api_worker {
    ( $x: ty, $y:expr ) => {
        #[no_mangle]
        pub extern "C" fn plugkit_v1_create_worker(_ctx: *const (), _diss: *const ()) -> *mut() {
            Box::into_raw(Box::new($y)) as *mut()
        }

        #[no_mangle]
        pub extern "C" fn plugkit_v1_destroy_worker(_ctx: *const (), _diss: *const (), worker: *mut()) {
            unsafe {
                Box::from_raw(worker as *mut $x);
            }
        }

        #[no_mangle]
        pub extern "C" fn plugkit_v1_analyze(ctx: *mut (), _diss: *const (), worker: *mut(), layer: *mut ()) {
            use std::panic;
            use plugkit::context::Context;
            use plugkit::layer::Layer;
            unsafe {
                let w: &mut $x = &mut *(worker as *mut $x);
                let c: &mut Context =
                    &mut *(ctx as *mut Context);
                let l: &mut Layer = &mut *(layer as *mut Layer);
                let result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
                    w.analyze(c, l)
                }));
                match result {
                    Ok(_) => {},
                    Err(e) => {
                        println!("{:?}", e);
                    },
                };
            }
        }
    };
}