1 // Copyright 2022 The ChromiumOS Authors 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 //! Wrappers and helpers around `VABuffer`s. 6 7 mod av1; 8 mod enc_misc; 9 mod h264; 10 mod hevc; 11 mod mpeg2; 12 mod vp8; 13 mod vp9; 14 15 pub use av1::*; 16 pub use enc_misc::*; 17 pub use h264::*; 18 pub use hevc::*; 19 pub use mpeg2::*; 20 pub use vp8::*; 21 pub use vp9::*; 22 23 use std::rc::Rc; 24 25 use log::error; 26 27 use crate::bindings; 28 use crate::va_check; 29 use crate::Context; 30 use crate::VaError; 31 32 /// Wrapper type representing a buffer created with `vaCreateBuffer`. 33 pub struct Buffer { 34 context: Rc<Context>, 35 id: bindings::VABufferID, 36 } 37 38 impl Buffer { 39 /// Creates a new buffer by wrapping a `vaCreateBuffer` call. This is just a helper for 40 /// [`Context::create_buffer`]. new(context: Rc<Context>, mut type_: BufferType) -> Result<Self, VaError>41 pub(crate) fn new(context: Rc<Context>, mut type_: BufferType) -> Result<Self, VaError> { 42 let mut buffer_id = 0; 43 44 /* we send all slices parameters as a single array in H264, AV1 */ 45 let nb_elements = match type_ { 46 BufferType::SliceParameter(SliceParameter::H264(ref mut params)) => { 47 params.inner_mut().len() 48 } 49 BufferType::SliceParameter(SliceParameter::AV1(ref mut params)) => { 50 params.inner_mut().len() 51 } 52 _ => 1, 53 }; 54 55 let (ptr, size) = match type_ { 56 BufferType::PictureParameter(ref mut picture_param) => match picture_param { 57 PictureParameter::MPEG2(ref mut wrapper) => ( 58 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 59 std::mem::size_of_val(wrapper.inner_mut()), 60 ), 61 PictureParameter::VP8(ref mut wrapper) => ( 62 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 63 std::mem::size_of_val(wrapper.inner_mut()), 64 ), 65 PictureParameter::VP9(ref mut wrapper) => ( 66 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 67 std::mem::size_of_val(wrapper.inner_mut()), 68 ), 69 PictureParameter::H264(ref mut wrapper) => ( 70 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 71 std::mem::size_of_val(wrapper.inner_mut()), 72 ), 73 PictureParameter::HEVC(ref mut wrapper) => ( 74 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 75 std::mem::size_of_val(wrapper.inner_mut()), 76 ), 77 PictureParameter::HEVCRext(ref mut wrapper) => ( 78 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 79 std::mem::size_of_val(wrapper.inner_mut()), 80 ), 81 PictureParameter::HEVCScc(ref mut wrapper) => ( 82 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 83 std::mem::size_of_val(wrapper.inner_mut()), 84 ), 85 PictureParameter::AV1(ref mut wrapper) => ( 86 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 87 std::mem::size_of_val(wrapper.inner_mut()), 88 ), 89 }, 90 91 BufferType::SliceParameter(ref mut slice_param) => match slice_param { 92 SliceParameter::MPEG2(ref mut wrapper) => ( 93 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 94 std::mem::size_of_val(wrapper.inner_mut()), 95 ), 96 SliceParameter::VP8(ref mut wrapper) => ( 97 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 98 std::mem::size_of_val(wrapper.inner_mut()), 99 ), 100 SliceParameter::VP9(ref mut wrapper) => ( 101 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 102 std::mem::size_of_val(wrapper.inner_mut()), 103 ), 104 SliceParameter::H264(ref mut wrapper) => ( 105 wrapper.inner_mut().as_mut_ptr() as *mut std::ffi::c_void, 106 std::mem::size_of::<bindings::VASliceParameterBufferH264>(), 107 ), 108 SliceParameter::HEVC(ref mut wrapper) => ( 109 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 110 std::mem::size_of_val(wrapper.inner_mut()), 111 ), 112 SliceParameter::HEVCRext(ref mut wrapper) => ( 113 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 114 std::mem::size_of_val(wrapper.inner_mut()), 115 ), 116 SliceParameter::AV1(ref mut wrapper) => ( 117 wrapper.inner_mut().as_mut_ptr() as *mut std::ffi::c_void, 118 std::mem::size_of::<bindings::VASliceParameterBufferAV1>(), 119 ), 120 }, 121 122 BufferType::IQMatrix(ref mut iq_matrix) => match iq_matrix { 123 IQMatrix::MPEG2(ref mut wrapper) => ( 124 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 125 std::mem::size_of_val(wrapper.inner_mut()), 126 ), 127 IQMatrix::VP8(ref mut wrapper) => ( 128 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 129 std::mem::size_of_val(wrapper.inner_mut()), 130 ), 131 IQMatrix::H264(ref mut wrapper) => ( 132 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 133 std::mem::size_of_val(wrapper.inner_mut()), 134 ), 135 IQMatrix::HEVC(ref mut wrapper) => ( 136 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 137 std::mem::size_of_val(wrapper.inner_mut()), 138 ), 139 }, 140 141 BufferType::Probability(ref mut wrapper) => ( 142 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 143 std::mem::size_of_val(wrapper.inner_mut()), 144 ), 145 146 BufferType::SliceData(ref mut data) => { 147 (data.as_mut_ptr() as *mut std::ffi::c_void, data.len()) 148 } 149 150 BufferType::EncSequenceParameter(ref mut seq_param) => match seq_param { 151 EncSequenceParameter::H264(ref mut wrapper) => ( 152 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 153 std::mem::size_of_val(wrapper.inner_mut()), 154 ), 155 EncSequenceParameter::HEVC(ref mut wrapper) => ( 156 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 157 std::mem::size_of_val(wrapper.inner_mut()), 158 ), 159 EncSequenceParameter::VP8(ref mut wrapper) => ( 160 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 161 std::mem::size_of_val(wrapper.inner_mut()), 162 ), 163 EncSequenceParameter::VP9(ref mut wrapper) => ( 164 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 165 std::mem::size_of_val(wrapper.inner_mut()), 166 ), 167 EncSequenceParameter::AV1(ref mut wrapper) => ( 168 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 169 std::mem::size_of_val(wrapper.inner_mut()), 170 ), 171 }, 172 173 BufferType::EncPictureParameter(ref mut picture_param) => match picture_param { 174 EncPictureParameter::H264(ref mut wrapper) => ( 175 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 176 std::mem::size_of_val(wrapper.inner_mut()), 177 ), 178 EncPictureParameter::HEVC(ref mut wrapper) => ( 179 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 180 std::mem::size_of_val(wrapper.inner_mut()), 181 ), 182 EncPictureParameter::VP8(ref mut wrapper) => ( 183 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 184 std::mem::size_of_val(wrapper.inner_mut()), 185 ), 186 EncPictureParameter::VP9(ref mut wrapper) => ( 187 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 188 std::mem::size_of_val(wrapper.inner_mut()), 189 ), 190 EncPictureParameter::AV1(ref mut wrapper) => ( 191 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 192 std::mem::size_of_val(wrapper.inner_mut()), 193 ), 194 }, 195 196 BufferType::EncSliceParameter(ref mut slice_param) => match slice_param { 197 EncSliceParameter::H264(ref mut wrapper) => ( 198 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 199 std::mem::size_of_val(wrapper.inner_mut()), 200 ), 201 EncSliceParameter::HEVC(ref mut wrapper) => ( 202 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 203 std::mem::size_of_val(wrapper.inner_mut()), 204 ), 205 EncSliceParameter::AV1(ref mut wrapper) => ( 206 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 207 std::mem::size_of_val(wrapper.inner_mut()), 208 ), 209 }, 210 211 BufferType::EncMacroblockParameterBuffer(ref mut mb_param) => match mb_param { 212 EncMacroblockParameterBuffer::H264(ref mut wrapper) => ( 213 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 214 std::mem::size_of_val(wrapper.inner_mut()), 215 ), 216 }, 217 218 BufferType::EncCodedBuffer(size) => (std::ptr::null_mut(), size), 219 220 BufferType::EncMiscParameter(ref mut enc_misc_param) => match enc_misc_param { 221 EncMiscParameter::FrameRate(ref mut wrapper) => ( 222 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 223 std::mem::size_of_val(wrapper.inner_mut()), 224 ), 225 EncMiscParameter::RateControl(ref mut wrapper) => ( 226 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 227 std::mem::size_of_val(wrapper.inner_mut()), 228 ), 229 EncMiscParameter::MaxSliceSize(ref mut wrapper) => ( 230 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 231 std::mem::size_of_val(wrapper.inner_mut()), 232 ), 233 EncMiscParameter::MaxFrameSize(ref mut wrapper) => ( 234 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 235 std::mem::size_of_val(wrapper.inner_mut()), 236 ), 237 EncMiscParameter::SkipFrame(ref mut wrapper) => ( 238 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 239 std::mem::size_of_val(wrapper.inner_mut()), 240 ), 241 EncMiscParameter::HRD(ref mut wrapper) => ( 242 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 243 std::mem::size_of_val(wrapper.inner_mut()), 244 ), 245 EncMiscParameter::QualityLevel(ref mut wrapper) => ( 246 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 247 std::mem::size_of_val(wrapper.inner_mut()), 248 ), 249 EncMiscParameter::Quantization(ref mut wrapper) => ( 250 wrapper.inner_mut() as *mut _ as *mut std::ffi::c_void, 251 std::mem::size_of_val(wrapper.inner_mut()), 252 ), 253 }, 254 }; 255 256 // Safe because `self` represents a valid `VAContext`. `ptr` and `size` are also ensured to 257 // be correct, as `ptr` is just a cast to `*c_void` from a Rust struct, and `size` is 258 // computed from `std::mem::size_of_val`. 259 va_check(unsafe { 260 bindings::vaCreateBuffer( 261 context.display().handle(), 262 context.id(), 263 type_.inner(), 264 size as u32, 265 nb_elements as u32, 266 ptr, 267 &mut buffer_id, 268 ) 269 })?; 270 271 Ok(Self { 272 context, 273 id: buffer_id, 274 }) 275 } 276 277 /// Convenience function to return a `VABufferID` vector from a slice of `Buffer`s in order to 278 /// easily interface with the C API where a buffer array might be needed. as_id_vec(buffers: &[Self]) -> Vec<bindings::VABufferID>279 pub fn as_id_vec(buffers: &[Self]) -> Vec<bindings::VABufferID> { 280 buffers.iter().map(|buffer| buffer.id).collect() 281 } 282 } 283 284 impl Drop for Buffer { drop(&mut self)285 fn drop(&mut self) { 286 // Safe because `self` represents a valid buffer, created with 287 // vaCreateBuffers. 288 let status = va_check(unsafe { 289 bindings::vaDestroyBuffer(self.context.display().handle(), self.id) 290 }); 291 292 if status.is_err() { 293 error!("vaDestroyBuffer failed: {}", status.unwrap_err()); 294 } 295 } 296 } 297 298 /// Abstraction over `VABufferType`s. 299 pub enum BufferType { 300 /// Abstraction over `VAPictureParameterBufferType`. Needed for MPEG2, VP8, VP9, H264. 301 PictureParameter(PictureParameter), 302 /// Abstraction over `VASliceParameterBufferType`. Needed for MPEG2, VP8, VP9, H264. 303 SliceParameter(SliceParameter), 304 /// Abstraction over `VAIQMatrixBufferType`. Needed for VP8, H264. 305 IQMatrix(IQMatrix), 306 /// Abstraction over `VAProbabilityDataBufferType`. Needed for VP8. 307 Probability(vp8::ProbabilityDataBufferVP8), 308 /// Abstraction over `VASliceDataBufferType`. Needed for VP9, H264. 309 SliceData(Vec<u8>), 310 /// Abstraction over `VAEncSequenceParameterBufferType`. Needed for MPEG2, VP8, VP9, H264, HEVC. 311 EncSequenceParameter(EncSequenceParameter), 312 /// Abstraction over `VAEncPictureParameterBufferType`. Needed for MPEG2, VP8, VP9, H264, HEVC. 313 EncPictureParameter(EncPictureParameter), 314 /// Abstraction over `VAEncSliceParameterBufferType`. Needed for MPEG2, VP8, VP9, H264, HEVC. 315 EncSliceParameter(EncSliceParameter), 316 /// Abstraction over `VAEncMacroblockMapBufferType`. Needed for H264. 317 EncMacroblockParameterBuffer(EncMacroblockParameterBuffer), 318 /// Abstraction over `VAEncCodedBufferType`. Needed for MPEG2, VP8, VP9, H264, HEVC. 319 EncCodedBuffer(usize), 320 /// Abstraction over `VAEncMiscParameterBuffer`. 321 EncMiscParameter(EncMiscParameter), 322 } 323 324 impl BufferType { 325 /// Returns the inner FFI buffer type. inner(&self) -> bindings::VABufferType::Type326 pub(crate) fn inner(&self) -> bindings::VABufferType::Type { 327 match self { 328 BufferType::PictureParameter(_) => bindings::VABufferType::VAPictureParameterBufferType, 329 BufferType::SliceParameter(_) => bindings::VABufferType::VASliceParameterBufferType, 330 BufferType::IQMatrix(_) => bindings::VABufferType::VAIQMatrixBufferType, 331 BufferType::Probability(_) => bindings::VABufferType::VAProbabilityBufferType, 332 BufferType::SliceData { .. } => bindings::VABufferType::VASliceDataBufferType, 333 334 BufferType::EncSequenceParameter(_) => { 335 bindings::VABufferType::VAEncSequenceParameterBufferType 336 } 337 338 BufferType::EncPictureParameter(_) => { 339 bindings::VABufferType::VAEncPictureParameterBufferType 340 } 341 342 BufferType::EncSliceParameter(_) => { 343 bindings::VABufferType::VAEncSliceParameterBufferType 344 } 345 346 BufferType::EncMacroblockParameterBuffer(_) => { 347 bindings::VABufferType::VAEncMacroblockMapBufferType 348 } 349 350 BufferType::EncCodedBuffer(_) => bindings::VABufferType::VAEncCodedBufferType, 351 352 BufferType::EncMiscParameter(_) => bindings::VABufferType::VAEncMiscParameterBufferType, 353 } 354 } 355 } 356 357 /// Abstraction over the `PictureParameterBuffer` types we support. 358 pub enum PictureParameter { 359 /// Wrapper over VAPictureParameterBufferMPEG2. 360 MPEG2(mpeg2::PictureParameterBufferMPEG2), 361 /// Wrapper over VAPictureParameterBufferVP8. 362 VP8(vp8::PictureParameterBufferVP8), 363 /// Wrapper over VAPictureParameterBufferVP9. 364 VP9(vp9::PictureParameterBufferVP9), 365 /// Wrapper over VAPictureParameterBufferH264. 366 H264(h264::PictureParameterBufferH264), 367 /// Wrapper over VAPictureParameterBufferHEVC 368 HEVC(hevc::PictureParameterBufferHEVC), 369 /// Wrapper over VAPictureParameterBufferHEVCRext 370 HEVCRext(hevc::PictureParameterBufferHEVCRext), 371 /// Wrapper over VAPictureParameterBufferHEVCScc 372 HEVCScc(hevc::PictureParameterBufferHEVCScc), 373 /// Wrapper over VADecPictureParameterBufferAV1 374 AV1(av1::PictureParameterBufferAV1), 375 } 376 377 /// Abstraction over the `SliceParameterBuffer` types we support 378 pub enum SliceParameter { 379 /// Wrapper over VASliceParameterBufferMPEG2 380 MPEG2(mpeg2::SliceParameterBufferMPEG2), 381 /// Wrapper over VASliceParameterBufferVP8 382 VP8(vp8::SliceParameterBufferVP8), 383 /// Wrapper over VASliceParameterBufferVP9 384 VP9(vp9::SliceParameterBufferVP9), 385 /// Wrapper over VASliceParameterBufferH264 386 H264(h264::SliceParameterBufferH264), 387 /// Wrapper over VASliceParameterBufferHEVC 388 HEVC(hevc::SliceParameterBufferHEVC), 389 /// Wrapper over VASliceParameterBufferHEVCRext 390 HEVCRext(hevc::SliceParameterBufferHEVCRext), 391 /// Wrapper over VASliceParameterBufferAV1 392 AV1(av1::SliceParameterBufferAV1), 393 } 394 395 /// Abstraction over the `IQMatrixBuffer` types we support. 396 pub enum IQMatrix { 397 /// Abstraction over `VAIQMatrixBufferMPEG2` 398 MPEG2(mpeg2::IQMatrixBufferMPEG2), 399 /// Abstraction over `VAIQMatrixBufferVP8` 400 VP8(vp8::IQMatrixBufferVP8), 401 /// Abstraction over `VAIQMatrixBufferH264` 402 H264(h264::IQMatrixBufferH264), 403 /// Abstraction over `VAIQMatrixBufferHEVC` 404 HEVC(hevc::IQMatrixBufferHEVC), 405 } 406 407 /// Abstraction over the `EncSequenceParameter` types we support. 408 pub enum EncSequenceParameter { 409 /// Abstraction over `VAEncSequenceParameterBufferH264` 410 H264(h264::EncSequenceParameterBufferH264), 411 /// Abstraction over `VAEncSequenceParameterBufferHEVC` 412 HEVC(hevc::EncSequenceParameterBufferHEVC), 413 /// Abstraction over `VAEncSequenceParameterBufferVP8` 414 VP8(vp8::EncSequenceParameterBufferVP8), 415 /// Abstraction over `VAEncSequenceParameterBufferVP9` 416 VP9(vp9::EncSequenceParameterBufferVP9), 417 /// Abstraction over `VAEncSequenceParameterBufferAV1` 418 AV1(av1::EncSequenceParameterBufferAV1), 419 } 420 421 /// Abstraction over the `EncPictureParameter` types we support. 422 pub enum EncPictureParameter { 423 /// Abstraction over `VAEncPictureParameterBufferH264` 424 H264(h264::EncPictureParameterBufferH264), 425 /// Abstraction over `VAEncPictureParameterBufferHEVC` 426 HEVC(hevc::EncPictureParameterBufferHEVC), 427 /// Abstraction over `VAEncPictureParameterBufferVP8` 428 VP8(vp8::EncPictureParameterBufferVP8), 429 /// Abstraction over `VAEncPictureParameterBufferVP9` 430 VP9(vp9::EncPictureParameterBufferVP9), 431 /// Abstraction over `VAEncPictureParameterBufferAV1` 432 AV1(av1::EncPictureParameterBufferAV1), 433 } 434 435 /// Abstraction over the `EncSliceParameter` types we support. 436 pub enum EncSliceParameter { 437 /// Abstraction over `VAEncSliceParameterBufferH264` 438 H264(h264::EncSliceParameterBufferH264), 439 /// Abstraction over `VAEncSliceParameterBufferHEVC` 440 HEVC(hevc::EncSliceParameterBufferHEVC), 441 /// Abstraction over `VAEncTileGroupBufferAV1` 442 AV1(av1::EncTileGroupBufferAV1), 443 } 444 445 /// Abstraction over the `EncMacroblockParameterBuffer` types we support. 446 pub enum EncMacroblockParameterBuffer { 447 /// Abstraction over `VAEncMacroblockParameterBufferH264` 448 H264(h264::EncMacroblockParameterBufferH264), 449 } 450 451 /// Wrapper type representing a buffer created with `vaCreateBuffer` with VAEncCodedBufferType. 452 pub struct EncCodedBuffer(Buffer); 453 454 impl EncCodedBuffer { new(context: Rc<Context>, size: usize) -> Result<Self, VaError>455 pub(crate) fn new(context: Rc<Context>, size: usize) -> Result<Self, VaError> { 456 Ok(Self(Buffer::new( 457 context, 458 BufferType::EncCodedBuffer(size), 459 )?)) 460 } 461 462 /// Convenience function to return buffer's `VABufferID`. id(&self) -> bindings::VABufferID463 pub fn id(&self) -> bindings::VABufferID { 464 self.0.id 465 } 466 } 467 468 /// Helper to access a single segment of mapped coded buffer 469 pub struct MappedCodedSegment<'s> { 470 pub bit_offset: u32, 471 pub status: u32, 472 pub buf: &'s [u8], 473 } 474 475 /// Helper to access segments of mapped coded buffer 476 pub struct MappedCodedBuffer<'p> { 477 segments: Vec<MappedCodedSegment<'p>>, 478 buffer: &'p EncCodedBuffer, 479 } 480 481 impl<'p> MappedCodedBuffer<'p> { 482 /// Map a 'VAEncCodedBufferType' buffer. new(buffer: &'p EncCodedBuffer) -> Result<Self, VaError>483 pub fn new(buffer: &'p EncCodedBuffer) -> Result<Self, VaError> { 484 let mut addr = std::ptr::null_mut(); 485 let mut segments = Vec::new(); 486 487 va_check(unsafe { 488 bindings::vaMapBuffer(buffer.0.context.display().handle(), buffer.id(), &mut addr) 489 })?; 490 491 while !addr.is_null() { 492 let segment: &bindings::VACodedBufferSegment = 493 unsafe { &*(addr as *const bindings::VACodedBufferSegment) }; 494 495 let size = segment.size; 496 let buf = segment.buf; 497 498 let buf = unsafe { std::slice::from_raw_parts(buf as *mut u8, size as usize) }; 499 500 segments.push(MappedCodedSegment { 501 bit_offset: segment.bit_offset, 502 status: segment.status, 503 buf, 504 }); 505 506 addr = segment.next; 507 } 508 509 Ok(Self { segments, buffer }) 510 } 511 512 /// Returns the iterator over segments iter(&self) -> impl Iterator<Item = &MappedCodedSegment<'p>>513 pub fn iter(&self) -> impl Iterator<Item = &MappedCodedSegment<'p>> { 514 self.segments.iter() 515 } 516 517 /// Returns the segments of mapped coded buffers. segments(&self) -> &Vec<MappedCodedSegment<'p>>518 pub fn segments(&self) -> &Vec<MappedCodedSegment<'p>> { 519 &self.segments 520 } 521 } 522 523 impl<'p> Drop for MappedCodedBuffer<'p> { drop(&mut self)524 fn drop(&mut self) { 525 let status = va_check(unsafe { 526 bindings::vaUnmapBuffer(self.buffer.0.context.display().handle(), self.buffer.id()) 527 }); 528 529 if status.is_err() { 530 error!("vaUnmapBuffer failed: {}", status.unwrap_err()); 531 } 532 } 533 } 534 535 /// Abstraction over the `EncMiscParameterBuffer` types we support. 536 pub enum EncMiscParameter { 537 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterFrameRate`. 538 FrameRate(EncMiscParameterFrameRate), 539 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterRateControl`. 540 RateControl(EncMiscParameterRateControl), 541 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterMaxSliceSize`. 542 MaxSliceSize(EncMiscParameterMaxSliceSize), 543 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterBufferMaxFrameSize`. 544 MaxFrameSize(EncMiscParameterBufferMaxFrameSize), 545 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterSkipFrame`. 546 SkipFrame(EncMiscParameterSkipFrame), 547 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterHRD`. 548 HRD(EncMiscParameterHRD), 549 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterBufferQualityLevel`. 550 QualityLevel(EncMiscParameterBufferQualityLevel), 551 /// Wrapper over `VAEncMiscParameterBuffer` with `VAEncMiscParameterQuantization`. 552 Quantization(EncMiscParameterQuantization), 553 } 554