alex/winit-sonoma-fix
1
0
Fork 0
mirror of https://github.com/italicsjenga/winit-sonoma-fix.git synced 2024-12-23 22:01:31 +11:00
Code Issues Packages Projects Releases Wiki Activity

Use the shared_library crate instead of loading symbols manually

Browse source
This commit is contained in:
Pierre Krieger 2015-04-27 14:25:53 +02:00
parent 2ca9adffa0
commit 7df4de2ce7
5 changed files with 48 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -19,6 +19,7 @@ headless = []
gl_common = "*"
lazy_static = "0.1"
libc = "*"
shared_library = "0.1"
[build-dependencies]
gl_generator = "*"

23
src/api/caca/ffi.rs Normal file
View file

@ -0,0 +1,23 @@
use libc;
use std::ffi::CStr;
use std::mem;
pub type caca_display_t = libc::c_void;
pub type caca_canvas_t = libc::c_void;
pub type caca_dither_t = libc::c_void;
shared_library!(LibCaca, "libcaca.so.0",
pub fn caca_create_display(cv: *mut caca_canvas_t) -> *mut caca_display_t,
pub fn caca_free_display(dp: *mut caca_display_t) -> libc::c_int,
pub fn caca_get_canvas(dp: *mut caca_display_t) -> *mut caca_canvas_t,
pub fn caca_refresh_display(dp: *mut caca_display_t) -> libc::c_int,
pub fn caca_dither_bitmap(cv: *mut caca_canvas_t, x: libc::c_int, y: libc::c_int,
w: libc::c_int, h: libc::c_int, d: *const caca_dither_t,
pixels: *const libc::c_void) -> libc::c_int,
pub fn caca_free_dither(d: *mut caca_dither_t) -> libc::c_int,
pub fn caca_create_dither(bpp: libc::c_int, w: libc::c_int, h: libc::c_int,
pitch: libc::c_int, rmask: libc::uint32_t, gmask: libc::uint32_t,
bmask: libc::uint32_t, amask: libc::uint32_t) -> *mut caca_dither_t,
pub fn caca_get_canvas_width(cv: *mut caca_canvas_t) -> libc::c_int,
pub fn caca_get_canvas_height(cv: *mut caca_canvas_t) -> libc::c_int,
);

187
src/api/caca/libcaca.rs
View file

