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
|
extern crate libc;
extern crate glib;
extern crate gobject_sys as gobject_ffi;
extern crate glib_sys as glib_ffi;
use std::ffi::CString;
use std::ptr;
use glib::translate::*;
use glib::Value;
use gobject_ffi::G_TYPE_POINTER;
#[derive(Debug)]
pub struct GeglBuffer(*mut libc::c_void);
#[repr(C)]
#[derive(Debug)]
struct GeglRectangle {
x: i32,
y: i32,
width: i32,
height: i32,
}
impl GeglBuffer {
pub fn new() -> GeglBuffer {
GeglBuffer(ptr::null_mut())
// let mut bounds = GeglRectangle{x: 0, y: 0, width: 32, height: 32};
// GeglBuffer(unsafe {
// gegl_buffer_new(&mut bounds as *mut _ as *mut libc::c_void,
// ptr::null_mut()) })
}
pub fn get_value(&self) -> Value {
unsafe {
let mut ret = Value::uninitialized();
gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
self.0 as *mut libc::c_void);
ret
}
}
pub fn get_value_ptr(&mut self) -> Value {
unsafe {
let mut ret = Value::uninitialized();
gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
&mut self.0 as *mut _ as *mut libc::c_void);
ret
}
}
}
impl Drop for GeglBuffer {
fn drop(&mut self) {
println!("Dropping geglbuffer: {:?}", self.0);
unsafe { g_object_unref(self.0); }
println!("Dropped");
}
}
#[link(name="gegl-0.3")]
extern {
fn gegl_init(argc: *mut i32, argv: *mut *mut libc::c_char);
fn gegl_node_new() -> *mut libc::c_void;
fn gegl_node_create_child(parent: *mut libc::c_void,
operation: *const libc::c_char)
-> *mut libc::c_void;
fn gegl_node_set_property(node: *mut libc::c_void,
property_name: *const libc::c_char,
value: *const libc::c_void);
fn gegl_node_link(source: *mut libc::c_void,
sink: *mut libc::c_void);
fn gegl_node_process(node: *mut libc::c_void);
fn g_object_unref(node: *mut libc::c_void);
fn gegl_exit();
fn gegl_buffer_new(extent: *mut libc::c_void, format: *mut libc::c_void)
-> *mut libc::c_void;
fn gegl_buffer_get_extent(buffer: *const libc::c_void) ->
*const GeglRectangle;
}
fn main() {
let mut graph : *mut libc::c_void;
unsafe {
let mut argc : i32 = 0;
gegl_init(&mut argc as *mut i32, ptr::null_mut());
graph = gegl_node_new();
let src = gegl_node_create_child(
graph, CString::new("gegl:load").unwrap().as_ptr());
gegl_node_set_property(
src,
CString::new("path").unwrap().as_ptr(),
Value::from("/tmp/test.jpg").to_glib_none().0
as *const libc::c_void);
let sink = gegl_node_create_child(graph,
CString::new("gegl:buffer-sink")
.unwrap().as_ptr());
let mut buffer = GeglBuffer::new();
println!("before set property: {:?}", buffer);
gegl_node_set_property(
sink,
CString::new("buffer").unwrap().as_ptr(),
buffer.get_value_ptr().to_glib_none().0 as *mut libc::c_void);
println!("before processing: {:?}", buffer);
gegl_node_link(src, sink);
gegl_node_process(sink);
println!("before extent: {:?}", buffer);
let extent = gegl_buffer_get_extent(buffer.0
as *mut libc::c_void);
println!("after extent: {:?}", buffer);
println!("height: {:?}", (*extent).height);
println!("got here");
}
unsafe {
g_object_unref(graph);
gegl_exit();
}
}
|
