X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihed-cros-libva%2Fsrc%2Fdisplay.rs;h=171a73347b491102316ea64b25ae10f6c2abac3e;hb=8006218d420a403957a15ee49e0610f39d24d511;hp=462bc3e8db1dcb154b14bf8026fa06ea579f4842;hpb=683627242f69bed0b818d976d4b03d651e529697;p=nihav-player.git

diff --git a/nihed-cros-libva/src/display.rs b/nihed-cros-libva/src/display.rs
index 462bc3e..171a733 100644
--- a/nihed-cros-libva/src/display.rs
+++ b/nihed-cros-libva/src/display.rs
@@ -9,16 +9,13 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::rc::Rc;
 
-use anyhow::anyhow;
-use anyhow::Context as AnyhowContext;
-use anyhow::Result;
-
 use crate::bindings;
 use crate::config::Config;
 use crate::context::Context;
-use crate::status::Status;
+use crate::formats::{RTFormat, VAFourcc};
+use crate::status::*;
 use crate::surface::Surface;
-use crate::UsageHint;
+use crate::UsageHints;
 
 /// Iterates over existing DRM devices.
 ///
@@ -80,29 +77,26 @@ impl Display {
     /// Opens and initializes a specific DRM `Display`.
     ///
     /// `path` is the path to a DRM device that supports VAAPI, e.g. `/dev/dri/renderD128`.
-    pub fn open_drm_display<P: AsRef<Path>>(path: P) -> Result<Rc<Self>> {
+    pub fn open_drm_display<P: AsRef<Path>>(path: P) -> VAResult<Rc<Self>> {
         let file = std::fs::File::options()
             .read(true)
             .write(true)
             .open(path.as_ref())
-            .context(format!("failed to open {}", path.as_ref().display()))?;
+            .map_err(|_| VAError::InvalidValue)?;
 
         // Safe because fd represents a valid file descriptor and the pointer is checked for
         // NULL afterwards.
         let display = unsafe { bindings::vaGetDisplayDRM(file.as_raw_fd()) };
         if display.is_null() {
             // The File will close the DRM fd on drop.
-            return Err(anyhow!(
-                "failed to obtain VA display from DRM device {}",
-                path.as_ref().display()
-            ));
+            return Err(VAError::InvalidDisplay);
         }
 
         let mut major = 0i32;
         let mut minor = 0i32;
         // Safe because we ensure that the display is valid (i.e not NULL) before calling
         // vaInitialize. The File will close the DRM fd on drop.
-        Status(unsafe { bindings::vaInitialize(display, &mut major, &mut minor) }).check()?;
+        (unsafe { bindings::vaInitialize(display, &mut major, &mut minor) }).check()?;
 
         Ok(Rc::new(Self {
             handle: display,
@@ -133,14 +127,14 @@ impl Display {
     }
 
     /// Queries supported profiles by this display.
-    pub fn query_config_profiles(&self) -> Result<Vec<bindings::VAProfile::Type>> {
+    pub fn query_config_profiles(&self) -> VAResult<Vec<bindings::VAProfile::Type>> {
         // Safe because `self` represents a valid VADisplay.
         let mut max_num_profiles = unsafe { bindings::vaMaxNumProfiles(self.handle) };
         let mut profiles = Vec::with_capacity(max_num_profiles as usize);
 
         // Safe because `self` represents a valid `VADisplay` and the vector has `max_num_profiles`
         // as capacity.
-        Status(unsafe {
+        (unsafe {
             bindings::vaQueryConfigProfiles(
                 self.handle,
                 profiles.as_mut_ptr(),
@@ -182,14 +176,14 @@ impl Display {
     pub fn query_config_entrypoints(
         &self,
         profile: bindings::VAProfile::Type,
-    ) -> Result<Vec<bindings::VAEntrypoint::Type>> {
+    ) -> VAResult<Vec<bindings::VAEntrypoint::Type>> {
         // Safe because `self` represents a valid VADisplay.
         let mut max_num_entrypoints = unsafe { bindings::vaMaxNumEntrypoints(self.handle) };
         let mut entrypoints = Vec::with_capacity(max_num_entrypoints as usize);
 
         // Safe because `self` represents a valid VADisplay and the vector has `max_num_entrypoints`
         // as capacity.
-        Status(unsafe {
+        (unsafe {
             bindings::vaQueryConfigEntrypoints(
                 self.handle,
                 profile,
@@ -218,10 +212,10 @@ impl Display {
         profile: bindings::VAProfile::Type,
         entrypoint: bindings::VAEntrypoint::Type,
         attributes: &mut [bindings::VAConfigAttrib],
-    ) -> Result<()> {
+    ) -> VAResult<()> {
         // Safe because `self` represents a valid VADisplay. The slice length is passed to the C
         // function, so it is impossible to write past the end of the slice's storage by mistake.
-        Status(unsafe {
+        (unsafe {
             bindings::vaGetConfigAttributes(
                 self.handle,
                 profile,
@@ -237,7 +231,7 @@ impl Display {
     ///
     /// # Arguments
     ///
-    /// * `rt_format` - The desired surface format. See `VA_RT_FORMAT_*`
+    /// * `rt_format` - The desired surface format.
     /// * `va_fourcc` - The desired pixel format (optional). See `VA_FOURCC_*`
     /// * `width` - Width for the create surfaces
     /// * `height` - Height for the created surfaces
@@ -245,20 +239,20 @@ impl Display {
     /// * `num_surfaces` - Number of surfaces to create
     pub fn create_surfaces(
         self: &Rc<Self>,
-        rt_format: u32,
-        va_fourcc: Option<u32>,
+        rt_format: RTFormat,
+        va_fourcc: Option<VAFourcc>,
         width: u32,
         height: u32,
-        usage_hint: Option<UsageHint>,
+        usage_hints: Option<UsageHints>,
         num_surfaces: u32,
-    ) -> Result<Vec<Surface>> {
+    ) -> VAResult<Vec<Surface>> {
         Surface::new(
             Rc::clone(self),
             rt_format,
             va_fourcc,
             width,
             height,
-            usage_hint,
+            usage_hints,
             num_surfaces,
         )
     }
@@ -279,7 +273,7 @@ impl Display {
         coded_height: i32,
         surfaces: Option<&Vec<Surface>>,
         progressive: bool,
-    ) -> Result<Rc<Context>> {
+    ) -> VAResult<Rc<Context>> {
         Context::new(
             Rc::clone(self),
             config,
@@ -301,12 +295,12 @@ impl Display {
         attrs: Vec<bindings::VAConfigAttrib>,
         profile: bindings::VAProfile::Type,
         entrypoint: bindings::VAEntrypoint::Type,
-    ) -> Result<Config> {
+    ) -> VAResult<Config> {
         Config::new(Rc::clone(self), attrs, profile, entrypoint)
     }
 
     /// Returns available image formats for this display by wrapping around `vaQueryImageFormats`.
-    pub fn query_image_formats(&self) -> Result<Vec<bindings::VAImageFormat>> {
+    pub fn query_image_formats(&self) -> VAResult<Vec<bindings::VAImageFormat>> {
         // Safe because `self` represents a valid VADisplay.
         let mut num_image_formats = unsafe { bindings::vaMaxNumImageFormats(self.handle) };
         let mut image_formats = Vec::with_capacity(num_image_formats as usize);
@@ -314,7 +308,7 @@ impl Display {
         // Safe because `self` represents a valid VADisplay. The `image_formats` vector is properly
         // initialized and a valid size is passed to the C function, so it is impossible to write
         // past the end of their storage by mistake.
-        Status(unsafe {
+        (unsafe {
             bindings::vaQueryImageFormats(
                 self.handle,
                 image_formats.as_mut_ptr(),