drm 0.3.4

Safe, low-level bindings to the Direct Rendering Manager API
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

//!
//! # DumbBuffer
//!
//! Memory-supported, slow, but easy & cross-platform buffer implementation
//!

use ffi;
use result::*;
use control;
use buffer;

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
/// Slow, but generic `Buffer` implementation
pub struct DumbBuffer {
    size: (u32, u32),
    length: usize,
    format: buffer::PixelFormat,
    pitch: u32,
    handle: buffer::Id,
}

/// Mapping of a dumbbuffer
pub struct DumbMapping<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
    map: &'a mut [u8],
}

impl DumbBuffer {
    /// Create a new dumb buffer with a given size and pixel format
    pub fn create_from_device<T>(
        device: &T,
        size: (u32, u32),
        format: buffer::PixelFormat,
    ) -> Result<Self>
    where
        T: control::Device,
    {
        let mut raw: ffi::drm_mode_create_dumb = Default::default();
        raw.width = size.0;
        raw.height = size.1;
        raw.bpp = try!(
            format
                .bpp()
                .ok_or(Error::from_kind(ErrorKind::UnsupportedPixelFormat))
        ) as u32;

        unsafe {
            try!(ffi::ioctl_mode_create_dumb(device.as_raw_fd(), &mut raw));
        }

        let dumb = Self {
            size: (raw.width, raw.height),
            length: raw.size as usize,
            format: format,
            pitch: raw.pitch,
            handle: buffer::Id::from_raw(raw.handle),
        };

        Ok(dumb)
    }

    /// Free the memory resources of a dumb buffer
    pub fn destroy<T>(self, device: &T) -> Result<()>
    where
        T: control::Device,
    {
        let mut raw: ffi::drm_mode_destroy_dumb = Default::default();
        raw.handle = self.handle.as_raw();

        unsafe {
            try!(ffi::ioctl_mode_destroy_dumb(device.as_raw_fd(), &mut raw));
        }

        Ok(())
    }

    /// Map the buffer for access
    pub fn map<'a, T>(&'a mut self, device: &T) -> Result<DumbMapping<'a>>
    where
        T: control::Device,
    {
        let mut raw: ffi::drm_mode_map_dumb = Default::default();
        raw.handle = self.handle.as_raw();

        unsafe {
            try!(ffi::ioctl_mode_map_dumb(device.as_raw_fd(), &mut raw));
        }

        let map = {
            use nix::sys::mman;
            let addr = ::std::ptr::null_mut();
            let prot = mman::PROT_READ | mman::PROT_WRITE;
            let flags = mman::MAP_SHARED;
            let length = self.length;
            let fd = device.as_raw_fd();
            let offset = raw.offset as i64;
            try!(mman::mmap(addr, length, prot, flags, fd, offset))
        };

        let mapping = DumbMapping {
            _phantom: ::std::marker::PhantomData,
            map: unsafe { ::std::slice::from_raw_parts_mut(map as *mut _, self.length) },
        };

        Ok(mapping)
    }
}

impl<'a> AsMut<[u8]> for DumbMapping<'a> {
    fn as_mut(&mut self) -> &mut [u8] {
        self.map
    }
}

impl<'a> Drop for DumbMapping<'a> {
    fn drop(&mut self) {
        use nix::sys::mman;

        mman::munmap(self.map.as_mut_ptr() as *mut _, self.map.len()).expect("Unmap failed");
    }
}

impl buffer::Buffer for DumbBuffer {
    fn size(&self) -> (u32, u32) {
        self.size
    }
    fn format(&self) -> buffer::PixelFormat {
        self.format
    }
    fn pitch(&self) -> u32 {
        self.pitch
    }
    fn handle(&self) -> buffer::Id {
        self.handle
    }
}