Debian Codegraph @

.cargo/vendor/rav1e/src/tiling/tiler.rs

raw
1 // Copyright (c) 2019-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 use super::*;
11
12 use crate::context::*;
13 use crate::encoder::*;
14 use crate::me::WriteGuardMEStats;
15 use crate::util::*;
16
17 use std::iter::FusedIterator;
18 use std::marker::PhantomData;
19 use std::ops::DerefMut;
20
21 pub const MAX_TILE_WIDTH: usize = 4096;
22 pub const MAX_TILE_AREA: usize = 4096 * 2304;
23 pub const MAX_TILE_COLS: usize = 64;
24 pub const MAX_TILE_ROWS: usize = 64;
25 pub const MAX_TILE_RATE: f64 = 4096f64 * 2176f64 * 60f64 * 1.1;
26
27 /// Tiling information
28 ///
29 /// This stores everything necessary to split a frame into tiles, and write
30 /// headers fields into the bitstream.
31 ///
32 /// The method `tile_iter_mut()` actually provides tiled views of `FrameState`
33 /// and `FrameBlocks`.
34 #[derive(Debug, Clone, Copy)]
35 pub struct TilingInfo {
36 pub frame_width: usize,
37 pub frame_height: usize,
38 pub tile_width_sb: usize,
39 pub tile_height_sb: usize,
40 pub cols: usize, // number of columns of tiles within the whole frame
41 pub rows: usize, // number of rows of tiles within the whole frame
42 pub tile_cols_log2: usize,
43 pub tile_rows_log2: usize,
44 pub min_tile_cols_log2: usize,
45 pub max_tile_cols_log2: usize,
46 pub min_tile_rows_log2: usize,
47 pub max_tile_rows_log2: usize,
48 pub sb_size_log2: usize,
49 pub min_tiles_log2: usize,
50 }
51
52 impl TilingInfo {
53 /// # Panics
54 ///
55 /// Panics if the resulting tile sizes would be too large.
56 pub fn from_target_tiles(
57 sb_size_log2: usize, frame_width: usize, frame_height: usize,
58 frame_rate: f64, tile_cols_log2: usize, tile_rows_log2: usize,
59 is_422_p: bool,
60 ) -> Self {
61 // <https://aomediacodec.github.io/av1-spec/#tile-info-syntax>
62
63 // Frame::new() aligns to the next multiple of 8
64 let frame_width = frame_width.align_power_of_two(3);
65 let frame_height = frame_height.align_power_of_two(3);
66 let frame_width_sb =
67 frame_width.align_power_of_two_and_shift(sb_size_log2);
68 let frame_height_sb =
69 frame_height.align_power_of_two_and_shift(sb_size_log2);
70 let sb_cols = frame_width.align_power_of_two_and_shift(sb_size_log2);
71 let sb_rows = frame_height.align_power_of_two_and_shift(sb_size_log2);
72
73 // these are bitstream-defined values and must not be changed
74 let max_tile_width_sb = MAX_TILE_WIDTH >> sb_size_log2;
75 let max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size_log2);
76 let min_tile_cols_log2 =
77 Self::tile_log2(max_tile_width_sb, sb_cols).unwrap();
78 let max_tile_cols_log2 =
79 Self::tile_log2(1, sb_cols.min(MAX_TILE_COLS)).unwrap();
80 let max_tile_rows_log2 =
81 Self::tile_log2(1, sb_rows.min(MAX_TILE_ROWS)).unwrap();
82 let min_tiles_log2 = min_tile_cols_log2
83 .max(Self::tile_log2(max_tile_area_sb, sb_cols * sb_rows).unwrap());
84
85 // Implements restriction in Annex A of the spec.
86 // Unlike the other restrictions, this one does not change
87 // the header coding of the tile rows/cols.
88 let min_tiles_ratelimit_log2 = min_tiles_log2.max(
89 ((frame_width * frame_height) as f64 * frame_rate / MAX_TILE_RATE)
90 .ceil()
91 .log2()
92 .ceil() as usize,
93 );
94
95 let tile_cols_log2 =
96 tile_cols_log2.clamp(min_tile_cols_log2, max_tile_cols_log2);
97 let tile_width_sb_pre =
98 sb_cols.align_power_of_two_and_shift(tile_cols_log2);
99
100 // If this is 4:2:2, our UV horizontal is subsampled but not our
101 // vertical. Loop Restoration Units must be square, so they
102 // will always have an even number of horizontal superblocks. For
103 // tiles and LRUs to align, tile_width_sb must be even in 4:2:2
104 // video.
105
106 // This is only relevant when doing loop restoration RDO inline
107 // with block/superblock encoding, that is, where tiles are
108 // relevant. If (when) we introduce optionally delaying loop-filter
109 // encode to after the partitioning loop, we won't need to make
110 // any 4:2:2 adjustment.
111
112 let tile_width_sb = if is_422_p {
113 (tile_width_sb_pre + 1) >> 1 << 1
114 } else {
115 tile_width_sb_pre
116 };
117
118 let cols = frame_width_sb.div_ceil(tile_width_sb);
119
120 // Adjust tile_cols_log2 in case of rounding tile_width_sb to even.
121 let tile_cols_log2 = Self::tile_log2(1, cols).unwrap();
122 assert!(tile_cols_log2 >= min_tile_cols_log2);
123
124 let min_tile_rows_log2 = min_tiles_log2.saturating_sub(tile_cols_log2);
125 let min_tile_rows_ratelimit_log2 =
126 min_tiles_ratelimit_log2.saturating_sub(tile_cols_log2);
127 let tile_rows_log2 = tile_rows_log2
128 .max(min_tile_rows_log2)
129 .clamp(min_tile_rows_ratelimit_log2, max_tile_rows_log2);
130 let tile_height_sb = sb_rows.align_power_of_two_and_shift(tile_rows_log2);
131
132 let rows = frame_height_sb.div_ceil(tile_height_sb);
133
134 Self {
135 frame_width,
136 frame_height,
137 tile_width_sb,
138 tile_height_sb,
139 cols,
140 rows,
141 tile_cols_log2,
142 tile_rows_log2,
143 min_tile_cols_log2,
144 max_tile_cols_log2,
145 min_tile_rows_log2,
146 max_tile_rows_log2,
147 sb_size_log2,
148 min_tiles_log2,
149 }
150 }
151
152 /// Return the smallest value for `k` such that `blkSize << k` is greater than
153 /// or equal to `target`.
154 ///
155 /// <https://aomediacodec.github.io/av1-spec/#tile-size-calculation-function>
156 pub fn tile_log2(blk_size: usize, target: usize) -> Option<usize> {
157 let mut k = 0;
158 while (blk_size.checked_shl(k)?) < target {
159 k += 1;
160 }
161 Some(k as usize)
162 }
163
164 #[inline(always)]
165 pub const fn tile_count(&self) -> usize {
166 self.cols * self.rows
167 }
168
169 /// Split frame-level structures into tiles
170 ///
171 /// Provide mutable tiled views of frame-level structures.
172 pub fn tile_iter_mut<'a, T: Pixel>(
173 &self, fs: &'a mut FrameState<T>, fb: &'a mut FrameBlocks,
174 ) -> TileContextIterMut<'a, T> {
175 let afs = fs as *mut _;
176 let afb = fb as *mut _;
177 let frame_me_stats = fs.frame_me_stats.write().expect("poisoned lock");
178 TileContextIterMut { ti: *self, fs: afs, fb: afb, next: 0, frame_me_stats }
179 }
180 }
181
182 /// Container for all tiled views
183 pub struct TileContextMut<'a, T: Pixel> {
184 pub ts: TileStateMut<'a, T>,
185 pub tb: TileBlocksMut<'a>,
186 }
187
188 /// Iterator over tiled views
189 pub struct TileContextIterMut<'a, T: Pixel> {
190 ti: TilingInfo,
191 fs: *mut FrameState<T>,
192 fb: *mut FrameBlocks,
193 frame_me_stats: WriteGuardMEStats<'a>,
194 next: usize,
195 }
196
197 impl<'a, T: Pixel> Iterator for TileContextIterMut<'a, T> {
198 type Item = TileContextMut<'a, T>;
199
200 fn next(&mut self) -> Option<Self::Item> {
201 if self.next < self.ti.rows * self.ti.cols {
202 let tile_col = self.next % self.ti.cols;
203 let tile_row = self.next / self.ti.cols;
204 let ctx = TileContextMut {
205 ts: {
206 // SAFETY: Multiple tiles mutably access this struct.
207 // The dimensions must be configured correctly to ensure
208 // the tiles do not overlap.
209 let fs = unsafe { &mut *self.fs };
210 // SAFETY: ditto
211 let frame_me_stats = unsafe {
212 let len = self.frame_me_stats.len();
213 let ptr = self.frame_me_stats.as_mut_ptr();
214 std::slice::from_raw_parts_mut(ptr, len)
215 };
216 let sbo = PlaneSuperBlockOffset(SuperBlockOffset {
217 x: tile_col * self.ti.tile_width_sb,
218 y: tile_row * self.ti.tile_height_sb,
219 });
220 let x = sbo.0.x << self.ti.sb_size_log2;
221 let y = sbo.0.y << self.ti.sb_size_log2;
222 let tile_width = self.ti.tile_width_sb << self.ti.sb_size_log2;
223 let tile_height = self.ti.tile_height_sb << self.ti.sb_size_log2;
224 let width = tile_width.min(self.ti.frame_width - x);
225 let height = tile_height.min(self.ti.frame_height - y);
226 TileStateMut::new(
227 fs,
228 sbo,
229 self.ti.sb_size_log2,
230 width,
231 height,
232 frame_me_stats,
233 )
234 },
235 tb: {
236 // SAFETY: Multiple tiles mutably access this struct.
237 // The dimensions must be configured correctly to ensure
238 // the tiles do not overlap.
239 let fb = unsafe { &mut *self.fb };
240 let tile_width_mi =
241 self.ti.tile_width_sb << (self.ti.sb_size_log2 - MI_SIZE_LOG2);
242 let tile_height_mi =
243 self.ti.tile_height_sb << (self.ti.sb_size_log2 - MI_SIZE_LOG2);
244 let x = tile_col * tile_width_mi;
245 let y = tile_row * tile_height_mi;
246 let cols = tile_width_mi.min(fb.cols - x);
247 let rows = tile_height_mi.min(fb.rows - y);
248 TileBlocksMut::new(fb, x, y, cols, rows)
249 },
250 };
251 self.next += 1;
252 Some(ctx)
253 } else {
254 None
255 }
256 }
257
258 fn size_hint(&self) -> (usize, Option<usize>) {
259 let remaining = self.ti.cols * self.ti.rows - self.next;
260 (remaining, Some(remaining))
261 }
262 }
263
264 impl<T: Pixel> ExactSizeIterator for TileContextIterMut<'_, T> {}
265 impl<T: Pixel> FusedIterator for TileContextIterMut<'_, T> {}
266
267 #[cfg(test)]
268 pub mod test {
269 use super::*;
270 use crate::api::*;
271 use crate::lrf::*;
272 use crate::mc::MotionVector;
273 use crate::predict::PredictionMode;
274 use std::sync::Arc;
275
276 #[test]
277 fn test_tiling_info_from_tile_count() {
278 let sb_size_log2 = 6;
279 let (width, height) = (160, 144);
280 let frame_rate = 25f64;
281
282 let ti = TilingInfo::from_target_tiles(
283 sb_size_log2,
284 width,
285 height,
286 frame_rate,
287 0,
288 0,
289 false,
290 );
291 assert_eq!(1, ti.cols);
292 assert_eq!(1, ti.rows);
293 assert_eq!(3, ti.tile_width_sb);
294 assert_eq!(3, ti.tile_height_sb);
295
296 let ti = TilingInfo::from_target_tiles(
297 sb_size_log2,
298 width,
299 height,
300 frame_rate,
301 1,
302 1,
303 false,
304 );
305 assert_eq!(2, ti.cols);
306 assert_eq!(2, ti.rows);
307 assert_eq!(2, ti.tile_width_sb);
308 assert_eq!(2, ti.tile_height_sb);
309
310 let ti = TilingInfo::from_target_tiles(
311 sb_size_log2,
312 width,
313 height,
314 frame_rate,
315 2,
316 2,
317 false,
318 );
319 assert_eq!(3, ti.cols);
320 assert_eq!(3, ti.rows);
321 assert_eq!(1, ti.tile_width_sb);
322 assert_eq!(1, ti.tile_height_sb);
323
324 // cannot split more than superblocks
325 let ti = TilingInfo::from_target_tiles(
326 sb_size_log2,
327 width,
328 height,
329 frame_rate,
330 10,
331 8,
332 false,
333 );
334 assert_eq!(3, ti.cols);
335 assert_eq!(3, ti.rows);
336 assert_eq!(1, ti.tile_width_sb);
337 assert_eq!(1, ti.tile_height_sb);
338
339 let ti = TilingInfo::from_target_tiles(
340 sb_size_log2,
341 1024,
342 1024,
343 frame_rate,
344 0,
345 0,
346 false,
347 );
348 assert_eq!(1, ti.cols);
349 assert_eq!(1, ti.rows);
350 assert_eq!(16, ti.tile_width_sb);
351 assert_eq!(16, ti.tile_height_sb);
352 }
353
354 fn setup(
355 width: usize, height: usize,
356 ) -> (FrameInvariants<u16>, FrameState<u16>, FrameBlocks, f64) {
357 // FrameInvariants aligns to the next multiple of 8, so using other values could make tests confusing
358 assert!(width.trailing_zeros() >= 3);
359 assert!(height.trailing_zeros() >= 3);
360 // We test only for 420 for now
361 let chroma_sampling = ChromaSampling::Cs420;
362 let config = Arc::new(EncoderConfig {
363 width,
364 height,
365 bit_depth: 8,
366 chroma_sampling,
367 ..Default::default()
368 });
369 let mut sequence = Sequence::new(&config);
370 // These tests are all assuming SB-sized LRUs, so set that.
371 sequence.enable_large_lru = false;
372 let frame_rate = config.frame_rate();
373 let fi = FrameInvariants::new(config, Arc::new(sequence));
374 let fs = FrameState::new(&fi);
375 let fb = FrameBlocks::new(fi.w_in_b, fi.h_in_b);
376
377 (fi, fs, fb, frame_rate)
378 }
379
380 #[test]
381 fn test_tile_iter_len() {
382 // frame size 160x144, 40x36 in 4x4-blocks
383 let (fi, mut fs, mut fb, frame_rate) = setup(160, 144);
384
385 {
386 // 2x2 tiles
387 let ti = TilingInfo::from_target_tiles(
388 fi.sb_size_log2(),
389 fi.width,
390 fi.height,
391 frame_rate,
392 1,
393 1,
394 false,
395 );
396 let mut iter = ti.tile_iter_mut(&mut fs, &mut fb);
397 assert_eq!(4, iter.len());
398 assert!(iter.next().is_some());
399 assert_eq!(3, iter.len());
400 assert!(iter.next().is_some());
401 assert_eq!(2, iter.len());
402 assert!(iter.next().is_some());
403 assert_eq!(1, iter.len());
404 assert!(iter.next().is_some());
405 assert_eq!(0, iter.len());
406 assert!(iter.next().is_none());
407 }
408
409 {
410 // 4x4 tiles requested, will actually get 3x3 tiles
411 let ti = TilingInfo::from_target_tiles(
412 fi.sb_size_log2(),
413 fi.width,
414 fi.height,
415 frame_rate,
416 2,
417 2,
418 false,
419 );
420 let mut iter = ti.tile_iter_mut(&mut fs, &mut fb);
421 assert_eq!(9, iter.len());
422 assert!(iter.next().is_some());
423 assert_eq!(8, iter.len());
424 assert!(iter.next().is_some());
425 assert_eq!(7, iter.len());
426 assert!(iter.next().is_some());
427 assert_eq!(6, iter.len());
428 assert!(iter.next().is_some());
429 assert_eq!(5, iter.len());
430 assert!(iter.next().is_some());
431 assert_eq!(4, iter.len());
432 assert!(iter.next().is_some());
433 assert_eq!(3, iter.len());
434 assert!(iter.next().is_some());
435 assert_eq!(2, iter.len());
436 assert!(iter.next().is_some());
437 assert_eq!(1, iter.len());
438 assert!(iter.next().is_some());
439 assert_eq!(0, iter.len());
440 assert!(iter.next().is_none());
441 }
442 }
443
444 #[inline]
445 fn rect<T: Pixel>(
446 region: &PlaneRegionMut<'_, T>,
447 ) -> (isize, isize, usize, usize) {
448 let &Rect { x, y, width, height } = region.rect();
449 (x, y, width, height)
450 }
451
452 #[test]
453 fn test_tile_area() {
454 let (fi, mut fs, mut fb, frame_rate) = setup(160, 144);
455
456 // 4x4 tiles requested, will actually get 3x3 tiles
457 let ti = TilingInfo::from_target_tiles(
458 fi.sb_size_log2(),
459 fi.width,
460 fi.height,
461 frame_rate,
462 2,
463 2,
464 false,
465 );
466 let iter = ti.tile_iter_mut(&mut fs, &mut fb);
467 let tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
468
469 // the frame must be split into 9 tiles:
470 //
471 // luma (Y) chroma (U) chroma (V)
472 // 64x64 64x64 32x64 32x32 32x32 16x32 32x32 32x32 16x32
473 // 64x64 64x64 32x64 32x32 32x32 16x32 32x32 32x32 16x32
474 // 64x16 64x16 32x16 32x 8 32x 8 16x 8 32x 8 32x 8 16x 8
475
476 assert_eq!(9, tile_states.len());
477
478 let tile = &tile_states[0].rec; // the top-left tile
479 assert_eq!((0, 0, 64, 64), rect(&tile.planes[0]));
480 assert_eq!((0, 0, 32, 32), rect(&tile.planes[1]));
481 assert_eq!((0, 0, 32, 32), rect(&tile.planes[2]));
482
483 let tile = &tile_states[1].rec; // the top-middle tile
484 assert_eq!((64, 0, 64, 64), rect(&tile.planes[0]));
485 assert_eq!((32, 0, 32, 32), rect(&tile.planes[1]));
486 assert_eq!((32, 0, 32, 32), rect(&tile.planes[2]));
487
488 let tile = &tile_states[2].rec; // the top-right tile
489 assert_eq!((128, 0, 64, 64), rect(&tile.planes[0]));
490 assert_eq!((64, 0, 32, 32), rect(&tile.planes[1]));
491 assert_eq!((64, 0, 32, 32), rect(&tile.planes[2]));
492
493 let tile = &tile_states[3].rec; // the middle-left tile
494 assert_eq!((0, 64, 64, 64), rect(&tile.planes[0]));
495 assert_eq!((0, 32, 32, 32), rect(&tile.planes[1]));
496 assert_eq!((0, 32, 32, 32), rect(&tile.planes[2]));
497
498 let tile = &tile_states[4].rec; // the center tile
499 assert_eq!((64, 64, 64, 64), rect(&tile.planes[0]));
500 assert_eq!((32, 32, 32, 32), rect(&tile.planes[1]));
501 assert_eq!((32, 32, 32, 32), rect(&tile.planes[2]));
502
503 let tile = &tile_states[5].rec; // the middle-right tile
504 assert_eq!((128, 64, 64, 64), rect(&tile.planes[0]));
505 assert_eq!((64, 32, 32, 32), rect(&tile.planes[1]));
506 assert_eq!((64, 32, 32, 32), rect(&tile.planes[2]));
507
508 let tile = &tile_states[6].rec; // the bottom-left tile
509 assert_eq!((0, 128, 64, 64), rect(&tile.planes[0]));
510 assert_eq!((0, 64, 32, 32), rect(&tile.planes[1]));
511 assert_eq!((0, 64, 32, 32), rect(&tile.planes[2]));
512
513 let tile = &tile_states[7].rec; // the bottom-middle tile
514 assert_eq!((64, 128, 64, 64), rect(&tile.planes[0]));
515 assert_eq!((32, 64, 32, 32), rect(&tile.planes[1]));
516 assert_eq!((32, 64, 32, 32), rect(&tile.planes[2]));
517
518 let tile = &tile_states[8].rec; // the bottom-right tile
519 assert_eq!((128, 128, 64, 64), rect(&tile.planes[0]));
520 assert_eq!((64, 64, 32, 32), rect(&tile.planes[1]));
521 assert_eq!((64, 64, 32, 32), rect(&tile.planes[2]));
522 }
523
524 #[inline]
525 const fn b_area(region: &TileBlocksMut<'_>) -> (usize, usize, usize, usize) {
526 (region.x(), region.y(), region.cols(), region.rows())
527 }
528
529 #[test]
530 fn test_tile_blocks_area() {
531 let (fi, mut fs, mut fb, frame_rate) = setup(160, 144);
532
533 // 4x4 tiles requested, will actually get 3x3 tiles
534 let ti = TilingInfo::from_target_tiles(
535 fi.sb_size_log2(),
536 fi.width,
537 fi.height,
538 frame_rate,
539 2,
540 2,
541 false,
542 );
543 let iter = ti.tile_iter_mut(&mut fs, &mut fb);
544 let tbs = iter.map(|ctx| ctx.tb).collect::<Vec<_>>();
545
546 // the FrameBlocks must be split into 9 TileBlocks:
547 //
548 // 16x16 16x16 8x16
549 // 16x16 16x16 8x16
550 // 16x 4 16x4 8x 4
551
552 assert_eq!(9, tbs.len());
553
554 assert_eq!((0, 0, 16, 16), b_area(&tbs[0]));
555 assert_eq!((16, 0, 16, 16), b_area(&tbs[1]));
556 assert_eq!((32, 0, 8, 16), b_area(&tbs[2]));
557
558 assert_eq!((0, 16, 16, 16), b_area(&tbs[3]));
559 assert_eq!((16, 16, 16, 16), b_area(&tbs[4]));
560 assert_eq!((32, 16, 8, 16), b_area(&tbs[5]));
561
562 assert_eq!((0, 32, 16, 4), b_area(&tbs[6]));
563 assert_eq!((16, 32, 16, 4), b_area(&tbs[7]));
564 assert_eq!((32, 32, 8, 4), b_area(&tbs[8]));
565 }
566
567 #[test]
568 fn test_tile_write() {
569 let (fi, mut fs, mut fb, frame_rate) = setup(160, 144);
570
571 {
572 // 4x4 tiles requested, will actually get 3x3 tiles
573 let ti = TilingInfo::from_target_tiles(
574 fi.sb_size_log2(),
575 fi.width,
576 fi.height,
577 frame_rate,
578 2,
579 2,
580 false,
581 );
582 let iter = ti.tile_iter_mut(&mut fs, &mut fb);
583 let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
584
585 {
586 // row 12 of Y-plane of the top-left tile
587 let tile_plane = &mut tile_states[0].rec.planes[0];
588 let row = &mut tile_plane[12];
589 assert_eq!(64, row.len());
590 row[35..41].copy_from_slice(&[4, 42, 12, 18, 15, 31]);
591 }
592
593 {
594 // row 8 of U-plane of the middle-right tile
595 let tile_plane = &mut tile_states[5].rec.planes[1];
596 let row = &mut tile_plane[8];
597 assert_eq!(32, row.len());
598 row[..4].copy_from_slice(&[14, 121, 1, 3]);
599 }
600
601 {
602 // row 1 of V-plane of the bottom-middle tile
603 let tile_plane = &mut tile_states[7].rec.planes[2];
604 let row = &mut tile_plane[1];
605 assert_eq!(32, row.len());
606 row[11..16].copy_from_slice(&[6, 5, 2, 11, 8]);
607 }
608 }
609
610 // check that writes on tiles correctly affected the underlying frame
611
612 let plane = &fs.rec.planes[0];
613 let y = plane.cfg.yorigin + 12;
614 let x = plane.cfg.xorigin + 35;
615 let idx = y * plane.cfg.stride + x;
616 assert_eq!(&[4, 42, 12, 18, 15, 31], &plane.data[idx..idx + 6]);
617
618 let plane = &fs.rec.planes[1];
619 let offset = (64, 32); // middle-right tile, chroma plane
620 let y = plane.cfg.yorigin + offset.1 + 8;
621 let x = plane.cfg.xorigin + offset.0;
622 let idx = y * plane.cfg.stride + x;
623 assert_eq!(&[14, 121, 1, 3], &plane.data[idx..idx + 4]);
624
625 let plane = &fs.rec.planes[2];
626 let offset = (32, 64); // bottom-middle tile, chroma plane
627 let y = plane.cfg.yorigin + offset.1 + 1;
628 let x = plane.cfg.xorigin + offset.0 + 11;
629 let idx = y * plane.cfg.stride + x;
630 assert_eq!(&[6, 5, 2, 11, 8], &plane.data[idx..idx + 5]);
631 }
632
633 #[test]
634 fn test_tile_restoration_edges() {
635 let (fi, mut fs, mut fb, frame_rate) = setup(64, 80);
636
637 let ti = TilingInfo::from_target_tiles(
638 fi.sb_size_log2(),
639 fi.width,
640 fi.height,
641 frame_rate,
642 2,
643 2,
644 false,
645 );
646 let iter = ti.tile_iter_mut(&mut fs, &mut fb);
647 let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
648
649 assert_eq!(tile_states.len(), 2);
650
651 {
652 let trs = &mut tile_states[0].restoration;
653 let units = &trs.planes[0].units;
654 assert_eq!(units.x(), 0);
655 assert_eq!(units.y(), 0);
656 assert_eq!(units.cols(), 1);
657 assert_eq!(units.rows(), 1);
658 }
659
660 {
661 let trs = &mut tile_states[1].restoration;
662 let units = &trs.planes[0].units;
663 assert_eq!(units.x(), 0);
664 assert_eq!(units.y(), 1);
665 // no units, the tile is too small (less than 1/2 super-block)
666 assert_eq!(units.cols() * units.rows(), 0);
667 }
668 }
669
670 #[test]
671 fn test_tile_restoration_write() {
672 let (fi, mut fs, mut fb, frame_rate) = setup(256, 256);
673
674 {
675 // 2x2 tiles, each one containing 2×2 restoration units (1 super-block per restoration unit)
676 let ti = TilingInfo::from_target_tiles(
677 fi.sb_size_log2(),
678 fi.width,
679 fi.height,
680 frame_rate,
681 1,
682 1,
683 false,
684 );
685 let iter = ti.tile_iter_mut(&mut fs, &mut fb);
686 let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
687
688 {
689 // unit (1, 0) of Y-plane of the top-left tile
690 let units = &mut tile_states[0].restoration.planes[0].units;
691 units[0][1].filter =
692 RestorationFilter::Wiener { coeffs: [[1, 2, 3], [4, 5, 6]] };
693 }
694
695 {
696 // unit (0, 1) of U-plane of the bottom-right tile
697 let units = &mut tile_states[3].restoration.planes[1].units;
698 units[1][0].filter =
699 RestorationFilter::Sgrproj { set: 42, xqd: [10, 20] };
700 }
701
702 {
703 // unit (1, 1) of V-plane of the bottom-left tile
704 let units = &mut tile_states[2].restoration.planes[2].units;
705 units[1][1].filter =
706 RestorationFilter::Sgrproj { set: 5, xqd: [1, 2] };
707 }
708 }
709
710 // check that writes on tiles correctly affected the underlying restoration units
711
712 let units = &mut fs.restoration.planes[0].units;
713 assert_eq!(
714 units[0][1].filter,
715 RestorationFilter::Wiener { coeffs: [[1, 2, 3], [4, 5, 6]] }
716 );
717
718 let units = &mut fs.restoration.planes[1].units;
719 assert_eq!(
720 units[3][2].filter,
721 RestorationFilter::Sgrproj { set: 42, xqd: [10, 20] }
722 );
723
724 let units = &mut fs.restoration.planes[2].units;
725 assert_eq!(
726 units[3][1].filter,
727 RestorationFilter::Sgrproj { set: 5, xqd: [1, 2] }
728 );
729 }
730
731 #[test]
732 fn test_tile_motion_vectors_write() {
733 let (fi, mut fs, mut fb, frame_rate) = setup(160, 144);
734
735 {
736 // 4x4 tiles requested, will actually get 3x3 tiles
737 let ti = TilingInfo::from_target_tiles(
738 fi.sb_size_log2(),
739 fi.width,
740 fi.height,
741 frame_rate,
742 2,
743 2,
744 false,
745 );
746 let iter = ti.tile_iter_mut(&mut fs, &mut fb);
747 let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
748
749 {
750 // block (8, 5) of the top-left tile (of the first ref frame)
751 let me_stats = &mut tile_states[0].me_stats[0];
752 me_stats[5][8].mv = MotionVector { col: 42, row: 38 };
753 println!("{:?}", me_stats[5][8].mv);
754 }
755
756 {
757 // block (4, 2) of the middle-right tile (of ref frame 2)
758 let me_stats = &mut tile_states[5].me_stats[2];
759 me_stats[2][3].mv = MotionVector { col: 2, row: 14 };
760 }
761 }
762
763 // check that writes on tiled views affected the underlying motion vectors
764
765 let me_stats = &fs.frame_me_stats.read().unwrap()[0];
766 assert_eq!(MotionVector { col: 42, row: 38 }, me_stats[5][8].mv);
767
768 let me_stats = &fs.frame_me_stats.read().unwrap()[2];
769 let mix = (128 >> MI_SIZE_LOG2) + 3;
770 let miy = (64 >> MI_SIZE_LOG2) + 2;
771 assert_eq!(MotionVector { col: 2, row: 14 }, me_stats[miy][mix].mv);
772 }
773
774 #[test]
775 fn test_tile_blocks_write() {
776 let (fi, mut fs, mut fb, frame_rate) = setup(160, 144);
777
778 {
779 // 4x4 tiles requested, will actually get 3x3 tiles
780 let ti = TilingInfo::from_target_tiles(
781 fi.sb_size_log2(),
782 fi.width,
783 fi.height,
784 frame_rate,
785 2,
786 2,
787 false,
788 );
789 let iter = ti.tile_iter_mut(&mut fs, &mut fb);
790 let mut tbs = iter.map(|ctx| ctx.tb).collect::<Vec<_>>();
791
792 {
793 // top-left tile
794 let tb = &mut tbs[0];
795 // block (4, 3)
796 tb[3][4].n4_w = 42;
797 // block (8, 5)
798 tb[5][8].segmentation_idx = 14;
799 }
800
801 {
802 // middle-right tile
803 let tb = &mut tbs[5];
804 // block (0, 1)
805 tb[1][0].n4_h = 11;
806 // block (7, 5)
807 tb[5][7].cdef_index = 3;
808 }
809
810 {
811 // bottom-middle tile
812 let tb = &mut tbs[7];
813 // block (3, 2)
814 tb[2][3].mode = PredictionMode::PAETH_PRED;
815 // block (1, 1)
816 tb[1][1].n4_w = 8;
817 }
818 }
819
820 // check that writes on tiles correctly affected the underlying blocks
821
822 assert_eq!(42, fb[3][4].n4_w);
823 assert_eq!(14, fb[5][8].segmentation_idx);
824
825 assert_eq!(11, fb[17][32].n4_h);
826 assert_eq!(3, fb[21][39].cdef_index);
827
828 assert_eq!(PredictionMode::PAETH_PRED, fb[34][19].mode);
829 assert_eq!(8, fb[33][17].n4_w);
830 }
831
832 #[test]
833 fn tile_log2_overflow() {
834 assert_eq!(TilingInfo::tile_log2(1, usize::MAX), None);
835 }
836
837 #[test]
838 fn from_target_tiles_422() {
839 let sb_size_log2 = 6;
840 let is_422_p = true;
841 let frame_rate = 60.;
842 let sb_size = 1 << sb_size_log2;
843
844 for frame_height in (sb_size..4352).step_by(sb_size) {
845 for tile_rows_log2 in
846 0..=TilingInfo::tile_log2(1, frame_height >> sb_size_log2).unwrap()
847 {
848 for frame_width in (sb_size..7680).step_by(sb_size) {
849 for tile_cols_log2 in
850 0..=TilingInfo::tile_log2(1, frame_width >> sb_size_log2).unwrap()
851 {
852 let ti = TilingInfo::from_target_tiles(
853 sb_size_log2,
854 frame_width,
855 frame_height,
856 frame_rate,
857 tile_cols_log2,
858 tile_rows_log2,
859 is_422_p,
860 );
861 assert_eq!(
862 ti.tile_cols_log2,
863 TilingInfo::tile_log2(1, ti.cols).unwrap()
864 );
865 assert_eq!(
866 ti.tile_rows_log2,
867 TilingInfo::tile_log2(1, ti.rows).unwrap()
868 );
869 }
870 }
871 }
872 }
873 }
874 }