libdrm_amdgpu_sys 0.8.16

libdrm_amdgpu bindings for Rust, and some methods ported from Mesa3D.
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
137
138
139
140
141
142
143
144
145
146

use crate::*;
use crate::AMDGPU::*;
use core::mem::{size_of, MaybeUninit};
pub use bindings::{drm_amdgpu_info_video_caps, drm_amdgpu_info_video_codec_info};

#[derive(Debug, Clone, Copy)]
pub struct VideoCapsInfo {
    pub cap_type: CAP_TYPE,
    pub mpeg2: Option<drm_amdgpu_info_video_codec_info>,
    pub mpeg4: Option<drm_amdgpu_info_video_codec_info>,
    pub vc1: Option<drm_amdgpu_info_video_codec_info>,
    pub mpeg4_avc: Option<drm_amdgpu_info_video_codec_info>,
    pub hevc: Option<drm_amdgpu_info_video_codec_info>,
    pub jpeg: Option<drm_amdgpu_info_video_codec_info>,
    pub vp9: Option<drm_amdgpu_info_video_codec_info>,
    pub av1: Option<drm_amdgpu_info_video_codec_info>,
}

impl From<(&CAP_TYPE, &drm_amdgpu_info_video_caps)> for VideoCapsInfo {
    fn from(caps: (&CAP_TYPE, &drm_amdgpu_info_video_caps)) -> Self {
        let (cap_type, video_caps) = caps;
        let [mpeg2, mpeg4, vc1, mpeg4_avc, hevc, jpeg, vp9, av1] = CODEC::LIST
            .map(|codec| {
                let info = video_caps.get_codec_info(codec);

                (info.valid != 0).then_some(info)
            });

        Self {
            cap_type: *cap_type,
            mpeg2,
            mpeg4,
            vc1,
            mpeg4_avc,
            hevc,
            jpeg,
            vp9,
            av1,
        }
    }
}

impl DeviceHandle {
    pub fn get_video_caps_info(&self, cap_type: CAP_TYPE) -> Result<VideoCapsInfo, i32> {
        let cap = self.get_video_caps(cap_type)?;

        Ok(VideoCapsInfo::from((&cap_type, &cap)))
    }
}

use bindings::{
    AMDGPU_INFO_VIDEO_CAPS_DECODE,
    AMDGPU_INFO_VIDEO_CAPS_ENCODE,
};

/// Used for [DeviceHandle::get_video_caps]
#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum CAP_TYPE {
    DECODE = AMDGPU_INFO_VIDEO_CAPS_DECODE,
    ENCODE = AMDGPU_INFO_VIDEO_CAPS_ENCODE,
}

impl DeviceHandle {
    pub fn get_video_caps(&self, type_: CAP_TYPE) -> Result<drm_amdgpu_info_video_caps, i32> {
        #[cfg(not(feature = "dynamic_loading"))]
        let func = bindings::amdgpu_query_video_caps_info;
        #[cfg(feature = "dynamic_loading")]
        let func = self.libdrm_amdgpu.amdgpu_query_video_caps_info;

        unsafe {
            let mut video_caps: MaybeUninit<drm_amdgpu_info_video_caps> = MaybeUninit::zeroed();

            let r = func(
                self.amdgpu_dev,
                type_ as u32,
                size_of::<drm_amdgpu_info_video_caps>() as u32,
                video_caps.as_mut_ptr() as *mut ::core::ffi::c_void,
            );

            let video_caps = video_caps.assume_init();

            query_error!(r);

            Ok(video_caps)
        }
    }
}

impl drm_amdgpu_info_video_caps {
    pub fn get_codec_info(&self, codec: CODEC) -> drm_amdgpu_info_video_codec_info {
        self.codec_info[codec as usize]
    }
}

use bindings::{
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG2,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VC1,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4_AVC,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_HEVC,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_JPEG,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VP9,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_AV1,
    AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_COUNT,
};

/// Used for [drm_amdgpu_info_video_caps::get_codec_info]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd)]
#[repr(u32)]
pub enum CODEC {
    MPEG2 = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG2,
    MPEG4 = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4,
    VC1 = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VC1,
    MPEG4_AVC = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4_AVC,
    HEVC = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_HEVC,
    JPEG = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_JPEG,
    VP9 = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VP9,
    AV1 = AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_AV1,
}

impl CODEC {
    pub const LIST: [Self; AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_COUNT as usize] = [
        Self::MPEG2,
        Self::MPEG4,
        Self::VC1,
        Self::MPEG4_AVC,
        Self::HEVC,
        Self::JPEG,
        Self::VP9,
        Self::AV1,
    ];
}

use std::fmt;
impl fmt::Display for CODEC {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl drm_amdgpu_info_video_codec_info {
    pub fn is_supported(&self) -> bool {
        self.valid != 0
    }
}