[go: up one dir, main page]

gbm 0.0.0

High-level access to libgbm.
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

mod ffi;

use std::fs::File;
use std::os::unix::io::AsRawFd;
use std::sync::{Mutex, MutexGuard};
use std::os::raw::c_void;


pub struct Device<'a> {
    file: &'a File,
    raw: ffi::GbmDevice
}

impl<'a> AsRef<File> for Device<'a> {
    fn as_ref(&self) -> &File {
        self.file
    }
}

impl<'a> Device<'a> {
    pub fn from_file(file: &'a File) -> Device<'a> {
        Device {
            file: file,
            raw: ffi::GbmDevice::new(file.as_raw_fd())
        }
    }

    pub fn buffer(&'a self, size: (u32, u32), format: u32, flags: u32) -> Buffer<'a> {
        let (width, height) = size;
        Buffer {
            device: self,
            raw: ffi::GbmBufferObject::new(&self.raw, width, height, format, flags)
        }
    }
}

pub struct Surface<'a> {
    device: &'a Device<'a>,
    raw: ffi::GbmSurface,
    front_lock: Mutex<()>
}

impl<'a> Surface<'a> {
    pub fn from_device(device: &'a Device, width: u32, height: u32, format: u32, flags: u32) -> Surface<'a> {
        Surface {
            device: device,
            raw: ffi::GbmSurface::new(&device.raw, width, height, format, flags),
            front_lock: Mutex::new(())
        }
    }

    pub fn lock_front_buffer(&'a self) -> FrontBuffer<'a> {
        let guard = self.front_lock.lock();
        FrontBuffer {
            surface: self,
            raw: ffi::GbmFrontBufferObject::lock(&self.raw),
            _guard: guard.unwrap()
        }
    }

}

pub struct Buffer<'a> {
    device: &'a Device<'a>,
    raw: ffi::GbmBufferObject
}

impl<'a> Buffer<'a> {
    pub unsafe fn set_user_data(&self, data: *mut c_void) {
        self.raw.set_user_data(data);
    }
}

pub struct FrontBuffer<'a> {
    surface: &'a Surface<'a>,
    raw: ffi::GbmFrontBufferObject,
    _guard: MutexGuard<'a, ()>
}

impl<'a> FrontBuffer<'a> {
    pub unsafe fn set_user_data(&self, data: *mut c_void) {
        self.raw.set_user_data(data);
    }
}

impl<'a> Drop for FrontBuffer<'a> {
    fn drop(&mut self) {
        self.raw.release(&self.surface.raw);
    }
}