1// Copyright (c) 2017-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
10use super::*;
11
12pub const MAX_SB_SIZE_LOG2: usize = 7;
13const SB_SIZE_LOG2: usize = 6;
14pub const SB_SIZE: usize = 1 << SB_SIZE_LOG2;
15const SB_SQUARE: usize = SB_SIZE * SB_SIZE;
16
17pub const MI_SIZE_LOG2: usize = 2;
18pub const MI_SIZE: usize = 1 << MI_SIZE_LOG2;
19pub const MAX_MIB_SIZE_LOG2: usize = MAX_SB_SIZE_LOG2 - MI_SIZE_LOG2;
20pub const MIB_SIZE_LOG2: usize = SB_SIZE_LOG2 - MI_SIZE_LOG2;
21pub const MIB_SIZE: usize = 1 << MIB_SIZE_LOG2;
22pub const MIB_MASK: usize = MIB_SIZE - 1;
23
24pub const SUPERBLOCK_TO_PLANE_SHIFT: usize = SB_SIZE_LOG2;
25pub const SUPERBLOCK_TO_BLOCK_SHIFT: usize = MIB_SIZE_LOG2;
26pub const BLOCK_TO_PLANE_SHIFT: usize = MI_SIZE_LOG2;
27pub const IMPORTANCE_BLOCK_TO_BLOCK_SHIFT: usize = 1;
28pub const LOCAL_BLOCK_MASK: usize = (1 << SUPERBLOCK_TO_BLOCK_SHIFT) - 1;
29
30pub const MAX_SB_IN_IMP_B: usize = 1
31 << (MAX_SB_SIZE_LOG2
32 - IMPORTANCE_BLOCK_TO_BLOCK_SHIFT
33 - BLOCK_TO_PLANE_SHIFT);
34
35/// Absolute offset in superblocks, where a superblock is defined
36/// to be an `N*N` square where `N == (1 << SUPERBLOCK_TO_PLANE_SHIFT)`.
37#[derive(Clone, Copy, Debug, PartialEq, Eq)]
38pub struct SuperBlockOffset {
39 pub x: usize,
40 pub y: usize,
41}
42
43/// Absolute offset in superblocks inside a plane, where a superblock is defined
44/// to be an `N*N` square where `N == (1 << SUPERBLOCK_TO_PLANE_SHIFT)`.
45#[derive(Clone, Copy, Debug, PartialEq, Eq)]
46pub struct PlaneSuperBlockOffset(pub SuperBlockOffset);
47
48/// Absolute offset in superblocks inside a tile, where a superblock is defined
49/// to be an `N*N` square where `N == (1 << SUPERBLOCK_TO_PLANE_SHIFT)`.
50#[derive(Clone, Copy, Debug, PartialEq, Eq)]
51pub struct TileSuperBlockOffset(pub SuperBlockOffset);
52
53impl SuperBlockOffset {
54 /// Offset of a block inside the current superblock.
55 #[inline]
56 const fn block_offset(self, block_x: usize, block_y: usize) -> BlockOffset {
57 BlockOffset {
58 x: (self.x << SUPERBLOCK_TO_BLOCK_SHIFT) + block_x,
59 y: (self.y << SUPERBLOCK_TO_BLOCK_SHIFT) + block_y,
60 }
61 }
62
63 /// Offset of the top-left pixel of this block.
64 #[inline]
65 const fn plane_offset(self, plane: &PlaneConfig) -> PlaneOffset {
66 PlaneOffset {
67 x: (self.x as isize) << (SUPERBLOCK_TO_PLANE_SHIFT - plane.xdec),
68 y: (self.y as isize) << (SUPERBLOCK_TO_PLANE_SHIFT - plane.ydec),
69 }
70 }
71}
72
73impl Add for SuperBlockOffset {
74 type Output = Self;
75 #[inline]
76 fn add(self, rhs: Self) -> Self::Output {
77 Self { x: self.x + rhs.x, y: self.y + rhs.y }
78 }
79}
80
81impl PlaneSuperBlockOffset {
82 /// Offset of a block inside the current superblock.
83 #[inline]
84 pub const fn block_offset(
85 self, block_x: usize, block_y: usize,
86 ) -> PlaneBlockOffset {
87 PlaneBlockOffset(self.0.block_offset(block_x, block_y))
88 }
89
90 /// Offset of the top-left pixel of this block.
91 #[inline]
92 pub const fn plane_offset(self, plane: &PlaneConfig) -> PlaneOffset {
93 self.0.plane_offset(plane)
94 }
95}
96
97impl Add for PlaneSuperBlockOffset {
98 type Output = Self;
99 #[inline]
100 fn add(self, rhs: Self) -> Self::Output {
101 PlaneSuperBlockOffset(self.0 + rhs.0)
102 }
103}
104
105impl TileSuperBlockOffset {
106 /// Offset of a block inside the current superblock.
107 #[inline]
108 pub const fn block_offset(
109 self, block_x: usize, block_y: usize,
110 ) -> TileBlockOffset {
111 TileBlockOffset(self.0.block_offset(block_x, block_y))
112 }
113
114 /// Offset of the top-left pixel of this block.
115 #[inline]
116 pub const fn plane_offset(self, plane: &PlaneConfig) -> PlaneOffset {
117 self.0.plane_offset(plane)
118 }
119}
120
121impl Add for TileSuperBlockOffset {
122 type Output = Self;
123 #[inline]
124 fn add(self, rhs: Self) -> Self::Output {
125 TileSuperBlockOffset(self.0 + rhs.0)
126 }
127}
128