@ -1,187 +0,0 @@
use libc;
use std::ffi::CStr;
use std::mem;
use api::dlopen;
pub type caca_display_t = libc::c_void;
pub type caca_canvas_t = libc::c_void;
pub type caca_dither_t = libc::c_void;
pub struct LibCaca {
lib: *mut libc::c_void,
caca_create_display: unsafe extern fn(*mut caca_canvas_t) -> *mut caca_display_t,
caca_free_display: unsafe extern fn(*mut caca_display_t) -> libc::c_int,
caca_get_canvas: unsafe extern fn(*mut caca_display_t) -> *mut caca_canvas_t,
caca_refresh_display: unsafe extern fn(*mut caca_display_t) -> libc::c_int,
caca_dither_bitmap: unsafe extern fn(*mut caca_canvas_t, libc::c_int, libc::c_int, libc::c_int,
libc::c_int, *const caca_dither_t, *const libc::c_void)
-> libc::c_int,
caca_free_dither: unsafe extern fn(*mut caca_dither_t) -> libc::c_int,
caca_create_dither: unsafe extern fn(libc::c_int, libc::c_int, libc::c_int, libc::c_int,
libc::uint32_t, libc::uint32_t, libc::uint32_t,
libc::uint32_t) -> *mut caca_dither_t,
caca_get_canvas_width: unsafe extern fn(*mut caca_canvas_t) -> libc::c_int,
caca_get_canvas_height: unsafe extern fn(*mut caca_canvas_t) -> libc::c_int,
}
#[derive(Debug)]
pub struct OpenError {
reason: String
}
impl LibCaca {
pub fn open() -> Result<LibCaca, OpenError> {
let lib = unsafe { dlopen::dlopen(b"libcaca.so.0\0".as_ptr() as *const _,
dlopen::RTLD_NOW) };
if lib.is_null() {
let cstr = unsafe { CStr::from_ptr(dlopen::dlerror()) };
let reason = String::from_utf8(cstr.to_bytes().to_vec()).unwrap();
return Err(OpenError { reason: reason });
}
let caca_create_display = match unsafe { dlopen::dlsym(lib,
b"caca_create_display\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_create_display".to_string()
}),
ptr => ptr
};
let caca_free_display = match unsafe { dlopen::dlsym(lib,
b"caca_free_display\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_free_display".to_string()
}),
ptr => ptr
};
let caca_get_canvas = match unsafe { dlopen::dlsym(lib,
b"caca_get_canvas\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_get_canvas".to_string()
}),
ptr => ptr
};
let caca_refresh_display = match unsafe { dlopen::dlsym(lib,
b"caca_refresh_display\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_refresh_display".to_string()
}),
ptr => ptr
};
let caca_dither_bitmap = match unsafe { dlopen::dlsym(lib,
b"caca_dither_bitmap\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_dither_bitmap".to_string()
}),
ptr => ptr
};
let caca_free_dither = match unsafe { dlopen::dlsym(lib,
b"caca_free_dither\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_free_dither".to_string()
}),
ptr => ptr
};
let caca_create_dither = match unsafe { dlopen::dlsym(lib,
b"caca_create_dither\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_create_dither".to_string()
}),
ptr => ptr
};
let caca_get_canvas_width = match unsafe { dlopen::dlsym(lib,
b"caca_get_canvas_width\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_get_canvas_width".to_string()
}),
ptr => ptr
};
let caca_get_canvas_height = match unsafe { dlopen::dlsym(lib,
b"caca_get_canvas_height\0".as_ptr() as *const _) }
{
ptr if ptr.is_null() => return Err(OpenError {
reason: "Could not load caca_get_canvas_height".to_string()
}),
ptr => ptr
};
Ok(LibCaca {
lib: lib,
caca_create_display: unsafe { mem::transmute(caca_create_display) },
caca_free_display: unsafe { mem::transmute(caca_free_display) },
caca_get_canvas: unsafe { mem::transmute(caca_get_canvas) },
caca_refresh_display: unsafe { mem::transmute(caca_refresh_display) },
caca_dither_bitmap: unsafe { mem::transmute(caca_dither_bitmap) },
caca_free_dither: unsafe { mem::transmute(caca_free_dither) },
caca_create_dither: unsafe { mem::transmute(caca_create_dither) },
caca_get_canvas_width: unsafe { mem::transmute(caca_get_canvas_width) },
caca_get_canvas_height: unsafe { mem::transmute(caca_get_canvas_height) },
})
}
pub unsafe fn caca_create_display(&self, cv: *mut caca_canvas_t) -> *mut caca_display_t {
(self.caca_create_display)(cv)
}
pub unsafe fn caca_free_display(&self, dp: *mut caca_display_t) -> libc::c_int {
(self.caca_free_display)(dp)
}
pub unsafe fn caca_get_canvas(&self, dp: *mut caca_display_t) -> *mut caca_canvas_t {
(self.caca_get_canvas)(dp)
}
pub unsafe fn caca_refresh_display(&self, dp: *mut caca_display_t) -> libc::c_int {
(self.caca_refresh_display)(dp)
}
pub unsafe fn caca_dither_bitmap(&self, cv: *mut caca_canvas_t, x: libc::c_int, y: libc::c_int,
w: libc::c_int, h: libc::c_int, d: *const caca_dither_t,
pixels: *const libc::c_void) -> libc::c_int
{
(self.caca_dither_bitmap)(cv, x, y, w, h, d, pixels)
}
pub unsafe fn caca_free_dither(&self, d: *mut caca_dither_t) -> libc::c_int {
(self.caca_free_dither)(d)
}
pub unsafe fn caca_create_dither(&self, bpp: libc::c_int, w: libc::c_int, h: libc::c_int,
pitch: libc::c_int, rmask: libc::uint32_t, gmask: libc::uint32_t,
bmask: libc::uint32_t, amask: libc::uint32_t) -> *mut caca_dither_t
{
(self.caca_create_dither)(bpp, w, h, pitch, rmask, gmask, bmask, amask)
}
pub unsafe fn caca_get_canvas_width(&self, cv: *mut caca_canvas_t) -> libc::c_int {
(self.caca_get_canvas_width)(cv)
}
pub unsafe fn caca_get_canvas_height(&self, cv: *mut caca_canvas_t) -> libc::c_int {
(self.caca_get_canvas_height)(cv)
}
}
impl Drop for LibCaca {
fn drop(&mut self) {
unsafe { dlopen::dlclose(self.lib); }
}
}

