Crate drm [−] [src]
drm-rs
drm-rs
This library is a safe interface to the Direct Rendering Manager API found on various operating systems.
This library is currently a work in progress.
Usage
The user is expected to implement their own functionality for opening and
accessing the file descriptor of the device. Here we create a small wrapper
around File
and implement AsRawFd
, drm::Device
, and
drm::control::Device
:
extern crate drm; use std::fs::{OpenOptions, File}; use std::os::unix::io::{AsRawFd, RawFd}; use drm::Device as BasicDevice; use drm::control::Device as ControlDevice; // The drm crate does not provide a method of opening the device. // It is expected to be implemented by the user. struct Card(File); // Required to implement drm::Device impl AsRawFd for Card { fn as_raw_fd(&self) -> RawFd { self.0.as_raw_fd() } } // Required to implement drm::control::Device impl BasicDevice for Card { } // Allows modesetting functionality to be performed. impl ControlDevice for Card { }
Assuming the program used the above wrapper, the user now opens the card:
// Open the device (usually located at /dev/dri/*) with rw access. let mut options = OpenOptions::new(); options.read(true); options.write(true); let file = options.open("/dev/dri/card0"); let card = Card(file);
Now we can check out what resources are available:
// Get a set of all modesetting resource handles (excluding planes): let res_handles = card.resource_handles().unwrap(); // Print all connector information for &con in res_handles.connectors() { let info = card.resource_info(con).unwrap(); println!("{:#?}") } // Print all CRTC information for &crtc in res_handles.crtcs() { let info = card.resource_info(crtc).unwrap(); println!("{:#?}") }
You'll also want to find a suitable mode:
// Assuming we found a good connector and loaded the info into `connector_info` let &mode = connector_info.modes().iter(); // Search until you find one you want.
Once you find a suitable connector and CRTC, it's time to create a framebuffer. Here we use a simple dumbbuffer as the backend:'
// Create a DB of size 1920x1080 let db = dumbbuffer::DumbBuffer::create_from_device(&card, (1920, 1080), 32) .expect("Could not create dumb buffer"); // Map it and grey it out. let mut map = db.map(&card).expect("Could not map dumbbuffer"); for mut b in map.as_mut() { *b = 128; // Grey } let fb_info = framebuffer::Info::create_from_buffer(&card, &db) let fb_handle = fb_info.handle();
Now we can apply the framebuffer onto the CRTC's internal plane, and connect it to a connector with the proper mode:
// Assuming `crtc` is a crtc handle and `con` is a connector handle crtc.set_on_device(&card, fb_handle, &[con], (0, 0), Some(mode)) .expect("Could not set Crtc");
The contents of the dumb buffer will now appear onto the screen.
Modules
buffer | |
control | |
ffi |
Foreign function interface |
result |
Error types |
Structs
AuthToken |
A token unique to the process that determines who opened the device. |
Enums
ClientCapability |
Capabilities that the process understands. |
Traits
Device |
A trait for all DRM devices. |
Type Definitions
Dimensions |
Dimensions (width, height) |
iPoint |
Signed point |
iRect |
Rectangle with a signed upper left corner |
uPoint |
Unsigned point |
uRect |
Rectangle with an unsigned upper left corner |