From 0f2fb233e67f283867b0bd92a0d6a8d3510a7fd6 Mon Sep 17 00:00:00 2001 From: Kostya Shishkov Date: Fri, 20 Oct 2023 18:33:27 +0200 Subject: [PATCH] nihed-cros-libva: introduce more enums instead of constants --- nihed-cros-libva/src/buffer/h264.rs | 9 +- nihed-cros-libva/src/display.rs | 7 +- nihed-cros-libva/src/formats.rs | 487 ++++++++++++++++++++++++++++ nihed-cros-libva/src/lib.rs | 2 + nihed-cros-libva/src/surface.rs | 7 +- 5 files changed, 502 insertions(+), 10 deletions(-) create mode 100644 nihed-cros-libva/src/formats.rs diff --git a/nihed-cros-libva/src/buffer/h264.rs b/nihed-cros-libva/src/buffer/h264.rs index af60498..822f2ed 100644 --- a/nihed-cros-libva/src/buffer/h264.rs +++ b/nihed-cros-libva/src/buffer/h264.rs @@ -5,6 +5,7 @@ //! Wrappers around H264 `VABuffer` types. use crate::bindings; +use crate::formats::H264PictureFlags; /// Wrapper over the `VAPictureH264` FFI type. pub struct PictureH264(bindings::VAPictureH264); @@ -14,14 +15,14 @@ impl PictureH264 { pub fn new( picture_id: bindings::VASurfaceID, frame_idx: u32, - flags: u32, + flags: H264PictureFlags, top_field_order_cnt: i32, bottom_field_order_cnt: i32, ) -> Self { Self(bindings::VAPictureH264 { picture_id, frame_idx, - flags, + flags: flags.into(), TopFieldOrderCnt: top_field_order_cnt, BottomFieldOrderCnt: bottom_field_order_cnt, va_reserved: Default::default(), @@ -202,7 +203,7 @@ impl SliceParameterBufferH264 { pub fn new( slice_data_size: u32, slice_data_offset: u32, - slice_data_flag: u32, + slice_data_flag: crate::formats::VASliceDataFlag, slice_data_bit_offset: u16, first_mb_in_slice: u16, slice_type: u8, @@ -237,7 +238,7 @@ impl SliceParameterBufferH264 { Self(Box::new(bindings::VASliceParameterBufferH264 { slice_data_size, slice_data_offset, - slice_data_flag, + slice_data_flag: slice_data_flag as u32, slice_data_bit_offset, first_mb_in_slice, slice_type, diff --git a/nihed-cros-libva/src/display.rs b/nihed-cros-libva/src/display.rs index 9e7c3e0..171a733 100644 --- a/nihed-cros-libva/src/display.rs +++ b/nihed-cros-libva/src/display.rs @@ -12,6 +12,7 @@ use std::rc::Rc; use crate::bindings; use crate::config::Config; use crate::context::Context; +use crate::formats::{RTFormat, VAFourcc}; use crate::status::*; use crate::surface::Surface; use crate::UsageHints; @@ -230,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 @@ -238,8 +239,8 @@ impl Display { /// * `num_surfaces` - Number of surfaces to create pub fn create_surfaces( self: &Rc, - rt_format: u32, - va_fourcc: Option, + rt_format: RTFormat, + va_fourcc: Option, width: u32, height: u32, usage_hints: Option, diff --git a/nihed-cros-libva/src/formats.rs b/nihed-cros-libva/src/formats.rs new file mode 100644 index 0000000..a565051 --- /dev/null +++ b/nihed-cros-libva/src/formats.rs @@ -0,0 +1,487 @@ +//! Provides Rust wrappers for common enumerations used throughout the library. + +use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign}; + +use crate::bindings; + +/// Colourspace parameters. +#[repr(u32)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum RTFormat { + /// YUV 4:2:0 8-bit. + YUV420 = bindings::constants::VA_RT_FORMAT_YUV420, + /// YUV 4:2:2 8-bit. + YUV422 = bindings::constants::VA_RT_FORMAT_YUV422, + /// YUV 4:4:4 8-bit. + YUV444 = bindings::constants::VA_RT_FORMAT_YUV444, + /// YUV 4:1:1 8-bit. + YUV411 = bindings::constants::VA_RT_FORMAT_YUV411, + /// Greyscale 8-bit. + YUV400 = bindings::constants::VA_RT_FORMAT_YUV400, + /// YUV 4:2:0 10-bit. + YUV420_10 = bindings::constants::VA_RT_FORMAT_YUV420_10, + /// YUV 4:2:2 10-bit. + YUV422_10 = bindings::constants::VA_RT_FORMAT_YUV422_10, + /// YUV 4:4:4 10-bit. + YUV444_10 = bindings::constants::VA_RT_FORMAT_YUV444_10, + /// YUV 4:2:0 12-bit. + YUV420_12 = bindings::constants::VA_RT_FORMAT_YUV420_12, + /// YUV 4:2:2 12-bit. + YUV422_12 = bindings::constants::VA_RT_FORMAT_YUV422_12, + /// YUV 4:4:4 12-bit. + YUV444_12 = bindings::constants::VA_RT_FORMAT_YUV444_12, + /// Packed RGB, 16 bits per pixel. + RGB16 = bindings::constants::VA_RT_FORMAT_RGB16, + /// Packed RGB, 32 bits per pixel, 8 bits per colour sample. + RGB32 = bindings::constants::VA_RT_FORMAT_RGB32, + /// Planar RGB, 8 bits per sample. + RGBP = bindings::constants::VA_RT_FORMAT_RGBP, + /// Packed RGB, 32 bits per pixel, 10 bits per colour sample. + RGB32_10 = bindings::constants::VA_RT_FORMAT_RGB32_10, + /// Protected or unknown format. + Protected = bindings::constants::VA_RT_FORMAT_PROTECTED +} + +impl From for u32 { + fn from(val: RTFormat) -> u32 { + val as u32 + } +} + +impl From for RTFormat { + fn from(val: u32) -> RTFormat { + match val { + bindings::constants::VA_RT_FORMAT_YUV420 => RTFormat::YUV420, + bindings::constants::VA_RT_FORMAT_YUV422 => RTFormat::YUV422, + bindings::constants::VA_RT_FORMAT_YUV444 => RTFormat::YUV444, + bindings::constants::VA_RT_FORMAT_YUV411 => RTFormat::YUV411, + bindings::constants::VA_RT_FORMAT_YUV400 => RTFormat::YUV400, + bindings::constants::VA_RT_FORMAT_YUV420_10 => RTFormat::YUV420_10, + bindings::constants::VA_RT_FORMAT_YUV422_10 => RTFormat::YUV422_10, + bindings::constants::VA_RT_FORMAT_YUV444_10 => RTFormat::YUV444_10, + bindings::constants::VA_RT_FORMAT_YUV420_12 => RTFormat::YUV420_12, + bindings::constants::VA_RT_FORMAT_YUV422_12 => RTFormat::YUV422_12, + bindings::constants::VA_RT_FORMAT_YUV444_12 => RTFormat::YUV444_12, + bindings::constants::VA_RT_FORMAT_RGB16 => RTFormat::RGB16, + bindings::constants::VA_RT_FORMAT_RGB32 => RTFormat::RGB32, + bindings::constants::VA_RT_FORMAT_RGBP => RTFormat::RGBP, + bindings::constants::VA_RT_FORMAT_RGB32_10 => RTFormat::RGB32_10, + bindings::constants::VA_RT_FORMAT_PROTECTED => RTFormat::Protected, + _ => RTFormat::Protected, + } + } +} + +impl std::fmt::Display for RTFormat { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self) + } +} + +/// Recognized FOURCCs. +#[repr(u32)] +#[derive(Clone, Copy, Debug, PartialEq)] +#[allow(non_camel_case_types)] +pub enum VAFourcc { + /// NV12: two-plane 8-bit YUV 4:2:0. + /// The first plane contains Y, the second plane contains U and V in pairs of bytes. + NV12 = bindings::constants::VA_FOURCC_NV12, + /// NV21: two-plane 8-bit YUV 4:2:0. + /// Same as NV12, but with U and V swapped. + NV21 = bindings::constants::VA_FOURCC_NV21, + /// AI44: packed 4-bit YA. + /// + /// The bottom half of each byte contains luma, the top half contains alpha. + A144 = bindings::constants::VA_FOURCC_AI44, + /// RGBA: packed 8-bit RGBA. + /// + // Four bytes per pixel: red, green, blue, alpha. + RGBA = bindings::constants::VA_FOURCC_RGBA, + /// RGBX: packed 8-bit RGB. + /// + /// Four bytes per pixel: red, green, blue, unspecified. + RGBX = bindings::constants::VA_FOURCC_RGBX, + /// BGRA: packed 8-bit RGBA. + /// + /// Four bytes per pixel: blue, green, red, alpha. + BGRA = bindings::constants::VA_FOURCC_BGRA, + /// BGRX: packed 8-bit RGB. + /// + /// Four bytes per pixel: blue, green, red, unspecified. + BGRX = bindings::constants::VA_FOURCC_BGRX, + /// ARGB: packed 8-bit RGBA. + /// + /// Four bytes per pixel: alpha, red, green, blue. + ARGB = bindings::constants::VA_FOURCC_ARGB, + /// XRGB: packed 8-bit RGB. + /// + /// Four bytes per pixel: unspecified, red, green, blue. + XRGB = bindings::constants::VA_FOURCC_XRGB, + /// ABGR: packed 8-bit RGBA. + /// + /// Four bytes per pixel: alpha, blue, green, red. + ABGR = bindings::constants::VA_FOURCC_ABGR, + /// XBGR: packed 8-bit RGB. + /// + /// Four bytes per pixel: unspecified, blue, green, red. + XBGR = bindings::constants::VA_FOURCC_XBGR, + /// UYUV: packed 8-bit YUV 4:2:2. + /// + /// Four bytes per pair of pixels: U, Y, U, V. + UYVY = bindings::constants::VA_FOURCC_UYVY, + /// YUY2: packed 8-bit YUV 4:2:2. + /// + /// Four bytes per pair of pixels: Y, U, Y, V. + YUY2 = bindings::constants::VA_FOURCC_YUY2, + /// AYUV: packed 8-bit YUVA 4:4:4. + /// + /// Four bytes per pixel: A, Y, U, V. + AYUV = bindings::constants::VA_FOURCC_AYUV, + /// NV11: two-plane 8-bit YUV 4:1:1. + /// + /// The first plane contains Y, the second plane contains U and V in pairs of bytes. + NV11 = bindings::constants::VA_FOURCC_NV11, + /// YV12: three-plane 8-bit YUV 4:2:0. + /// + /// The three planes contain Y, V and U respectively. + YV12 = bindings::constants::VA_FOURCC_YV12, + /// P208: two-plane 8-bit YUV 4:2:2. + /// + /// The first plane contains Y, the second plane contains U and V in pairs of bytes. + P208 = bindings::constants::VA_FOURCC_P208, + /// I420: three-plane 8-bit YUV 4:2:0. + /// + /// The three planes contain Y, U and V respectively. + I420 = bindings::constants::VA_FOURCC_I420, + /// YV24: three-plane 8-bit YUV 4:4:4. + /// + /// The three planes contain Y, V and U respectively. + YV24 = bindings::constants::VA_FOURCC_YV24, + /// YV32: four-plane 8-bit YUVA 4:4:4 + /// + /// The four planes contain Y, V, U and A respectively. + YV32 = bindings::constants::VA_FOURCC_YV32, + /// Y800: 8-bit greyscale. + Y800 = bindings::constants::VA_FOURCC_Y800, + /// IMC3: three-plane 8-bit YUV 4:2:0. + /// + /// Equivalent to YV12, but with the additional constraint that the pitch of all three planes + /// must be the same. + IMC3 = bindings::constants::VA_FOURCC_IMC3, + /// 411P: three-plane 8-bit YUV 4:1:1. + /// + /// The three planes contain Y, U and V respectively. + YUV_411P = bindings::constants::VA_FOURCC_411P, + /// 411R: three-plane 8-bit YUV. + /// + /// The subsampling is the transpose of 4:1:1 - full chroma appears on every fourth line. + /// The three planes contain Y, U and V respectively. + YUV_411R = bindings::constants::VA_FOURCC_411R, + /// 422H: three-plane 8-bit YUV 4:2:2. + /// + /// The three planes contain Y, U and V respectively. + YUV_422H = bindings::constants::VA_FOURCC_422H, + /// 422V: three-plane 8-bit YUV 4:4:0. + /// + /// The three planes contain Y, U and V respectively. + YUV_422V = bindings::constants::VA_FOURCC_422V, + /// 444P: three-plane 8-bit YUV 4:4:4. + /// + /// The three planes contain Y, U and V respectively. + YUV_444P = bindings::constants::VA_FOURCC_444P, + /// RGBP: three-plane 8-bit RGB. + /// + /// The three planes contain red, green and blue respectively. + RGBP = bindings::constants::VA_FOURCC_RGBP, + /// BGRP: three-plane 8-bit RGB. + /// + /// The three planes contain blue, green and red respectively. + BGRP = bindings::constants::VA_FOURCC_BGRP, + /// RG16: packed 5/6-bit RGB. + /// + /// Each pixel is a two-byte little-endian value. + /// Red, green and blue are found in bits 15:11, 10:5, 4:0 respectively. + RGB565 = bindings::constants::VA_FOURCC_RGB565, + /// BG16: packed 5/6-bit RGB. + /// + /// Each pixel is a two-byte little-endian value. + /// Blue, green and red are found in bits 15:11, 10:5, 4:0 respectively. + BGR565 = bindings::constants::VA_FOURCC_BGR565, + /// Y210: packed 10-bit YUV 4:2:2. + /// + /// Eight bytes represent a pair of pixels. Each sample is a two-byte little-endian value, + /// with the bottom six bits ignored. The samples are in the order Y, U, Y, V. + Y210 = bindings::constants::VA_FOURCC_Y210, + /// Y212: packed 12-bit YUV 4:2:2. + /// + /// Eight bytes represent a pair of pixels. Each sample is a two-byte little-endian value, + /// with the bottom six bits ignored. The samples are in the order Y, U, Y, V. + Y212 = bindings::constants::VA_FOURCC_Y212, + /// Y216: packed 16-bit YUV 4:2:2. + /// + /// Eight bytes represent a pair of pixels. Each sample is a two-byte little-endian value. + /// The samples are in the order Y, U, Y, V. + Y216 = bindings::constants::VA_FOURCC_Y216, + /// Y410: packed 10-bit YUVA 4:4:4. + /// + /// Each pixel is a six-byte little-endian value. + /// A, V, Y, U are found in bits 31:30, 29:20, 19:10, 9:0 respectively. + Y410 = bindings::constants::VA_FOURCC_Y410, + /// Y412: packed 12-bit YUVA 4:4:4. + /// + /// Each pixel is a set of four samples, each of which is a two-byte little-endian value. + /// The samples are in the order A, V, Y, U. + Y412 = bindings::constants::VA_FOURCC_Y412, + /// Y416: packed 16-bit YUVA 4:4:4. + /// + /// Each pixel is a set of four samples, each of which is a two-byte little-endian value. + /// The samples are in the order A, V, Y, U. + Y416 = bindings::constants::VA_FOURCC_Y416, + /// YV16: three-plane 8-bit YUV 4:2:2. + /// + /// The three planes contain Y, V and U respectively. + YV16 = bindings::constants::VA_FOURCC_YV16, + /// P010: two-plane 10-bit YUV 4:2:0. + /// + /// Each sample is a two-byte little-endian value with the bottom six bits ignored. + /// The first plane contains Y, the second plane contains U and V in pairs of samples. + P010 = bindings::constants::VA_FOURCC_P010, + /// P012: two-plane 12-bit YUV 4:2:0. + /// + /// Each sample is a two-byte little-endian value. The first plane contains Y, the second + /// plane contains U and V in pairs of samples. + P012 = bindings::constants::VA_FOURCC_P012, + /// P016: two-plane 16-bit YUV 4:2:0. + /// + /// Each sample is a two-byte little-endian value. The first plane contains Y, the second + /// plane contains U and V in pairs of samples. + P016 = bindings::constants::VA_FOURCC_P016, + /// I010: three-plane 10-bit YUV 4:2:0. + /// + /// Each sample is a two-byte little-endian value with the top six bits ignored. + /// The three planes contain Y, V and U respectively. + I010 = bindings::constants::VA_FOURCC_I010, + /// IYUV: three-plane 8-bit YUV 4:2:0. + /// + /// @deprecated Use I420 instead. + IYUV = bindings::constants::VA_FOURCC_IYUV, + /// 10-bit Pixel RGB formats. + A2R10G10B10 = bindings::constants::VA_FOURCC_A2R10G10B10, + /// 10-bit Pixel BGR formats. + A2B10G10R10 = bindings::constants::VA_FOURCC_A2B10G10R10, + /// 10-bit Pixel RGB formats without alpha. + X2R10G10B10 = bindings::constants::VA_FOURCC_X2R10G10B10, + /// 10-bit Pixel BGR formats without alpha. + X2B10G10R10 = bindings::constants::VA_FOURCC_X2B10G10R10, + /// Y8: 8-bit greyscale. + /// + /// Only a single sample, 8 bit Y plane for monochrome images + Y8 = bindings::constants::VA_FOURCC_Y8, + /// Y16: 16-bit greyscale. + /// + /// Only a single sample, 16 bit Y plane for monochrome images + Y16 = bindings::constants::VA_FOURCC_Y16, + /// VYUV: packed 8-bit YUV 4:2:2. + /// + /// Four bytes per pair of pixels: V, Y, U, V. + VYUY = bindings::constants::VA_FOURCC_VYUY, + /// YVYU: packed 8-bit YUV 4:2:2. + /// + /// Four bytes per pair of pixels: Y, V, Y, U. + YVYU = bindings::constants::VA_FOURCC_YVYU, + /// AGRB64: three-plane 16-bit ARGB 16:16:16:16 + /// + /// The four planes contain: alpha, red, green, blue respectively. + ARGB64 = bindings::constants::VA_FOURCC_ARGB64, + /// ABGR64: three-plane 16-bit ABGR 16:16:16:16 + /// + /// The four planes contain: alpha, blue, green, red respectively. + ABGR64 = bindings::constants::VA_FOURCC_ABGR64, + /// XYUV: packed 8-bit YUVX 4:4:4. + /// + /// Four bytes per pixel: X, Y, U, V. + XYUV = bindings::constants::VA_FOURCC_XYUV, +} + +impl From for u32 { + fn from(val: VAFourcc) -> u32 { + val as u32 + } +} + +impl TryFrom for VAFourcc { + type Error = (); + fn try_from(val: u32) -> Result { + match val { + bindings::constants::VA_FOURCC_NV12 => Ok(VAFourcc::NV12), + bindings::constants::VA_FOURCC_NV21 => Ok(VAFourcc::NV21), + bindings::constants::VA_FOURCC_AI44 => Ok(VAFourcc::A144), + bindings::constants::VA_FOURCC_RGBA => Ok(VAFourcc::RGBA), + bindings::constants::VA_FOURCC_RGBX => Ok(VAFourcc::RGBX), + bindings::constants::VA_FOURCC_BGRA => Ok(VAFourcc::BGRA), + bindings::constants::VA_FOURCC_BGRX => Ok(VAFourcc::BGRX), + bindings::constants::VA_FOURCC_ARGB => Ok(VAFourcc::ARGB), + bindings::constants::VA_FOURCC_XRGB => Ok(VAFourcc::XRGB), + bindings::constants::VA_FOURCC_ABGR => Ok(VAFourcc::ABGR), + bindings::constants::VA_FOURCC_XBGR => Ok(VAFourcc::XBGR), + bindings::constants::VA_FOURCC_UYVY => Ok(VAFourcc::UYVY), + bindings::constants::VA_FOURCC_YUY2 => Ok(VAFourcc::YUY2), + bindings::constants::VA_FOURCC_AYUV => Ok(VAFourcc::AYUV), + bindings::constants::VA_FOURCC_NV11 => Ok(VAFourcc::NV11), + bindings::constants::VA_FOURCC_YV12 => Ok(VAFourcc::YV12), + bindings::constants::VA_FOURCC_P208 => Ok(VAFourcc::P208), + bindings::constants::VA_FOURCC_I420 => Ok(VAFourcc::I420), + bindings::constants::VA_FOURCC_YV24 => Ok(VAFourcc::YV24), + bindings::constants::VA_FOURCC_YV32 => Ok(VAFourcc::YV32), + bindings::constants::VA_FOURCC_Y800 => Ok(VAFourcc::Y800), + bindings::constants::VA_FOURCC_IMC3 => Ok(VAFourcc::IMC3), + bindings::constants::VA_FOURCC_411P => Ok(VAFourcc::YUV_411P), + bindings::constants::VA_FOURCC_411R => Ok(VAFourcc::YUV_411R), + bindings::constants::VA_FOURCC_422H => Ok(VAFourcc::YUV_422H), + bindings::constants::VA_FOURCC_422V => Ok(VAFourcc::YUV_422V), + bindings::constants::VA_FOURCC_444P => Ok(VAFourcc::YUV_444P), + bindings::constants::VA_FOURCC_RGBP => Ok(VAFourcc::RGBP), + bindings::constants::VA_FOURCC_BGRP => Ok(VAFourcc::BGRP), + bindings::constants::VA_FOURCC_RGB565 => Ok(VAFourcc::RGB565), + bindings::constants::VA_FOURCC_BGR565 => Ok(VAFourcc::BGR565), + bindings::constants::VA_FOURCC_Y210 => Ok(VAFourcc::Y210), + bindings::constants::VA_FOURCC_Y212 => Ok(VAFourcc::Y212), + bindings::constants::VA_FOURCC_Y216 => Ok(VAFourcc::Y216), + bindings::constants::VA_FOURCC_Y410 => Ok(VAFourcc::Y410), + bindings::constants::VA_FOURCC_Y412 => Ok(VAFourcc::Y412), + bindings::constants::VA_FOURCC_Y416 => Ok(VAFourcc::Y416), + bindings::constants::VA_FOURCC_YV16 => Ok(VAFourcc::YV16), + bindings::constants::VA_FOURCC_P010 => Ok(VAFourcc::P010), + bindings::constants::VA_FOURCC_P012 => Ok(VAFourcc::P012), + bindings::constants::VA_FOURCC_P016 => Ok(VAFourcc::P016), + bindings::constants::VA_FOURCC_I010 => Ok(VAFourcc::I010), + bindings::constants::VA_FOURCC_IYUV => Ok(VAFourcc::IYUV), + bindings::constants::VA_FOURCC_A2R10G10B10 => Ok(VAFourcc::A2R10G10B10), + bindings::constants::VA_FOURCC_A2B10G10R10 => Ok(VAFourcc::A2B10G10R10), + bindings::constants::VA_FOURCC_X2R10G10B10 => Ok(VAFourcc::X2R10G10B10), + bindings::constants::VA_FOURCC_X2B10G10R10 => Ok(VAFourcc::X2B10G10R10), + bindings::constants::VA_FOURCC_Y8 => Ok(VAFourcc::Y8), + bindings::constants::VA_FOURCC_Y16 => Ok(VAFourcc::Y16), + bindings::constants::VA_FOURCC_VYUY => Ok(VAFourcc::VYUY), + bindings::constants::VA_FOURCC_YVYU => Ok(VAFourcc::YVYU), + bindings::constants::VA_FOURCC_ARGB64 => Ok(VAFourcc::ARGB64), + bindings::constants::VA_FOURCC_ABGR64 => Ok(VAFourcc::ABGR64), + bindings::constants::VA_FOURCC_XYUV => Ok(VAFourcc::XYUV), + _ => Err(()), + } + } +} + +/// H.264 picture flags structure. +#[derive(Default, Clone, Copy, Debug, PartialEq)] +pub struct H264PictureFlags(u32); + +impl H264PictureFlags { + /// Returns picture flags value as 32-bit integer. + pub fn bits(self) -> u32 { + self.0 + } +} + +impl From for u32 { + fn from(val: H264PictureFlags) -> u32 { + val.bits() + } +} + +impl BitOr for H264PictureFlags { + type Output = Self; + + fn bitor(self, rhs: H264PictureFlag) -> Self { + Self(self.0 | rhs.bits()) + } +} + +impl BitOrAssign for H264PictureFlags { + fn bitor_assign(&mut self, rhs: H264PictureFlag) { + self.0 |= rhs.bits(); + } +} + +impl BitXor for H264PictureFlags { + type Output = Self; + + fn bitxor(self, rhs: H264PictureFlag) -> Self { + Self(self.0 ^ rhs.bits()) + } +} + +impl BitXorAssign for H264PictureFlags { + fn bitxor_assign(&mut self, rhs: H264PictureFlag) { + self.0 ^= rhs.bits(); + } +} + +impl BitAnd for H264PictureFlags { + type Output = Self; + + fn bitand(self, rhs: H264PictureFlag) -> Self { + Self(self.0 & rhs.bits()) + } +} + +impl BitAndAssign for H264PictureFlags { + fn bitand_assign(&mut self, rhs: H264PictureFlag) { + self.0 &= rhs.bits(); + } +} + +/// H.264 picture property flags. +#[repr(u32)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum H264PictureFlag { + /// Picture is invalid. + Invalid = bindings::constants::VA_PICTURE_H264_INVALID, + /// Top field present. + TopField = bindings::constants::VA_PICTURE_H264_TOP_FIELD, + /// Bottom field present. + BottomField = bindings::constants::VA_PICTURE_H264_BOTTOM_FIELD, + /// Picture is used as a short-term reference. + ShortTermReference = bindings::constants::VA_PICTURE_H264_SHORT_TERM_REFERENCE, + /// Picture is used as a short-term reference. + LongTermReference = bindings::constants::VA_PICTURE_H264_LONG_TERM_REFERENCE, +} + +impl From for H264PictureFlags { + fn from(val: H264PictureFlag) -> Self { + Self(val.bits()) + } +} + +impl From for u32 { + fn from(val: H264PictureFlag) -> u32 { + val.bits() + } +} + +impl H264PictureFlag { + pub(crate) fn bits(self) -> u32 { + self as u32 + } +} + +/// Slice data contents type. +/// +/// There will be cases where the bitstream buffer will not have enough room to hold +/// the data for the entire slice, and the following flags will be used in the slice +/// parameter to signal to the server for the possible cases. +/// If a slice parameter buffer and slice data buffer pair is sent to the server with +/// the slice data partially in the slice data buffer (BEGIN and MIDDLE cases below), +/// then a slice parameter and data buffer needs to be sent again to complete this slice. +#[repr(u32)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum VASliceDataFlag { + /// Whole slice is in the buffer. + All = bindings::constants::VA_SLICE_DATA_FLAG_ALL, + /// The beginning of the slice is in the buffer but the end if not. + Begin = bindings::constants::VA_SLICE_DATA_FLAG_BEGIN, + /// Neither beginning nor end of the slice is in the buffer. + Middle = bindings::constants::VA_SLICE_DATA_FLAG_MIDDLE, + /// End of the slice is in the buffer. + End = bindings::constants::VA_SLICE_DATA_FLAG_END, +} diff --git a/nihed-cros-libva/src/lib.rs b/nihed-cros-libva/src/lib.rs index 953b57c..61f03c8 100644 --- a/nihed-cros-libva/src/lib.rs +++ b/nihed-cros-libva/src/lib.rs @@ -14,6 +14,7 @@ pub mod buffer; mod config; mod context; mod display; +mod formats; mod generic_value; mod image; mod picture; @@ -33,6 +34,7 @@ pub use buffer::*; pub use config::*; pub use context::*; pub use display::*; +pub use formats::*; pub use generic_value::*; pub use image::*; pub use picture::*; diff --git a/nihed-cros-libva/src/surface.rs b/nihed-cros-libva/src/surface.rs index fe11749..2a77a39 100644 --- a/nihed-cros-libva/src/surface.rs +++ b/nihed-cros-libva/src/surface.rs @@ -6,6 +6,7 @@ use std::rc::Rc; use crate::bindings; use crate::display::Display; +use crate::formats::{RTFormat, VAFourcc}; use crate::status::*; use crate::UsageHints; @@ -22,8 +23,8 @@ impl Surface { /// [`Display::create_surfaces`]. pub(crate) fn new( display: Rc, - rt_format: u32, - va_fourcc: Option, + rt_format: RTFormat, + va_fourcc: Option, width: u32, height: u32, usage_hints: Option, @@ -67,7 +68,7 @@ impl Surface { (unsafe { bindings::vaCreateSurfaces( display.handle(), - rt_format, + rt_format.into(), width, height, surfaces.as_mut_ptr(), -- 2.39.5