41
src/api/caca/mod.rs
View file

@ -11,15 +11,16 @@ use CursorState;
use MouseCursor;
use std::collections::VecDeque;
use std::path::Path;
use std::ptr;
mod libcaca;
mod ffi;
pub struct Window {
libcaca: libcaca::LibCaca,
display: *mut libcaca::caca_display_t,
libcaca: ffi::LibCaca,
display: *mut ffi::caca_display_t,
opengl: OsMesaContext,
dither: *mut libcaca::caca_dither_t,
dither: *mut ffi::caca_dither_t,
}
#[derive(Clone)]
@ -83,12 +84,12 @@ impl Window {
let opengl = try!(OsMesaContext::new(builder));
let opengl_dimensions = opengl.get_dimensions();
let libcaca = match libcaca::LibCaca::open() {
let libcaca = match ffi::LibCaca::open(&Path::new("libcaca.so.0")) {
Err(_) => return Err(CreationError::NotSupported),
Ok(l) => l
};
let display = unsafe { libcaca.caca_create_display(ptr::null_mut()) };
let display = unsafe { (libcaca.caca_create_display)(ptr::null_mut()) };
if display.is_null() {
return Err(CreationError::OsError("caca_create_display failed".to_string()));
@ -101,14 +102,14 @@ impl Window {
fn get_masks() -> (u32, u32, u32, u32) { (0xff000000, 0xff0000, 0xff00, 0xff) }
let masks = get_masks();
libcaca.caca_create_dither(32, opengl_dimensions.0 as libc::c_int,
opengl_dimensions.1 as libc::c_int,
opengl_dimensions.0 as libc::c_int * 4,
masks.0, masks.1, masks.2, masks.3)
(libcaca.caca_create_dither)(32, opengl_dimensions.0 as libc::c_int,
opengl_dimensions.1 as libc::c_int,
opengl_dimensions.0 as libc::c_int * 4,
masks.0, masks.1, masks.2, masks.3)
};
if dither.is_null() {
unsafe { libcaca.caca_free_display(display) };
unsafe { (libcaca.caca_free_display)(display) };
return Err(CreationError::OsError("caca_create_dither failed".to_string()));
}
@ -182,17 +183,17 @@ impl Window {
pub fn swap_buffers(&self) {
unsafe {
let canvas = self.libcaca.caca_get_canvas(self.display);
let width = self.libcaca.caca_get_canvas_width(canvas);
let height = self.libcaca.caca_get_canvas_height(canvas);
let canvas = (self.libcaca.caca_get_canvas)(self.display);
let width = (self.libcaca.caca_get_canvas_width)(canvas);
let height = (self.libcaca.caca_get_canvas_height)(canvas);
let buffer = self.opengl.get_framebuffer().chunks(self.opengl.get_dimensions().0 as usize)
.flat_map(|i| i.iter().cloned()).rev().collect::<Vec<u32>>();
self.libcaca.caca_dither_bitmap(canvas, 0, 0, width as libc::c_int,
height as libc::c_int, self.dither,
buffer.as_ptr() as *const _);
self.libcaca.caca_refresh_display(self.display);
(self.libcaca.caca_dither_bitmap)(canvas, 0, 0, width as libc::c_int,
height as libc::c_int, self.dither,
buffer.as_ptr() as *const _);
(self.libcaca.caca_refresh_display)(self.display);
};
}
@ -234,8 +235,8 @@ impl Window {
impl Drop for Window {
fn drop(&mut self) {
unsafe {
self.libcaca.caca_free_dither(self.dither);
self.libcaca.caca_free_display(self.display);
(self.libcaca.caca_free_dither)(self.dither);
(self.libcaca.caca_free_display)(self.display);
}
}
}

3
src/lib.rs
View file

@ -26,6 +26,9 @@
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate shared_library;
extern crate gl_common;
extern crate libc;