Debian Codegraph @

.cargo/vendor/rav1e/src/test_encode_decode/mod.rs

raw
1 // Copyright (c) 2018-2022, The rav1e contributors. All rights reserved
2 //
3 // This source code is subject to the terms of the BSD 2 Clause License and
4 // the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
5 // was not distributed with this source code in the LICENSE file, you can
6 // obtain it at www.aomedia.org/license/software. If the Alliance for Open
7 // Media Patent License 1.0 was not distributed with this source code in the
8 // PATENTS file, you can obtain it at www.aomedia.org/license/patent.
9
10 // Fuzzing only uses a subset of these.
11 #![cfg_attr(fuzzing, allow(unused))]
12
13 use crate::color::ChromaSampling;
14
15 use crate::api::config::GrainTableSegment;
16 use crate::util::Pixel;
17 use crate::*;
18
19 use arrayvec::ArrayVec;
20 use interpolate_name::interpolate_test;
21 use log::debug;
22 use rand::{Rng, SeedableRng};
23 use rand_chacha::ChaChaRng;
24 use std::collections::VecDeque;
25
26 #[cfg(feature = "decode_test")]
27 mod aom;
28 #[cfg(feature = "decode_test_dav1d")]
29 mod dav1d;
30
31 #[cfg(feature = "decode_test")]
32 use aom::AomDecoder;
33 #[cfg(feature = "decode_test_dav1d")]
34 use dav1d::Dav1dDecoder;
35
36 fn fill_frame<T: Pixel>(ra: &mut ChaChaRng, frame: &mut Frame<T>) {
37 for plane in frame.planes.iter_mut() {
38 let stride = plane.cfg.stride;
39 for row in plane.data.chunks_mut(stride) {
40 for pixel in row {
41 let v: u8 = ra.random();
42 *pixel = T::cast_from(v);
43 }
44 }
45 }
46 }
47
48 fn read_frame_batch<T: Pixel>(
49 ctx: &mut Context<T>, ra: &mut ChaChaRng, limit: usize,
50 ) {
51 for _ in 0..limit {
52 let mut input = ctx.new_frame();
53 fill_frame(ra, &mut input);
54
55 let _ = ctx.send_frame(input);
56 }
57
58 ctx.flush();
59 }
60
61 pub(crate) enum DecodeResult {
62 Done,
63 NotDone,
64 Corrupted(usize),
65 }
66
67 pub(crate) trait TestDecoder<T: Pixel> {
68 fn setup_decoder(w: usize, h: usize) -> Self
69 where
70 Self: Sized;
71 fn encode_decode(
72 &mut self, verify: bool, w: usize, h: usize, speed: u8, quantizer: usize,
73 limit: usize, bit_depth: usize, chroma_sampling: ChromaSampling,
74 min_keyint: u64, max_keyint: u64, switch_frame_interval: u64,
75 low_latency: bool, error_resilient: bool, bitrate: i32,
76 tile_cols_log2: usize, tile_rows_log2: usize, still_picture: bool,
77 grain_table: Option<Vec<GrainTableSegment>>,
78 ) {
79 let mut ra = ChaChaRng::from_seed([0; 32]);
80
81 let mut ctx: Context<T> = setup_encoder(
82 w,
83 h,
84 speed,
85 quantizer,
86 bit_depth,
87 chroma_sampling,
88 min_keyint,
89 max_keyint,
90 switch_frame_interval,
91 low_latency,
92 error_resilient,
93 bitrate,
94 tile_cols_log2,
95 tile_rows_log2,
96 still_picture,
97 grain_table,
98 );
99
100 debug!(
101 "Encoding {}x{} speed {} quantizer {} bit-depth {} bitrate {}",
102 w, h, speed, quantizer, bit_depth, bitrate
103 );
104 #[cfg(feature = "dump_ivf")]
105 let mut out = std::fs::File::create(&format!(
106 "out-{}x{}-s{}-q{}-r{}-{:?}.ivf",
107 w, h, speed, quantizer, bitrate, chroma_sampling
108 ))
109 .unwrap();
110 #[cfg(feature = "dump_ivf")]
111 ivf::write_ivf_header(&mut out, w, h, 30, 1);
112
113 let mut rec_fifo = VecDeque::new();
114 read_frame_batch(&mut ctx, &mut ra, limit);
115
116 for _ in 0..limit {
117 let mut corrupted_count = 0;
118 loop {
119 let res = ctx.receive_packet();
120 if let Ok(pkt) = res {
121 debug!("Encoded packet {}", pkt.input_frameno);
122
123 #[cfg(feature = "dump_ivf")]
124 ivf::write_ivf_frame(&mut out, pkt.input_frameno, &pkt.data);
125
126 if let Some(pkt_rec) = pkt.rec {
127 rec_fifo.push_back((*pkt_rec).clone());
128 }
129 let packet = pkt.data;
130 debug!("Decoding frame {}", pkt.input_frameno);
131 match self.decode_packet(
132 &packet,
133 &mut rec_fifo,
134 w,
135 h,
136 chroma_sampling,
137 bit_depth,
138 verify,
139 ) {
140 DecodeResult::Done => {
141 break;
142 }
143 DecodeResult::NotDone => {}
144 DecodeResult::Corrupted(corrupted) => {
145 corrupted_count += corrupted;
146 }
147 }
148 } else {
149 break;
150 }
151 }
152 assert_eq!(corrupted_count, 0);
153 }
154 }
155 fn decode_packet(
156 &mut self, packet: &[u8], rec_fifo: &mut VecDeque<Frame<T>>, w: usize,
157 h: usize, chroma_sampling: ChromaSampling, bit_depth: usize, verify: bool,
158 ) -> DecodeResult;
159 }
160
161 pub fn compare_plane<T: Ord + std::fmt::Debug>(
162 rec: &[T], rec_stride: usize, dec: &[T], dec_stride: usize, width: usize,
163 height: usize, pli: usize,
164 ) {
165 for (row, line) in
166 rec.chunks(rec_stride).zip(dec.chunks(dec_stride)).take(height).enumerate()
167 {
168 assert_eq!(
169 &line.0[..width],
170 &line.1[..width],
171 "at row {} of plane {}",
172 row,
173 pli
174 );
175 }
176 }
177
178 fn setup_encoder<T: Pixel>(
179 w: usize, h: usize, speed: u8, quantizer: usize, bit_depth: usize,
180 chroma_sampling: ChromaSampling, min_keyint: u64, max_keyint: u64,
181 switch_frame_interval: u64, low_latency: bool, error_resilient: bool,
182 bitrate: i32, tile_cols_log2: usize, tile_rows_log2: usize,
183 still_picture: bool, grain_table: Option<Vec<GrainTableSegment>>,
184 ) -> Context<T> {
185 assert!(bit_depth == 8 || std::mem::size_of::<T>() > 1);
186 let mut enc = EncoderConfig::with_speed_preset(speed);
187 enc.quantizer = quantizer;
188 enc.min_key_frame_interval = min_keyint;
189 enc.max_key_frame_interval = max_keyint;
190 enc.switch_frame_interval = switch_frame_interval;
191 enc.low_latency = low_latency;
192 enc.error_resilient = error_resilient;
193 enc.width = w;
194 enc.height = h;
195 enc.bit_depth = bit_depth;
196 enc.chroma_sampling = chroma_sampling;
197 enc.bitrate = bitrate;
198 enc.tile_cols = 1 << tile_cols_log2;
199 enc.tile_rows = 1 << tile_rows_log2;
200 enc.still_picture = still_picture;
201 enc.film_grain_params = grain_table;
202
203 let threads = if cfg!(fuzzing) { 1 } else { 2 };
204
205 let cfg = Config::new().with_encoder_config(enc).with_threads(threads);
206
207 cfg.new_context().unwrap()
208 }
209
210 // TODO: support non-multiple-of-16 dimensions
211 static DIMENSION_OFFSETS: &[(usize, usize)] =
212 &[(0, 0), (4, 4), (8, 8), (16, 16)];
213
214 fn speed(s: u8, decoder: &str) {
215 let quantizer = 100;
216 let limit = 5;
217 let w = 64;
218 let h = 80;
219
220 for b in DIMENSION_OFFSETS.iter() {
221 let w = w + b.0;
222 let h = h + b.1;
223 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
224 dec.encode_decode(
225 true,
226 w,
227 h,
228 s,
229 quantizer,
230 limit,
231 8,
232 Default::default(),
233 15,
234 15,
235 0,
236 true,
237 false,
238 0,
239 0,
240 0,
241 false,
242 None,
243 );
244 }
245 }
246
247 macro_rules! test_speeds {
248 ($($S:expr),+) => {
249 $(
250 paste::item!{
251 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
252 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
253 #[ignore]
254 fn [<speed_ $S>](decoder: &str) {
255 speed($S, decoder)
256 }
257 }
258 )*
259 }
260 }
261
262 test_speeds! { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
263
264 macro_rules! test_dimensions {
265 ($(($W:expr, $H:expr)),+) => {
266 $(
267 paste::item!{
268 #[cfg_attr(feature = "decode_test", interpolate_name::interpolate_test(aom, "aom"))]
269 #[cfg_attr(feature = "decode_test_dav1d", interpolate_name::interpolate_test(dav1d, "dav1d"))]
270 fn [<dimension_ $W x $H>](decoder: &str) {
271 super::dimension($W, $H, decoder)
272 }
273 }
274 )*
275 }
276 }
277
278 #[cfg(not(feature = "quick_test"))]
279 mod large_dimension {
280 test_dimensions! {
281 (512, 512),
282 (1024, 1024),
283 (2048, 2048)
284 }
285 }
286
287 mod small_dimension {
288 test_dimensions! {
289 (256, 256),
290 (258, 258),
291 (260, 260),
292 (262, 262),
293 (264, 264),
294 (265, 265)
295 }
296 }
297
298 mod tiny_dimension {
299 test_dimensions! {
300 (1, 1),
301 (2, 2),
302 (4, 4),
303 (8, 8),
304 (16, 16),
305 (32, 32),
306 (64, 64),
307 (128, 128)
308 }
309 }
310
311 fn dimension(w: usize, h: usize, decoder: &str) {
312 let quantizer = 100;
313 let limit = 1;
314 let speed = 10;
315 let still_picture = w < 16 || h < 16;
316
317 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
318 dec.encode_decode(
319 true,
320 w,
321 h,
322 speed,
323 quantizer,
324 limit,
325 8,
326 Default::default(),
327 15,
328 15,
329 0,
330 true,
331 false,
332 0,
333 0,
334 0,
335 still_picture,
336 None,
337 );
338 }
339
340 fn quantizer(decoder: &str, q: usize) {
341 let limit = 5;
342 let w = 64;
343 let h = 80;
344 let speed = 10;
345
346 for b in DIMENSION_OFFSETS.iter() {
347 let mut dec = get_decoder::<u8>(decoder, b.0, b.1);
348 dec.encode_decode(
349 true,
350 w + b.0,
351 h + b.1,
352 speed,
353 q,
354 limit,
355 8,
356 Default::default(),
357 15,
358 15,
359 0,
360 true,
361 false,
362 0,
363 0,
364 0,
365 false,
366 None,
367 );
368 }
369 }
370
371 macro_rules! test_quantizer {
372 ($($Q:expr),+) => {
373 $(
374 paste::item!{
375 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
376 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
377 fn [<quantizer_ $Q>](decoder: &str) {
378 quantizer(decoder, $Q);
379 }
380 }
381 )*
382 }
383 }
384
385 test_quantizer! {60, 80, 100, 120}
386
387 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
388 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
389 #[ignore]
390 fn bitrate(decoder: &str) {
391 let limit = 5;
392 let w = 64;
393 let h = 80;
394 let speed = 10;
395
396 for &q in [172, 220, 252, 255].iter() {
397 for &r in [100, 1000, 10_000].iter() {
398 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
399 dec.encode_decode(
400 true,
401 w,
402 h,
403 speed,
404 q,
405 limit,
406 8,
407 Default::default(),
408 15,
409 15,
410 0,
411 true,
412 false,
413 r,
414 0,
415 0,
416 false,
417 None,
418 );
419 }
420 }
421 }
422
423 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
424 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
425 fn keyframes(decoder: &str) {
426 let limit = 12;
427 let w = 64;
428 let h = 80;
429 let speed = 9;
430 let q = 100;
431
432 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
433 dec.encode_decode(
434 true,
435 w,
436 h,
437 speed,
438 q,
439 limit,
440 8,
441 Default::default(),
442 6,
443 6,
444 0,
445 true,
446 false,
447 0,
448 0,
449 0,
450 false,
451 None,
452 );
453 }
454
455 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
456 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
457 fn reordering(decoder: &str) {
458 let limit = 12;
459 let w = 64;
460 let h = 80;
461 let speed = 10;
462 let q = 100;
463
464 for keyint in &[4, 5, 6] {
465 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
466 dec.encode_decode(
467 true,
468 w,
469 h,
470 speed,
471 q,
472 limit,
473 8,
474 Default::default(),
475 *keyint,
476 *keyint,
477 0,
478 false,
479 false,
480 0,
481 0,
482 0,
483 false,
484 None,
485 );
486 }
487 }
488
489 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
490 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
491 fn reordering_short_video(decoder: &str) {
492 // Regression test for https://github.com/xiph/rav1e/issues/890
493 let limit = 2;
494 let w = 64;
495 let h = 80;
496 let speed = 10;
497 let q = 100;
498 let keyint = 12;
499
500 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
501 dec.encode_decode(
502 true,
503 w,
504 h,
505 speed,
506 q,
507 limit,
508 8,
509 Default::default(),
510 keyint,
511 keyint,
512 0,
513 false,
514 false,
515 0,
516 0,
517 0,
518 false,
519 None,
520 );
521 }
522
523 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
524 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
525 fn error_resilient(decoder: &str) {
526 let limit = 2;
527 let w = 64;
528 let h = 80;
529 let speed = 10;
530 let q = 100;
531 let keyint = 12;
532
533 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
534 dec.encode_decode(
535 true,
536 w,
537 h,
538 speed,
539 q,
540 limit,
541 8,
542 Default::default(),
543 keyint,
544 keyint,
545 0,
546 true,
547 true,
548 0,
549 0,
550 0,
551 false,
552 None,
553 );
554 }
555
556 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
557 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
558 fn error_resilient_reordering(decoder: &str) {
559 let limit = 6;
560 let w = 64;
561 let h = 80;
562 let speed = 10;
563 let q = 100;
564
565 for keyint in &[4, 5, 6] {
566 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
567 dec.encode_decode(
568 true,
569 w,
570 h,
571 speed,
572 q,
573 limit,
574 8,
575 Default::default(),
576 *keyint,
577 *keyint,
578 0,
579 false,
580 true,
581 0,
582 0,
583 0,
584 false,
585 None,
586 );
587 }
588 }
589
590 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
591 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
592 fn switch_frame(decoder: &str) {
593 let limit = 3;
594 let w = 64;
595 let h = 80;
596 let speed = 10;
597 let q = 100;
598 let keyint = 12;
599
600 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
601 dec.encode_decode(
602 true,
603 w,
604 h,
605 speed,
606 q,
607 limit,
608 8,
609 Default::default(),
610 keyint,
611 keyint,
612 1,
613 true,
614 true,
615 0,
616 0,
617 0,
618 false,
619 None,
620 );
621 }
622
623 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
624 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
625 #[ignore]
626 fn odd_size_frame_with_full_rdo(decoder: &str) {
627 let limit = 3;
628 let w = 64 + 1;
629 let h = 128 - 1;
630 let speed = 0;
631 let qindex = 100;
632
633 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
634 dec.encode_decode(
635 true,
636 w,
637 h,
638 speed,
639 qindex,
640 limit,
641 8,
642 Default::default(),
643 15,
644 15,
645 0,
646 true,
647 false,
648 0,
649 0,
650 0,
651 false,
652 None,
653 );
654 }
655
656 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
657 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
658 #[ignore]
659 fn low_bit_depth(decoder: &str) {
660 let quantizer = 100;
661 let limit = 3; // Include inter frames
662 let speed = 0; // Test as many tools as possible
663 let w = 64;
664 let h = 80;
665
666 // 8-bit
667 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
668 dec.encode_decode(
669 true,
670 w,
671 h,
672 speed,
673 quantizer,
674 limit,
675 8,
676 Default::default(),
677 15,
678 15,
679 0,
680 true,
681 false,
682 0,
683 0,
684 0,
685 false,
686 None,
687 );
688 }
689
690 fn high_bit_depth(decoder: &str, depth: usize) {
691 let quantizer = 100;
692 let limit = 3; // Include inter frames
693 let speed = 0; // Test as many tools as possible
694 let w = 64;
695 let h = 80;
696
697 let mut dec = get_decoder::<u16>(decoder, w as usize, h as usize);
698 dec.encode_decode(
699 true,
700 w,
701 h,
702 speed,
703 quantizer,
704 limit,
705 depth,
706 Default::default(),
707 15,
708 15,
709 0,
710 true,
711 false,
712 0,
713 0,
714 0,
715 false,
716 None,
717 );
718 }
719
720 macro_rules! test_high_bit_depth {
721 ($($B:expr),+) => {
722 $(
723 paste::item!{
724 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
725 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
726 #[ignore]
727 fn [<high_bit_depth_ $B>](decoder: &str) {
728 high_bit_depth(decoder, $B);
729 }
730 }
731 )*
732 }
733 }
734
735 test_high_bit_depth! {10, 12}
736
737 fn chroma_sampling(decoder: &str, cs: ChromaSampling) {
738 let quantizer = 100;
739 let limit = 3; // Include inter frames
740 let speed = 0; // Test as many tools as possible
741 let w = 64;
742 let h = 80;
743
744 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
745 dec.encode_decode(
746 true, w, h, speed, quantizer, limit, 8, cs, 15, 15, 0, true, false, 0, 0,
747 0, false, None,
748 );
749 }
750
751 macro_rules! test_chroma_sampling {
752 ($(($S:expr, $I:expr)),+) => {
753 $(
754 paste::item!{
755 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
756 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
757 #[ignore]
758 fn [<chroma_sampling_ $S>](decoder: &str) {
759 chroma_sampling(decoder, $I);
760 }
761 }
762 )*
763 }
764 }
765
766 test_chroma_sampling! {(400, ChromaSampling::Cs400), (420, ChromaSampling::Cs420),
767 (422, ChromaSampling::Cs422), (444, ChromaSampling::Cs444)}
768
769 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
770 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
771 fn tile_encoding_with_stretched_restoration_units(decoder: &str) {
772 let limit = 5;
773 let w = 256;
774 // the bottom tiles are small (their height is 140-128=12), so they will use stretched
775 // restoration units from their above neighbours
776 let h = 140;
777 let speed = 10;
778 let q = 100;
779
780 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
781 dec.encode_decode(
782 true,
783 w,
784 h,
785 speed,
786 q,
787 limit,
788 8,
789 Default::default(),
790 15,
791 15,
792 0,
793 true,
794 false,
795 0,
796 2,
797 2,
798 false,
799 None,
800 );
801 }
802
803 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
804 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
805 fn still_picture_mode(decoder: &str) {
806 let limit = 1;
807 let w = 480;
808 let h = 304;
809 let speed = 6;
810 let qindex = 100;
811
812 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
813 dec.encode_decode(
814 true,
815 w,
816 h,
817 speed,
818 qindex,
819 limit,
820 8,
821 Default::default(),
822 0,
823 0,
824 0,
825 false,
826 false,
827 0,
828 0,
829 0,
830 true,
831 None,
832 );
833 }
834
835 pub(crate) fn get_decoder<T: Pixel>(
836 decoder: &str, w: usize, h: usize,
837 ) -> Box<dyn TestDecoder<T>> {
838 match decoder {
839 #[cfg(feature = "decode_test")]
840 "aom" => Box::new(AomDecoder::<T>::setup_decoder(w, h)),
841 #[cfg(feature = "decode_test_dav1d")]
842 "dav1d" => Box::new(Dav1dDecoder::<T>::setup_decoder(w, h)),
843 _ => unimplemented!(),
844 }
845 }
846
847 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
848 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
849 #[ignore]
850 fn rdo_loop_decision_lrf_sanity(decoder: &str) {
851 let limit = 2;
852 let w = 936;
853 let h = 1404;
854 let speed = 9;
855 let q = 240;
856
857 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
858 dec.encode_decode(
859 true,
860 w,
861 h,
862 speed,
863 q,
864 limit,
865 8,
866 Default::default(),
867 6,
868 6,
869 0,
870 true,
871 false,
872 0,
873 0,
874 0,
875 false,
876 None,
877 );
878 }
879
880 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
881 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
882 #[ignore]
883 fn rdo_loop_decision_cdef_sanity(decoder: &str) {
884 let limit = 2;
885 let w = 1404;
886 let h = 936;
887 let speed = 9;
888 let q = 240;
889
890 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
891 dec.encode_decode(
892 true,
893 w,
894 h,
895 speed,
896 q,
897 limit,
898 8,
899 Default::default(),
900 6,
901 6,
902 0,
903 true,
904 false,
905 0,
906 0,
907 0,
908 false,
909 None,
910 );
911 }
912
913 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
914 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
915 #[ignore]
916 fn film_grain_table_luma_only(decoder: &str) {
917 let quantizer = 100;
918 let limit = 5; // Include inter frames
919 let speed = 10;
920 let w = 64;
921 let h = 80;
922
923 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
924 dec.encode_decode(
925 false,
926 w,
927 h,
928 speed,
929 quantizer,
930 limit,
931 8,
932 Default::default(),
933 15,
934 15,
935 0,
936 true,
937 false,
938 0,
939 0,
940 0,
941 false,
942 Some(vec![GrainTableSegment {
943 start_time: 0,
944 end_time: 9223372036854775807,
945 scaling_points_y: ArrayVec::from([
946 [0, 20],
947 [20, 5],
948 [39, 4],
949 [59, 3],
950 [78, 3],
951 [98, 3],
952 [118, 3],
953 [137, 3],
954 [157, 3],
955 [177, 3],
956 [196, 3],
957 [216, 4],
958 [235, 4],
959 [255, 4],
960 ]),
961 scaling_points_cb: ArrayVec::new(),
962 scaling_points_cr: ArrayVec::new(),
963 scaling_shift: 8,
964 ar_coeff_lag: 0,
965 ar_coeffs_y: ArrayVec::new(),
966 ar_coeffs_cb: ArrayVec::try_from([0].as_slice()).unwrap(),
967 ar_coeffs_cr: ArrayVec::try_from([0].as_slice()).unwrap(),
968 ar_coeff_shift: 6,
969 cb_mult: 0,
970 cb_luma_mult: 0,
971 cb_offset: 0,
972 cr_mult: 0,
973 cr_luma_mult: 0,
974 cr_offset: 0,
975 overlap_flag: true,
976 chroma_scaling_from_luma: false,
977 grain_scale_shift: 0,
978 random_seed: 7391,
979 }]),
980 );
981 }
982
983 #[cfg_attr(feature = "decode_test", interpolate_test(aom, "aom"))]
984 #[cfg_attr(feature = "decode_test_dav1d", interpolate_test(dav1d, "dav1d"))]
985 #[ignore]
986 fn film_grain_table_chroma(decoder: &str) {
987 let quantizer = 100;
988 let limit = 5; // Include inter frames
989 let speed = 10;
990 let w = 64;
991 let h = 80;
992
993 let mut dec = get_decoder::<u8>(decoder, w as usize, h as usize);
994 dec.encode_decode(
995 false,
996 w,
997 h,
998 speed,
999 quantizer,
1000 limit,
1001 8,
1002 Default::default(),
1003 15,
1004 15,
1005 0,
1006 true,
1007 false,
1008 0,
1009 0,
1010 0,
1011 false,
1012 Some(vec![GrainTableSegment {
1013 start_time: 0,
1014 end_time: 9223372036854775807,
1015 scaling_points_y: ArrayVec::from([
1016 [0, 0],
1017 [20, 4],
1018 [39, 3],
1019 [59, 3],
1020 [78, 3],
1021 [98, 3],
1022 [118, 4],
1023 [137, 4],
1024 [157, 4],
1025 [177, 4],
1026 [196, 4],
1027 [216, 5],
1028 [235, 5],
1029 [255, 5],
1030 ]),
1031 scaling_points_cb: ArrayVec::from([
1032 [0, 0],
1033 [28, 0],
1034 [57, 0],
1035 [85, 0],
1036 [113, 0],
1037 [142, 0],
1038 [170, 0],
1039 [198, 0],
1040 [227, 0],
1041 [255, 1],
1042 ]),
1043 scaling_points_cr: ArrayVec::from([
1044 [0, 0],
1045 [28, 0],
1046 [57, 0],
1047 [85, 0],
1048 [113, 0],
1049 [142, 0],
1050 [170, 0],
1051 [198, 0],
1052 [227, 0],
1053 [255, 1],
1054 ]),
1055 scaling_shift: 8,
1056 ar_coeff_lag: 0,
1057 ar_coeffs_y: ArrayVec::new(),
1058 ar_coeffs_cb: ArrayVec::try_from([0].as_slice()).unwrap(),
1059 ar_coeffs_cr: ArrayVec::try_from([0].as_slice()).unwrap(),
1060 ar_coeff_shift: 6,
1061 cb_mult: 128,
1062 cb_luma_mult: 192,
1063 cb_offset: 256,
1064 cr_mult: 128,
1065 cr_luma_mult: 192,
1066 cr_offset: 256,
1067 overlap_flag: true,
1068 chroma_scaling_from_luma: false,
1069 grain_scale_shift: 0,
1070 random_seed: 7391,
1071 }]),
1072 );
1073 }