projects / nihav-player.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hwdec_vaapi: ignore high-profile extradata tail when it is not correct
[nihav-player.git] / hwdec-vaapi / src / lib.rs
CommitLineData
e5ccd68d
KS		 1use std::collections::VecDeque;
2use std::convert::TryInto;
3use std::rc::Rc;
4
5use nihav_core::codecs::*;
6use nihav_core::io::byteio::*;
7use nihav_core::io::bitreader::*;
8use nihav_core::io::intcode::*;
9
10use libva::*;
11
12#[cfg(debug_assertions)]
13macro_rules! validate {
14 ($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DecoderError::InvalidData); } };
15}
16#[cfg(not(debug_assertions))]
17macro_rules! validate {
18 ($a:expr) => { if !$a { return Err(DecoderError::InvalidData); } };
19}
20
21mod pic_ref;
22pub use pic_ref::*;
23#[allow(clippy::manual_range_contains)]
24#[allow(clippy::needless_range_loop)]
25mod sets;
26use sets::*;
27#[allow(clippy::manual_range_contains)]
28mod slice;
29use slice::*;
30
31trait ReadUE {
32 fn read_ue(&mut self) -> DecoderResult<u32>;
33 fn read_te(&mut self, range: u32) -> DecoderResult<u32>;
34 fn read_ue_lim(&mut self, max_val: u32) -> DecoderResult<u32> {
35 let val = self.read_ue()?;
36 validate!(val <= max_val);
37 Ok(val)
38 }
39 fn read_se(&mut self) -> DecoderResult<i32> {
40 let val = self.read_ue()?;
41 if (val & 1) != 0 {
42 Ok (((val >> 1) as i32) + 1)
43 } else {
44 Ok (-((val >> 1) as i32))
45 }
46 }
47}
48
49impl<'a> ReadUE for BitReader<'a> {
50 fn read_ue(&mut self) -> DecoderResult<u32> {
51 Ok(self.read_code(UintCodeType::GammaP)? - 1)
52 }
53 fn read_te(&mut self, range: u32) -> DecoderResult<u32> {
54 if range == 1 {
55 if self.read_bool()? {
56 Ok(0)
57 } else {
58 Ok(1)
59 }
60 } else {
61 let val = self.read_ue()?;
62 validate!(val <= range);
63 Ok(val)
64 }
65 }
66}
67
68fn get_long_term_id(is_idr: bool, slice_hdr: &SliceHeader) -> Option<usize> {
69 if is_idr && !slice_hdr.long_term_reference {
70 None
71 } else {
72 let marking = &slice_hdr.adaptive_ref_pic_marking;
73 for (&op, &arg) in marking.memory_management_control_op.iter().zip(marking.operation_arg.iter()).take(marking.num_ops) {
74 if op == 6 {
75 return Some(arg as usize);
76 }
77 }
78 None
79 }
80}
81
82fn unescape_nal(src: &[u8], dst: &mut Vec<u8>) -> usize {
83 let mut off = 0;
84 let mut zrun = 0;
85 dst.clear();
86 dst.reserve(src.len());
87 while off < src.len() {
88 dst.push(src[off]);
89 if src[off] != 0 {
90 zrun = 0;
91 } else {
92 zrun += 1;
93 if zrun == 2 && off + 1 < src.len() && src[off + 1] == 0x03 {
94 zrun = 0;
95 off += 1;
96 }
97 if zrun >= 3 && off + 1 < src.len() && src[off + 1] == 0x01 {
98 off -= 3;
99 dst.truncate(off);
100 break;
101 }
102 }
103 off += 1;
104 }
105 off
106}
107
108fn make_dummy_h264_pic() -> PictureH264 {
109 PictureH264::new(VA_INVALID_ID, 0, H264PictureFlag::Invalid.into(), 0, 0)
110}
111
112trait MakePicH264 {
113 fn make_pic(&self) -> PictureH264;
114}
115
116impl MakePicH264 for PictureInfo {
117 fn make_pic(&self) -> PictureH264 {
118 let mut flags = H264PictureFlags::default();
119 let frame_idx = if let Some(id) = self.long_term {
120 flags |= H264PictureFlag::LongTermReference;
121 id as u32
122 } else {
123 if self.is_ref {
124 flags |= H264PictureFlag::ShortTermReference;
125 }
126 u32::from(self.id)
127 };
128 PictureH264::new(self.surface_id, frame_idx, flags, self.top_id as i32, self.bot_id as i32)
129 }
130}
131
132fn map_ref_list(refs: &[Option<PictureInfo>]) -> [PictureH264; 32] {
133 let mut ref_list = Vec::with_capacity(32);
134
135 for rpic in refs.iter() {
136 ref_list.push(rpic.as_ref().map_or_else(make_dummy_h264_pic, |pic| pic.make_pic()));
137 }
138
139 while ref_list.len() < 32 {
140 ref_list.push(make_dummy_h264_pic());
141 }
142 if let Ok(ret) = ref_list.try_into() {
143 ret
144 } else {
145 panic!("can't convert");
146 }
147}
148
149fn profile_name(profile: VAProfile::Type) -> &'static str {
150 match profile {
151 VAProfile::VAProfileMPEG2Simple => "MPEG2 Simple",
152 VAProfile::VAProfileMPEG2Main => "MPEG2 Main",
153 VAProfile::VAProfileMPEG4Simple => "MPEG4 Simple",
154 VAProfile::VAProfileMPEG4AdvancedSimple => "MPEG4 Advanced Simple",
155 VAProfile::VAProfileMPEG4Main => "MPEG4 Main",
156 VAProfile::VAProfileH264Baseline => "H264 Baseline",
157 VAProfile::VAProfileH264Main => "H264 Main",
158 VAProfile::VAProfileH264High => "H264 High",
159 VAProfile::VAProfileVC1Simple => "VC1 Simple",
160 VAProfile::VAProfileVC1Main => "VC1 Main",
161 VAProfile::VAProfileVC1Advanced => "VC1 Advanced",
162 VAProfile::VAProfileH263Baseline => "H263 Baseline",
163 VAProfile::VAProfileJPEGBaseline => "JPEG Baseline",
164 VAProfile::VAProfileH264ConstrainedBaseline => "H264 Constrained Baseline",
165 VAProfile::VAProfileVP8Version0_3 => "VP8",
166 VAProfile::VAProfileH264MultiviewHigh => "H.264 Multiview High",
167 VAProfile::VAProfileH264StereoHigh => "H264 Stereo High",
168 VAProfile::VAProfileHEVCMain => "H.EVC Main",
169 VAProfile::VAProfileHEVCMain10 => "H.EVC Main10",
170 VAProfile::VAProfileVP9Profile0 => "VP9 Profile 0",
171 VAProfile::VAProfileVP9Profile1 => "VP9 Profile 1",
172 VAProfile::VAProfileVP9Profile2 => "VP9 Profile 2",
173 VAProfile::VAProfileVP9Profile3 => "VP9 Profile 3",
174 VAProfile::VAProfileHEVCMain12 => "HEVC Main12",
175 VAProfile::VAProfileHEVCMain422_10 => "HEVC Main10 4:2:2",
176 VAProfile::VAProfileHEVCMain422_12 => "HEVC Main12 4:2:2",
177 VAProfile::VAProfileHEVCMain444 => "HEVC Main 4:4:4",
178 VAProfile::VAProfileHEVCMain444_10 => "HEVC Main10 4:4:4",
179 VAProfile::VAProfileHEVCMain444_12 => "HEVC Main12 4:4:4",
180 VAProfile::VAProfileHEVCSccMain => "HEVC SCC Main",
181 VAProfile::VAProfileHEVCSccMain10 => "HEVC SCC Main10",
182 VAProfile::VAProfileHEVCSccMain444 => "HEVC SCC Main 4:4:4",
183 VAProfile::VAProfileAV1Profile0 => "AV1 Profile 0",
184 VAProfile::VAProfileAV1Profile1 => "AV1 Profile 1",
185 VAProfile::VAProfileHEVCSccMain444_10 => "HEVC SCC Main10 4:4:4",
186 _ => "unknown",
187 }
188}
189
190const NUM_REF_PICS: usize = 16;
191
192struct WaitingFrame {
193 ts: u64,
194 pic: Picture<PictureEnd>,
195 is_idr: bool,
196 is_ref: bool,
197 ftype: FrameType,
198}
199
200struct Reorderer {
201 last_ref_dts: Option<u64>,
202 ready_idx: usize,
203 frames: VecDeque<WaitingFrame>,
204}
205
206impl Default for Reorderer {
207 fn default() -> Self {
208 Self {
209 last_ref_dts: None,
210 ready_idx: 0,
211 frames: VecDeque::with_capacity(16),
212 }
213 }
214}
215
216impl Reorderer {
217 fn add_frame(&mut self, new_frame: WaitingFrame) {
218 if !new_frame.is_ref {
219 if self.frames.is_empty() {
220 self.frames.push_back(new_frame);
221 } else {
222 let new_dts = new_frame.ts;
223 let mut idx = 0;
224 for (i, frm) in self.frames.iter().enumerate() {
225 idx = i;
226 if frm.ts > new_dts {
227 break;
228 }
229 }
230 self.frames.insert(idx, new_frame);
231 }
232 } else {
233 for (i, frm) in self.frames.iter().enumerate() {
234 if Some(frm.ts) == self.last_ref_dts {
235 self.ready_idx = i + 1;
236 }
237 }
238 self.last_ref_dts = Some(new_frame.ts);
239 self.frames.push_back(new_frame);
240 }
241 }
242 fn get_frame(&mut self) -> Option<WaitingFrame> {
243 if self.ready_idx > 0 {
244 match self.frames[0].pic.query_status() {
245 _ if self.ready_idx > 16 => {},
246 Ok(VASurfaceStatus::Ready) => {},
247 Ok(VASurfaceStatus::Rendering) => return None,
248 _ => {
249 unimplemented!();
250 },
251 };
252 self.ready_idx -= 1;
253 self.frames.pop_front()
254 } else {
255 None
256 }
257 }
258 fn flush(&mut self) {
259 self.last_ref_dts = None;
260 self.ready_idx = 0;
261 }
262}
263
264#[allow(dead_code)]
265struct VaapiInternals {
266 display: Rc<Display>,
267 context: Rc<Context>,
268 ref_pics: Vec<(Picture<PictureSync>, VASurfaceID)>,
269 surfaces: Vec<Surface>,
270 ifmt: VAImageFormat,
271}
272
273pub struct VaapiH264Decoder {
274 info: NACodecInfoRef,
275 vaapi: Option<VaapiInternals>,
276 spses: Vec<SeqParameterSet>,
277 ppses: Vec<PicParameterSet>,
278 frame_refs: FrameRefs,
279 nal_len: u8,
280 out_frm: NABufferType,
281 reorderer: Reorderer,
282 tb_num: u32,
283 tb_den: u32,
284}
285
a439fb0b
KS		 286#[cfg(not(target_arch="x86_64"))]
287fn deint_chroma(frm: NASimpleVideoFrame<u8>, src: &[u8], sstride: usize) {
288 let mut uoff = frm.offset[1];
289 let mut voff = frm.offset[2];
290 for cline in src.chunks(sstride).take(frm.height[1]) {
291 for (x, pair) in cline.chunks_exact(2).take(frm.width[1]).enumerate() {
292 frm.data[uoff + x] = pair[0];
293 frm.data[voff + x] = pair[1];
294 }
295 uoff += frm.stride[1];
296 voff += frm.stride[2];
297 }
298}
299
300#[cfg(target_arch="x86_64")]
301use std::arch::asm;
302#[cfg(target_arch="x86_64")]
303fn deint_chroma(frm: NASimpleVideoFrame<u8>, src: &[u8], sstride: usize) {
304 unsafe {
305 let width = frm.width[1];
306 let height = frm.height[1];
307 let dst = frm.data.as_mut_ptr();
308 let udst = dst.add(frm.offset[1]);
309 let vdst = dst.add(frm.offset[2]);
310 let dstep = frm.stride[1] - width;
311 let sstep = sstride - width * 2;
312 asm!(
313 "2:",
314 " mov {tmp}, {width}",
315 " test {width}, 8",
316 " jz 3f",
317 " movaps xmm0, [{src}]",
318 " movaps xmm1, xmm0",
319 " psllw xmm0, 8",
320 " psrlw xmm1, 8",
321 " psrlw xmm0, 8",
322 " packuswb xmm1, xmm1",
323 " packuswb xmm0, xmm0",
324 " movq [{vdst}], xmm1",
325 " movq [{udst}], xmm0",
326 " add {src}, 16",
327 " add {vdst}, 8",
328 " add {udst}, 8",
329 " sub {tmp}, 8",
330 " 3:",
331 " movaps xmm0, [{src}]",
332 " movaps xmm1, [{src} + 16]",
333 " movaps xmm2, xmm0",
334 " movaps xmm3, xmm1",
335 " psllw xmm0, 8",
336 " psllw xmm1, 8",
337 " psrlw xmm2, 8",
338 " psrlw xmm3, 8",
339 " psrlw xmm0, 8",
340 " psrlw xmm1, 8",
341 " packuswb xmm2, xmm3",
342 " packuswb xmm0, xmm1",
343 " movups [{vdst}], xmm2",
344 " movups [{udst}], xmm0",
345 " add {src}, 32",
346 " add {vdst}, 16",
347 " add {udst}, 16",
348 " sub {tmp}, 16",
349 " jnz 3b",
350 " add {udst}, {dstep}",
351 " add {vdst}, {dstep}",
352 " add {src}, {sstep}",
353 " dec {height}",
354 " jnz 2b",
355 src = inout(reg) src.as_ptr() => _,
356 udst = inout(reg) udst => _,
357 vdst = inout(reg) vdst => _,
358 width = in(reg) width,
359 height = inout(reg) height => _,
360 dstep = in(reg) dstep,
361 sstep = in(reg) sstep,
362 tmp = out(reg) _,
363 out("xmm0") _,
364 out("xmm1") _,
365 out("xmm2") _,
366 out("xmm3") _,
367 );
368 }
369}
370
e5ccd68d
KS		 371fn fill_frame(ifmt: VAImageFormat, pic: &Picture<PictureSync>, frm: &mut NABufferType) -> DecoderResult<()> {
372 let mut vbuf = frm.get_vbuf().unwrap();
373 let (w, h) = pic.surface_size();
374 //let cur_ts = pic.timestamp();
375
376 let img = Image::new(pic, ifmt, w, h, true).expect("get image");
377
378 let iimg = img.image();
379 let imgdata: &[u8] = img.as_ref();
380
381 match iimg.format.fourcc().map_err(|_| DecoderError::InvalidData)? {
382 VAFourcc::NV12 => {
383 let frm = NASimpleVideoFrame::from_video_buf(&mut vbuf).unwrap();
384 validate!(iimg.width == (frm.width[0] as u16));
385 validate!(iimg.height == (frm.height[0] as u16));
386
387 for (dline, sline) in frm.data[frm.offset[0]..].chunks_mut(frm.stride[0])
388 .zip(imgdata[iimg.offsets[0] as usize..].chunks(iimg.pitches[0] as usize))
389 .take(frm.height[0]) {
390 dline[..frm.width[0]].copy_from_slice(&sline[..frm.width[0]]);
391 }
392
a439fb0b 393 deint_chroma(frm, &imgdata[iimg.offsets[1] as usize..], iimg.pitches[1] as usize);
e5ccd68d
KS		 394 },
395 _ => unimplemented!(),
396 };
397 Ok(())
398}
399
400impl Default for VaapiH264Decoder {
401 fn default() -> Self {
402 Self {
403 info: NACodecInfoRef::default(),
404 vaapi: None,
405 spses: Vec::with_capacity(1),
406 ppses: Vec::with_capacity(4),
407 frame_refs: FrameRefs::new(),
408 nal_len: 0,
409 out_frm: NABufferType::None,
410 reorderer: Reorderer::default(),
411 tb_num: 0,
412 tb_den: 0,
413 }
414 }
415}
416
417impl VaapiH264Decoder {
418 pub fn new() -> Self { Self::default() }
419 pub fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {
420 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
421 let edata = info.get_extradata().unwrap();
422//print!("edata:"); for &el in edata.iter() { print!(" {:02X}", el); } println!();
423 let profile;
424 let mut nal_buf = Vec::with_capacity(1024);
425 if edata.len() > 11 && &edata[0..4] == b"avcC" {
426 let mut mr = MemoryReader::new_read(edata.as_slice());
427 let mut br = ByteReader::new(&mut mr);
428
429 br.read_skip(4)?;
430 let version = br.read_byte()?;
431 validate!(version == 1);
432 profile = br.read_byte()?;
433 let _compatibility = br.read_byte()?;
434 let _level = br.read_byte()?;
435 let b = br.read_byte()?;
436 validate!((b & 0xFC) == 0xFC);
437 self.nal_len = (b & 3) + 1;
438 let b = br.read_byte()?;
439 validate!((b & 0xE0) == 0xE0);
440 let num_sps = (b & 0x1F) as usize;
441 for _ in 0..num_sps {
442 let len = br.read_u16be()? as usize;
443 let offset = br.tell() as usize;
444 validate!((br.peek_byte()? & 0x1F) == 7);
445 let _size = unescape_nal(&edata[offset..][..len], &mut nal_buf);
446 br.read_skip(len)?;
447 let sps = parse_sps(&nal_buf[1..])?;
448 self.spses.push(sps);
449 }
450 let num_pps = br.read_byte()? as usize;
451 for _ in 0..num_pps {
452 let len = br.read_u16be()? as usize;
453 let offset = br.tell() as usize;
454 validate!((br.peek_byte()? & 0x1F) == 8);
455 let _size = unescape_nal(&edata[offset..][..len], &mut nal_buf);
456 br.read_skip(len)?;
457 let src = &nal_buf;
458
459 let mut full_size = src.len() * 8;
460 for &byte in src.iter().rev() {
461 if byte == 0 {
462 full_size -= 8;
463 } else {
464 full_size -= (byte.trailing_zeros() + 1) as usize;
465 break;
466 }
467 }
468 validate!(full_size > 0);
469
470 let pps = parse_pps(&src[1..], &self.spses, full_size - 8)?;
471 let mut found = false;
472 for stored_pps in self.ppses.iter_mut() {
473 if stored_pps.pic_parameter_set_id == pps.pic_parameter_set_id {
474 *stored_pps = pps.clone();
475 found = true;
476 break;
477 }
478 }
479 if !found {
480 self.ppses.push(pps);
481 }
482 }
483 if br.left() > 0 {
484 match profile {
485 100 | 110 | 122 | 144 => {
486 let b = br.read_byte()?;
bf56f153
KS		 487 // some encoders put something different here
488 if (b & 0xFC) != 0xFC {
489 return Ok(());
490 }
e5ccd68d
KS		 491 // b & 3 -> chroma format
492 let b = br.read_byte()?;
493 validate!((b & 0xF8) == 0xF8);
494 // b & 7 -> luma depth minus 8
495 let b = br.read_byte()?;
496 validate!((b & 0xF8) == 0xF8);
497 // b & 7 -> chroma depth minus 8
498 let num_spsext = br.read_byte()? as usize;
499 for _ in 0..num_spsext {
500 let len = br.read_u16be()? as usize;
501 // parse spsext
502 br.read_skip(len)?;
503 }
504 },
505 _ => {},
506 };
507 }
508 } else {
509 return Err(DecoderError::NotImplemented);
510 }
511
512 validate!(profile > 0);
513 let width = (vinfo.get_width() + 15) & !15;
514 let height = (vinfo.get_height() + 15) & !15;
515
516 let display = Display::open_silently().expect("open display");
517
518 let num_surfaces = self.spses[0].num_ref_frames + 4 + 64;
519
520 let va_profile = match profile {
521 66 => VAProfile::VAProfileH264ConstrainedBaseline,
522 77 => VAProfile::VAProfileH264Main,
523 88 | 100 | 110 | 122 => VAProfile::VAProfileH264High,
524 _ => return Err(DecoderError::NotImplemented),
525 };
526 if let Ok(profiles) = display.query_config_profiles() {
527 if !profiles.contains(&va_profile) {
528println!("Profile {} ({}) not supported", profile, profile_name(va_profile));
529 return Err(DecoderError::NotImplemented);
530 }
531 } else {
532 return Err(DecoderError::Bug);
533 }
534 if let Ok(points) = display.query_config_entrypoints(va_profile) {
535 if !points.contains(&VAEntrypoint::VAEntrypointVLD) {
536println!("no decoding support for this profile");
537 return Err(DecoderError::NotImplemented);
538 }
539 } else {
540 return Err(DecoderError::Bug);
541 }
542
543 let config = display.create_config(vec![
544 VAConfigAttrib { type_: VAConfigAttribType::VAConfigAttribRTFormat, value: RTFormat::YUV420.into() },
545 ], va_profile, VAEntrypoint::VAEntrypointVLD).map_err(|_| {
546println!("config creation failed!");
547 DecoderError::Bug
548 })?;
549 let surfaces = display.create_surfaces(RTFormat::YUV420, None, width as u32, height as u32, Some(UsageHint::Decoder.into()), num_surfaces as u32).map_err(|_| DecoderError::AllocError)?;
550 let context = display.create_context(&config, width as i32, height as i32, Some(&surfaces), true).map_err(|_| DecoderError::Bug)?;
551
552 let ref_pics = Vec::new();
553
554 let image_formats = display.query_image_formats().map_err(|_| DecoderError::Bug)?;
555 validate!(!image_formats.is_empty());
556 let mut ifmt = image_formats[0];
557 for fmt in image_formats.iter() {
558 if fmt.bits_per_pixel == 12 {
559 ifmt = *fmt;
560 break;
561 }
562 }
563
564 self.vaapi = Some(VaapiInternals { display, context, ref_pics, surfaces, ifmt });
565
566 let vinfo = NAVideoInfo::new(width, height, false, YUV420_FORMAT);
567 self.info = NACodecInfo::new_ref(info.get_name(), NACodecTypeInfo::Video(vinfo), info.get_extradata()).into_ref();
568 self.out_frm = alloc_video_buffer(vinfo, 4)?;
569
570 Ok(())
571 } else {
572 Err(DecoderError::InvalidData)
573 }
574 }
575 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<()> {
576 let src = pkt.get_buffer();
577 let vactx = if let Some(ref mut ctx) = self.vaapi { ctx } else { return Err(DecoderError::Bug) };
578
579 let timestamp = pkt.get_dts().unwrap_or_else(|| pkt.get_pts().unwrap_or(0));
580
581 if vactx.surfaces.is_empty() {
582panic!("ran out of free surfaces");
583// return Err(DecoderError::AllocError);
584 }
585 let surface = vactx.surfaces.pop().unwrap();
586 let surface_id = surface.id();
587 let mut pic = Picture::new(timestamp, vactx.context.clone(), surface);
588 let mut is_ref = false;
589 let mut is_keyframe = false;
590
591 self.tb_num = pkt.ts.tb_num;
592 self.tb_den = pkt.ts.tb_den;
593
594 let mut mr = MemoryReader::new_read(&src);
595 let mut br = ByteReader::new(&mut mr);
596 let mut frame_type = FrameType::I;
597 let mut nal_buf = Vec::with_capacity(1024);
598 while br.left() > 0 {
599 let size = match self.nal_len {
600 1 => br.read_byte()? as usize,
601 2 => br.read_u16be()? as usize,
602 3 => br.read_u24be()? as usize,
603 4 => br.read_u32be()? as usize,
604 _ => unreachable!(),
605 };
606 validate!(br.left() >= (size as i64));
607 let offset = br.tell() as usize;
608 let raw_nal = &src[offset..][..size];
609 let _size = unescape_nal(raw_nal, &mut nal_buf);
610
611 let src = &nal_buf;
612 validate!((src[0] & 0x80) == 0);
613 let nal_ref_idc = src[0] >> 5;
614 let nal_unit_type = src[0] & 0x1F;
615
616 let mut full_size = src.len() * 8;
617 for &byte in src.iter().rev() {
618 if byte == 0 {
619 full_size -= 8;
620 } else {
621 full_size -= (byte.trailing_zeros() + 1) as usize;
622 break;
623 }
624 }
625 validate!(full_size > 0);
626
627 match nal_unit_type {
628 1 | 5 => {
629 let is_idr = nal_unit_type == 5;
630 is_ref |= nal_ref_idc != 0;
631 is_keyframe |= is_idr;
632 let mut br = BitReader::new(&src[..(full_size + 7)/8], BitReaderMode::BE);
633 br.skip(8)?;
634
635 let slice_hdr = parse_slice_header(&mut br, &self.spses, &self.ppses, is_idr, nal_ref_idc)?;
636 match slice_hdr.slice_type {
637 SliceType::P if frame_type != FrameType::B => frame_type = FrameType::P,
638 SliceType::SP if frame_type != FrameType::B => frame_type = FrameType::P,
639 SliceType::B => frame_type = FrameType::B,
640 _ => {},
641 };
642 let mut cur_sps = 0;
643 let mut cur_pps = 0;
644 let mut pps_found = false;
645 for (i, pps) in self.ppses.iter().enumerate() {
646 if pps.pic_parameter_set_id == slice_hdr.pic_parameter_set_id {
647 cur_pps = i;
648 pps_found = true;
649 break;
650 }
651 }
652 validate!(pps_found);
653 let mut sps_found = false;
654 for (i, sps) in self.spses.iter().enumerate() {
655 if sps.seq_parameter_set_id == self.ppses[cur_pps].seq_parameter_set_id {
656 cur_sps = i;
657 sps_found = true;
658 break;
659 }
660 }
661 validate!(sps_found);
662 let sps = &self.spses[cur_sps];
663 let pps = &self.ppses[cur_pps];
664
665 if slice_hdr.first_mb_in_slice == 0 {
666 let (top_id, bot_id) = self.frame_refs.calc_picture_num(&slice_hdr, is_idr, nal_ref_idc, sps);
667 if is_idr {
668 self.frame_refs.clear_refs();
669 for (pic, _) in vactx.ref_pics.drain(..) {
670 if let Ok(surf) = pic.take_surface() {
671 vactx.surfaces.push(surf);
672 } else {
673 panic!("can't take surface");
674 }
675 }
676 }
677 self.frame_refs.select_refs(sps, &slice_hdr, top_id);
678 let mut pic_refs = Vec::with_capacity(NUM_REF_PICS);
679 for pic in self.frame_refs.ref_pics.iter().rev().take(NUM_REF_PICS) {
680 pic_refs.push(pic.make_pic());
681 }
682 if slice_hdr.adaptive_ref_pic_marking_mode {
683 self.frame_refs.apply_adaptive_marking(&slice_hdr.adaptive_ref_pic_marking, slice_hdr.frame_num, 1 << sps.log2_max_frame_num)?;
684 }
685
686 while pic_refs.len() < NUM_REF_PICS {
687 pic_refs.push(make_dummy_h264_pic());
688 }
689
690 let mut flags = H264PictureFlags::default();
691 let frame_idx = if let Some(id) = get_long_term_id(is_idr, &slice_hdr) {
692 flags |= H264PictureFlag::LongTermReference;
693 id as u32
694 } else {
695 if nal_ref_idc != 0 {
696 flags |= H264PictureFlag::ShortTermReference;
697 }
698 u32::from(slice_hdr.frame_num)
699 };
700 let pic_refs: [PictureH264; NUM_REF_PICS] = pic_refs.try_into().unwrap_or_else(|_| panic!("can't convert"));
701
702 let h264pic = PictureH264::new(surface_id, frame_idx, flags, top_id as i32, bot_id as i32);
703
704 let seq_fields = H264SeqFields::new(
705 u32::from(sps.chroma_format_idc),
706 u32::from(sps.separate_colour_plane),
707 u32::from(sps.gaps_in_frame_num_value_allowed),
708 u32::from(sps.frame_mbs_only),
709 u32::from(sps.mb_adaptive_frame_field),
710 u32::from(sps.direct_8x8_inference),
711 u32::from(sps.level_idc >= 31),
712 u32::from(sps.log2_max_frame_num) - 4,
713 u32::from(sps.pic_order_cnt_type),
714 u32::from(sps.log2_max_pic_order_cnt_lsb).wrapping_sub(4),
715 u32::from(sps.delta_pic_order_always_zero)
716 );
717 let pic_fields = H264PicFields::new(
718 u32::from(pps.entropy_coding_mode),
719 u32::from(pps.weighted_pred),
720 u32::from(pps.weighted_bipred_idc),
721 u32::from(pps.transform_8x8_mode),
722 u32::from(slice_hdr.field_pic),
723 u32::from(pps.constrained_intra_pred),
724 u32::from(pps.pic_order_present),
725 u32::from(pps.deblocking_filter_control_present),
726 u32::from(pps.redundant_pic_cnt_present),
727 u32::from(nal_ref_idc != 0)
728 );
729 let ppd = PictureParameterBufferH264::new(
730 h264pic,
731 pic_refs,
732 sps.pic_width_in_mbs as u16 - 1,
733 sps.pic_height_in_mbs as u16 - 1,
734 sps.bit_depth_luma - 8,
735 sps.bit_depth_chroma - 8,
736 sps.num_ref_frames as u8,
737 &seq_fields,
738 pps.num_slice_groups as u8 - 1, // should be 0
739 pps.slice_group_map_type, // should be 0
740 0, //pps.slice_group_change_rate as u16 - 1,
741 pps.pic_init_qp as i8 - 26,
742 pps.pic_init_qs as i8 - 26,
743 pps.chroma_qp_index_offset,
744 pps.second_chroma_qp_index_offset,
745 &pic_fields,
746 slice_hdr.frame_num
747 );
748 let pic_param = BufferType::PictureParameter(PictureParameter::H264(ppd));
749 let buf = vactx.context.create_buffer(pic_param).map_err(|_| DecoderError::Bug)?;
750 pic.add_buffer(buf);
751
752 let mut scaling_list_8x8 = [[0; 64]; 2];
753 scaling_list_8x8[0].copy_from_slice(&pps.scaling_list_8x8[0]);
754 scaling_list_8x8[1].copy_from_slice(&pps.scaling_list_8x8[3]);
755 let iqmatrix = BufferType::IQMatrix(IQMatrix::H264(IQMatrixBufferH264::new(pps.scaling_list_4x4, scaling_list_8x8)));
756 let buf = vactx.context.create_buffer(iqmatrix).map_err(|_| DecoderError::Bug)?;
757 pic.add_buffer(buf);
758
759 let cpic = PictureInfo {
760 id: slice_hdr.frame_num,
761 full_id: top_id,
762 surface_id,
763 top_id, bot_id,
764 //pic_type: slice_hdr.slice_type.to_frame_type(),
765 is_ref,
766 is_idr,
767 long_term: get_long_term_id(is_idr, &slice_hdr),
768 };
769 if cpic.is_ref {
770 self.frame_refs.add_short_term(cpic.clone(), sps.num_ref_frames);
771 }
772 if let Some(lt_idx) = cpic.long_term {
773 self.frame_refs.add_long_term(lt_idx, cpic);
774 }
775 }
776
777 let mut luma_weight_l0 = [0i16; 32];
778 let mut luma_offset_l0 = [0i16; 32];
779 let mut chroma_weight_l0 = [[0i16; 2]; 32];
780 let mut chroma_offset_l0 = [[0i16; 2]; 32];
781 let mut luma_weight_l1 = [0i16; 32];
782 let mut luma_offset_l1 = [0i16; 32];
783 let mut chroma_weight_l1 = [[0i16; 2]; 32];
784 let mut chroma_offset_l1 = [[0i16; 2]; 32];
785 let mut luma_weighted_l0 = false;
786 let mut chroma_weighted_l0 = false;
787 let mut luma_weighted_l1 = false;
788 let mut chroma_weighted_l1 = false;
789 let mut luma_log2_weight_denom = slice_hdr.luma_log2_weight_denom;
790 let mut chroma_log2_weight_denom = slice_hdr.chroma_log2_weight_denom;
791
792 if (pps.weighted_pred && matches!(slice_hdr.slice_type, SliceType::P | SliceType::B)) || (pps.weighted_bipred_idc == 1 && slice_hdr.slice_type == SliceType::B) {
793 luma_weighted_l0 = true;
794 chroma_weighted_l0 = false;
795 for (i, winfo) in slice_hdr.weights_l0.iter().enumerate().take(slice_hdr.num_ref_idx_l0_active) {
796 if winfo.luma_weighted {
797 luma_weight_l0[i] = winfo.luma_weight.into();
798 luma_offset_l0[i] = winfo.luma_offset.into();
799 } else {
800 luma_weight_l0[i] = 1 << slice_hdr.luma_log2_weight_denom;
801 }
802 if winfo.chroma_weighted {
803 chroma_weight_l0[i][0] = winfo.chroma_weight[0].into();
804 chroma_weight_l0[i][1] = winfo.chroma_weight[1].into();
805 chroma_offset_l0[i][0] = winfo.chroma_offset[0].into();
806 chroma_offset_l0[i][1] = winfo.chroma_offset[1].into();
807 } else {
808 chroma_weight_l0[i][0] = 1 << slice_hdr.chroma_log2_weight_denom;
809 chroma_weight_l0[i][1] = 1 << slice_hdr.chroma_log2_weight_denom;
810 chroma_offset_l0[i][0] = 0;
811 chroma_offset_l0[i][1] = 0;
812 }
813 chroma_weighted_l0 |= winfo.chroma_weighted;
814 }
815 }
816 if pps.weighted_bipred_idc == 1 && slice_hdr.slice_type == SliceType::B {
817 luma_weighted_l1 = true;
818 chroma_weighted_l1 = sps.chroma_format_idc != 0;
819 for (i, winfo) in slice_hdr.weights_l1.iter().enumerate().take(slice_hdr.num_ref_idx_l1_active) {
820 if winfo.luma_weighted {
821 luma_weight_l1[i] = winfo.luma_weight.into();
822 luma_offset_l1[i] = winfo.luma_offset.into();
823 } else {
824 luma_weight_l1[i] = 1 << slice_hdr.luma_log2_weight_denom;
825 }
826 if chroma_weighted_l1 && winfo.chroma_weighted {
827 chroma_weight_l1[i][0] = winfo.chroma_weight[0].into();
828 chroma_weight_l1[i][1] = winfo.chroma_weight[1].into();
829 chroma_offset_l1[i][0] = winfo.chroma_offset[0].into();
830 chroma_offset_l1[i][1] = winfo.chroma_offset[1].into();
831 } else {
832 chroma_weight_l1[i][0] = 1 << slice_hdr.chroma_log2_weight_denom;
833 chroma_weight_l1[i][1] = 1 << slice_hdr.chroma_log2_weight_denom;
834 chroma_offset_l1[i][0] = 0;
835 chroma_offset_l1[i][1] = 0;
836 }
837 }
838 }
839 if pps.weighted_bipred_idc == 2 && slice_hdr.slice_type == SliceType::B {
840 let num_l0 = slice_hdr.num_ref_idx_l0_active;
841 let num_l1 = slice_hdr.num_ref_idx_l1_active;
842 if num_l0 != 1 || num_l1 != 1 { //xxx: also exclude symmetric case
843 luma_weighted_l0 = false;
844 luma_weighted_l1 = false;
845 chroma_weighted_l0 = false;
846 chroma_weighted_l1 = false;
847 luma_log2_weight_denom = 5;
848 chroma_log2_weight_denom = 5;
849
850 for w in luma_weight_l0.iter_mut() {
851 *w = 32;
852 }
853 for w in luma_weight_l1.iter_mut() {
854 *w = 32;
855 }
856 for w in chroma_weight_l0.iter_mut() {
857 *w = [32; 2];
858 }
859 for w in chroma_weight_l1.iter_mut() {
860 *w = [32; 2];
861 }
862 }
863 }
864
865 let ref_pic_list_0 = map_ref_list(&self.frame_refs.cur_refs.ref_list0);
866 let ref_pic_list_1 = map_ref_list(&self.frame_refs.cur_refs.ref_list1);
867
868 let slice_param = SliceParameterBufferH264::new(
869 raw_nal.len() as u32,
870 0, // no offset
871 VASliceDataFlag::All,
872 br.tell() as u16,
873 slice_hdr.first_mb_in_slice as u16,
874 match slice_hdr.slice_type {
875 SliceType::I => 2,
876 SliceType::P => 0,
877 SliceType::B => 1,
878 SliceType::SI => 4,
879 SliceType::SP => 3,
880 },
881 slice_hdr.direct_spatial_mv_pred as u8,
882 (slice_hdr.num_ref_idx_l0_active as u8).saturating_sub(1),
883 (slice_hdr.num_ref_idx_l1_active as u8).saturating_sub(1),
884 slice_hdr.cabac_init_idc,
885 slice_hdr.slice_qp_delta as i8,
886 slice_hdr.disable_deblocking_filter_idc,
887 slice_hdr.slice_alpha_c0_offset / 2,
888 slice_hdr.slice_beta_offset / 2,
889 ref_pic_list_0,
890 ref_pic_list_1,
891 luma_log2_weight_denom,
892 chroma_log2_weight_denom,
893 luma_weighted_l0 as u8, luma_weight_l0, luma_offset_l0,
894 chroma_weighted_l0 as u8, chroma_weight_l0, chroma_offset_l0,
895 luma_weighted_l1 as u8, luma_weight_l1, luma_offset_l1,
896 chroma_weighted_l1 as u8, chroma_weight_l1, chroma_offset_l1,
897 );
898 let slc_param = BufferType::SliceParameter(SliceParameter::H264(slice_param));
899 let buf = vactx.context.create_buffer(slc_param).map_err(|_| DecoderError::Bug)?;
900 pic.add_buffer(buf);
901
902 let slc_data = BufferType::SliceData(raw_nal.to_vec());
903 let buf = vactx.context.create_buffer(slc_data).map_err(|_| DecoderError::Bug)?;
904 pic.add_buffer(buf);
905 },
906 2 => { // slice data partition A
907 //slice header
908 //slice id = read_ue()
909 //cat 2 slice data (all but MB layer residual)
910 return Err(DecoderError::NotImplemented);
911 },
912 3 => { // slice data partition B
913 //slice id = read_ue()
914 //if pps.redundant_pic_cnt_present { redundant_pic_cnt = read_ue() }
915 //cat 3 slice data (MB layer residual)
916 return Err(DecoderError::NotImplemented);
917 },
918 4 => { // slice data partition C
919 //slice id = read_ue()
920 //if pps.redundant_pic_cnt_present { redundant_pic_cnt = read_ue() }
921 //cat 4 slice data (MB layer residual)
922 return Err(DecoderError::NotImplemented);
923 },
924 6 => {}, //SEI
925 7 => {
926 let sps = parse_sps(&src[1..])?;
927 self.spses.push(sps);
928 },
929 8 => {
930 validate!(full_size >= 8 + 16);
931 let pps = parse_pps(&src[1..], &self.spses, full_size - 8)?;
932 let mut found = false;
933 for stored_pps in self.ppses.iter_mut() {
934 if stored_pps.pic_parameter_set_id == pps.pic_parameter_set_id {
935 *stored_pps = pps.clone();
936 found = true;
937 break;
938 }
939 }
940 if !found {
941 self.ppses.push(pps);
942 }
943 },
944 9 => { // access unit delimiter
945 },
946 10 => {}, //end of sequence
947 11 => {}, //end of stream
948 12 => {}, //filler
949 _ => {},
950 };
951
952 br.read_skip(size)?;
953 }
954
955 let bpic = pic.begin().expect("begin");
956 let rpic = bpic.render().expect("render");
957 let epic = rpic.end().expect("end");
958
959 self.reorderer.add_frame(WaitingFrame {
960 pic: epic,
961 is_idr: is_keyframe,
962 is_ref,
963 ftype: frame_type,
964 ts: timestamp,
965 });
966
967 let mut idx = 0;
968 while idx < vactx.ref_pics.len() {
969 let cur_surf_id = vactx.ref_pics[idx].1;
970 if self.frame_refs.ref_pics.iter().any(|fref| fref.surface_id == cur_surf_id) {
971 idx += 1;
972 } else {
973 let (pic, _) = vactx.ref_pics.remove(idx);
974 if let Ok(surf) = pic.take_surface() {
975 vactx.surfaces.push(surf);
976 } else {
977 panic!("can't take surface");
978 }
979 }
980 }
981
982 Ok(())
983 }
984 fn get_frame(&mut self) -> Option<NAFrameRef> {
985 if let Some(ref mut vactx) = self.vaapi {
986 if let Some(frm) = self.reorderer.get_frame() {
987 let ts = frm.ts;
988 let is_idr = frm.is_idr;
989 let is_ref = frm.is_ref;
990 let ftype = frm.ftype;
991 if let Ok(pic) = frm.pic.sync() {
992 let _ = fill_frame(vactx.ifmt, &pic, &mut self.out_frm);
993
994 if !is_ref {
995 if let Ok(surf) = pic.take_surface() {
996 vactx.surfaces.push(surf);
997 } else {
998 panic!("can't take surface");
999 }
1000 } else {
1001 let id = pic.surface_id();
1002 vactx.ref_pics.push((pic, id));
1003 }
1004
1005 let ts = NATimeInfo::new(None, Some(ts), None, self.tb_num, self.tb_den);
1006 Some(NAFrame::new(ts, ftype, is_idr, self.info.clone(), self.out_frm.clone()).into_ref())
1007 } else {
1008 panic!("can't sync");
1009 }
1010 } else {
1011 None
1012 }
1013 } else {
1014 None
1015 }
1016 }
1017 fn get_last_frames(&mut self) -> Option<NAFrameRef> {
1018 if let Some(ref mut vactx) = self.vaapi {
1019 if let Some(frm) = self.reorderer.frames.pop_front() {
1020 let ts = frm.ts;
1021 let is_idr = frm.is_idr;
1022 let is_ref = frm.is_ref;
1023 let ftype = frm.ftype;
1024 if let Ok(pic) = frm.pic.sync() {
1025 let _ = fill_frame(vactx.ifmt, &pic, &mut self.out_frm);
1026
1027 if !is_ref {
1028 if let Ok(surf) = pic.take_surface() {
1029 vactx.surfaces.push(surf);
1030 } else {
1031 panic!("can't take surface");
1032 }
1033 } else {
1034 let id = pic.surface_id();
1035 vactx.ref_pics.push((pic, id));
1036 }
1037
1038 let ts = NATimeInfo::new(None, Some(ts), None, self.tb_num, self.tb_den);
1039 Some(NAFrame::new(ts, ftype, is_idr, self.info.clone(), self.out_frm.clone()).into_ref())
1040 } else {
1041 panic!("can't sync");
1042 }
1043 } else {
1044 None
1045 }
1046 } else {
1047 None
1048 }
1049 }
1050 fn flush(&mut self) {
1051 self.frame_refs.clear_refs();
1052 if let Some(ref mut vactx) = self.vaapi {
1053 for frm in self.reorderer.frames.drain(..) {
1054 if let Ok(pic) = frm.pic.sync() {
1055 if let Ok(surf) = pic.take_surface() {
1056 vactx.surfaces.push(surf);
1057 } else {
1058 panic!("can't take surface");
1059 }
1060 } else {
1061 panic!("can't sync");
1062 }
1063 }
1064 self.reorderer.flush();
1065 for (pic, _) in vactx.ref_pics.drain(..) {
1066 if let Ok(surf) = pic.take_surface() {
1067 vactx.surfaces.push(surf);
1068 } else {
1069 panic!("can't take surface");
1070 }
1071 }
1072 }
1073 }
1074}
1075
1076impl NAOptionHandler for VaapiH264Decoder {
1077 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1078 fn set_options(&mut self, _options: &[NAOption]) {}
1079 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1080}
1081
1082use std::thread::*;
1083use std::sync::mpsc::*;
1084
1085enum DecMessage {
1086 Init(NACodecInfoRef),
1087 Decode(NAPacket),
1088 Flush,
1089 GetFrame,
1090 GetLastFrames,
1091 End
1092}
1093
1094enum DecResponse {
1095 Ok,
1096 Nothing,
1097 Err(DecoderError),
1098 Frame(NAFrameRef),
1099}
1100
1101pub trait HWDecoder {
1102 fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()>;
1103 fn queue_pkt(&mut self, pkt: &NAPacket) -> DecoderResult<()>;
1104 fn get_frame(&mut self) -> Option<NAFrameRef>;
1105 fn get_last_frames(&mut self) -> Option<NAFrameRef>;
1106 fn flush(&mut self);
1107}
1108
1109pub struct HWWrapper {
1110 handle: Option<JoinHandle<DecoderResult<()>>>,
1111 send: SyncSender<DecMessage>,
1112 recv: Receiver<DecResponse>,
1113}
1114
1115#[allow(clippy::new_without_default)]
1116impl HWWrapper {
1117 pub fn new() -> Self {
1118 let (in_send, in_recv) = sync_channel(1);
1119 let (out_send, out_recv) = sync_channel(1);
1120 let handle = std::thread::spawn(move || {
1121 let receiver = in_recv;
1122 let sender = out_send;
1123 let mut dec = VaapiH264Decoder::new();
1124 while let Ok(msg) = receiver.recv() {
1125 match msg {
1126 DecMessage::Init(info) => {
1127 let msg = if let Err(err) = dec.init(info) {
1128 DecResponse::Err(err)
1129 } else {
1130 DecResponse::Ok
1131 };
1132 sender.send(msg).map_err(|_| DecoderError::Bug)?;
1133 },
1134 DecMessage::Decode(pkt) => {
1135 let msg = match dec.decode(&pkt) {
1136 Ok(()) => DecResponse::Ok,
1137 Err(err) => DecResponse::Err(err),
1138 };
1139 sender.send(msg).map_err(|_| DecoderError::Bug)?;
1140 },
1141 DecMessage::GetFrame => {
1142 let msg = match dec.get_frame() {
1143 Some(frm) => DecResponse::Frame(frm),
1144 None => DecResponse::Nothing,
1145 };
1146 sender.send(msg).map_err(|_| DecoderError::Bug)?;
1147 },
1148 DecMessage::GetLastFrames => {
1149 let msg = match dec.get_last_frames() {
1150 Some(frm) => DecResponse::Frame(frm),
1151 None => DecResponse::Nothing,
1152 };
1153 sender.send(msg).map_err(|_| DecoderError::Bug)?;
1154 },
1155 DecMessage::Flush => dec.flush(),
1156 DecMessage::End => return Ok(()),
1157 };
1158 }
1159 Err(DecoderError::Bug)
1160 });
1161
1162 Self {
1163 handle: Some(handle),
1164 send: in_send,
1165 recv: out_recv,
1166 }
1167 }
1168}
1169
1170impl HWDecoder for HWWrapper {
1171 fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {
1172 if self.send.send(DecMessage::Init(info)).is_ok() {
1173 match self.recv.recv() {
1174 Ok(DecResponse::Ok) => Ok(()),
1175 Ok(DecResponse::Err(err)) => Err(err),
1176 Err(_) => Err(DecoderError::Bug),
1177 _ => unreachable!(),
1178 }
1179 } else {
1180 Err(DecoderError::Bug)
1181 }
1182 }
1183 fn queue_pkt(&mut self, pkt: &NAPacket) -> DecoderResult<()> {
1184 let pkt2 = NAPacket::new_from_refbuf(pkt.get_stream(), pkt.ts, pkt.keyframe, pkt.get_buffer());
1185 if self.send.send(DecMessage::Decode(pkt2)).is_ok() {
1186 match self.recv.recv() {
1187 Ok(DecResponse::Ok) => Ok(()),
1188 Ok(DecResponse::Err(err)) => Err(err),
1189 Err(_) => Err(DecoderError::Bug),
1190 _ => unreachable!(),
1191 }
1192 } else {
1193 Err(DecoderError::Bug)
1194 }
1195 }
1196 fn get_frame(&mut self) -> Option<NAFrameRef> {
1197 if self.send.send(DecMessage::GetFrame).is_ok() {
1198 match self.recv.recv() {
1199 Ok(DecResponse::Frame(frm)) => Some(frm),
1200 Ok(DecResponse::Nothing) => None,
1201 Err(_) => None,
1202 _ => unreachable!(),
1203 }
1204 } else {
1205 None
1206 }
1207 }
1208 fn get_last_frames(&mut self) -> Option<NAFrameRef> {
1209 if self.send.send(DecMessage::GetLastFrames).is_ok() {
1210 match self.recv.recv() {
1211 Ok(DecResponse::Frame(frm)) => Some(frm),
1212 Ok(DecResponse::Nothing) => None,
1213 Err(_) => None,
1214 _ => unreachable!(),
1215 }
1216 } else {
1217 None
1218 }
1219 }
1220 fn flush(&mut self) {
1221 let _ = self.send.send(DecMessage::Flush);
1222 }
1223}
1224
1225impl Drop for HWWrapper {
1226 fn drop(&mut self) {
1227 if self.send.send(DecMessage::End).is_ok() {
1228 let mut handle = None;
1229 std::mem::swap(&mut handle, &mut self.handle);
1230 if let Some(hdl) = handle {
1231 let _ = hdl.join();
1232 }
1233 }
1234 }
1235}
1236
1237impl NAOptionHandler for HWWrapper {
1238 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1239 fn set_options(&mut self, _options: &[NAOption]) {}
1240 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1241}
1242
1243pub fn new_h264_hwdec() -> Box<dyn HWDecoder + Send> {
1244 Box::new(HWWrapper::new())
1245}
1246
1247#[cfg(test)]
1248mod test {
1249 use nihav_core::codecs::*;
1250 use nihav_core::io::byteio::*;
1251 use nihav_core::demuxers::{RegisteredDemuxers, create_demuxer};
1252 use nihav_commonfmt::generic_register_all_demuxers;
1253 use super::VaapiH264Decoder;
1254 use std::io::prelude::*;
1255
1256 fn decode_h264(name: &str, dname: &str, dmx_reg: &RegisteredDemuxers, opfx: &str) -> DecoderResult<()> {
1257 let dmx_f = dmx_reg.find_demuxer(dname).expect("demuxer exists");
1258 let file = std::fs::File::open(name).expect("file exists");
1259 let mut fr = FileReader::new_read(file);
1260 let mut br = ByteReader::new(&mut fr);
1261 let mut dmx = create_demuxer(dmx_f, &mut br).expect("create demuxer");
1262
1263 let mut vstream_id = 0;
1264 let mut dec = VaapiH264Decoder::new();
1265 for stream in dmx.get_streams() {
1266 if stream.get_media_type() == StreamType::Video {
1267 dec.init(stream.get_info()).expect("inited");
1268 vstream_id = stream.get_id();
1269 break;
1270 }
1271 }
1272
1273 let mut frameno = 0;
1274 while let Ok(pkt) = dmx.get_frame() {
1275 if pkt.get_stream().get_id() != vstream_id {
1276 continue;
1277 }
1278 dec.decode(&pkt).expect("decoded");
1279 let frm = dec.get_last_frames().expect("get frame");
1280 let timestamp = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
1281
1282 let pic = frm.get_buffer().get_vbuf().expect("got picture");
1283
1284 let nname = format!("assets/test_out/{}{:06}_{}.pgm", opfx, timestamp, frameno);
1285 frameno += 1;
1286 let mut file = std::fs::File::create(&nname).expect("create file");
1287 let (w, h) = pic.get_dimensions(0);
1288 file.write_all(format!("P5\n{} {}\n255\n", w, h * 3 / 2).as_bytes()).expect("header written");
1289 let data = pic.get_data();
1290 for yline in data.chunks(pic.get_stride(0)).take(h) {
1291 file.write_all(&yline[..w]).expect("Y line written");
1292 }
1293 for (uline, vline) in data[pic.get_offset(1)..].chunks(pic.get_stride(1))
1294 .zip(data[pic.get_offset(2)..].chunks(pic.get_stride(2))).take(h / 2) {
1295 file.write_all(&uline[..w / 2]).expect("U line written");
1296 file.write_all(&vline[..w / 2]).expect("V line written");
1297 }
1298 }
1299 Ok(())
1300 }
1301
1302
1303 // samples if not specified otherwise come from H.264 conformance suite
1304
1305 #[test]
1306 fn test_h264_simple() {
1307 let mut dmx_reg = RegisteredDemuxers::new();
1308 generic_register_all_demuxers(&mut dmx_reg);
1309
1310 decode_h264("assets/ITU/DimpledSpanishCuckoo-mobile.mp4", "mov", &dmx_reg, "hw").unwrap();
1311 }
1312}
extremely simple tool to test decoding functionality of NihAV