| 1 |
use std::{ |
| 2 |
fmt, |
| 3 |
fmt::Display, |
| 4 |
ops::{Index, IndexMut}, |
| 5 |
}; |
| 6 |
|
| 7 |
use thiserror::Error; |
| 8 |
use v_frame::plane::PlaneOffset; |
| 9 |
|
| 10 |
use crate::data::{ |
| 11 |
plane::PlaneBlockOffset, |
| 12 |
superblock::{MI_SIZE_LOG2, SB_SIZE_LOG2}, |
| 13 |
}; |
| 14 |
|
| 15 |
pub const MAX_TX_SIZE: usize = 64; |
| 16 |
pub const BLOCK_TO_PLANE_SHIFT: usize = MI_SIZE_LOG2; |
| 17 |
pub const MIB_SIZE_LOG2: usize = SB_SIZE_LOG2 - MI_SIZE_LOG2; |
| 18 |
|
| 19 |
#[derive(Debug, Copy, Clone, PartialEq, Eq)] |
| 20 |
#[cfg_attr(test, derive(Default))] |
| 21 |
#[allow(non_camel_case_types)] |
| 22 |
pub enum BlockSize { |
| 23 |
BLOCK_4X4, |
| 24 |
BLOCK_4X8, |
| 25 |
BLOCK_8X4, |
| 26 |
BLOCK_8X8, |
| 27 |
BLOCK_8X16, |
| 28 |
BLOCK_16X8, |
| 29 |
BLOCK_16X16, |
| 30 |
BLOCK_16X32, |
| 31 |
BLOCK_32X16, |
| 32 |
BLOCK_32X32, |
| 33 |
BLOCK_32X64, |
| 34 |
BLOCK_64X32, |
| 35 |
#[cfg_attr(test, default)] |
| 36 |
BLOCK_64X64, |
| 37 |
BLOCK_64X128, |
| 38 |
BLOCK_128X64, |
| 39 |
BLOCK_128X128, |
| 40 |
BLOCK_4X16, |
| 41 |
BLOCK_16X4, |
| 42 |
BLOCK_8X32, |
| 43 |
BLOCK_32X8, |
| 44 |
BLOCK_16X64, |
| 45 |
BLOCK_64X16, |
| 46 |
} |
| 47 |
|
| 48 |
impl BlockSize { |
| 49 |
/// # Errors |
| 50 |
/// |
| 51 |
/// - Returns `InvalidBlockSize` if the given `w` and `h` do not produce a |
| 52 |
/// valid block size. |
| 53 |
pub fn from_width_and_height_opt(w: usize, h: usize) -> Result<BlockSize, InvalidBlockSize> { |
| 54 |
use crate::data::block::BlockSize::*; |
| 55 |
|
| 56 |
match (w, h) { |
| 57 |
(4, 4) => Ok(BLOCK_4X4), |
| 58 |
(4, 8) => Ok(BLOCK_4X8), |
| 59 |
(4, 16) => Ok(BLOCK_4X16), |
| 60 |
(8, 4) => Ok(BLOCK_8X4), |
| 61 |
(8, 8) => Ok(BLOCK_8X8), |
| 62 |
(8, 16) => Ok(BLOCK_8X16), |
| 63 |
(8, 32) => Ok(BLOCK_8X32), |
| 64 |
(16, 4) => Ok(BLOCK_16X4), |
| 65 |
(16, 8) => Ok(BLOCK_16X8), |
| 66 |
(16, 16) => Ok(BLOCK_16X16), |
| 67 |
(16, 32) => Ok(BLOCK_16X32), |
| 68 |
(16, 64) => Ok(BLOCK_16X64), |
| 69 |
(32, 8) => Ok(BLOCK_32X8), |
| 70 |
(32, 16) => Ok(BLOCK_32X16), |
| 71 |
(32, 32) => Ok(BLOCK_32X32), |
| 72 |
(32, 64) => Ok(BLOCK_32X64), |
| 73 |
(64, 16) => Ok(BLOCK_64X16), |
| 74 |
(64, 32) => Ok(BLOCK_64X32), |
| 75 |
(64, 64) => Ok(BLOCK_64X64), |
| 76 |
(64, 128) => Ok(BLOCK_64X128), |
| 77 |
(128, 64) => Ok(BLOCK_128X64), |
| 78 |
(128, 128) => Ok(BLOCK_128X128), |
| 79 |
_ => Err(InvalidBlockSize), |
| 80 |
} |
| 81 |
} |
| 82 |
|
| 83 |
/// # Panics |
| 84 |
/// |
| 85 |
/// - If the given `w` and `h` do not produce a valid block size. |
| 86 |
pub fn from_width_and_height(w: usize, h: usize) -> BlockSize { |
| 87 |
Self::from_width_and_height_opt(w, h).unwrap() |
| 88 |
} |
| 89 |
|
| 90 |
pub const fn width(self) -> usize { |
| 91 |
1 << self.width_log2() |
| 92 |
} |
| 93 |
|
| 94 |
pub const fn width_log2(self) -> usize { |
| 95 |
use crate::data::block::BlockSize::*; |
| 96 |
|
| 97 |
match self { |
| 98 |
BLOCK_4X4 | BLOCK_4X8 | BLOCK_4X16 => 2, |
| 99 |
BLOCK_8X4 | BLOCK_8X8 | BLOCK_8X16 | BLOCK_8X32 => 3, |
| 100 |
BLOCK_16X4 | BLOCK_16X8 | BLOCK_16X16 | BLOCK_16X32 | BLOCK_16X64 => 4, |
| 101 |
BLOCK_32X8 | BLOCK_32X16 | BLOCK_32X32 | BLOCK_32X64 => 5, |
| 102 |
BLOCK_64X16 | BLOCK_64X32 | BLOCK_64X64 | BLOCK_64X128 => 6, |
| 103 |
BLOCK_128X64 | BLOCK_128X128 => 7, |
| 104 |
} |
| 105 |
} |
| 106 |
|
| 107 |
pub const fn height(self) -> usize { |
| 108 |
1 << self.height_log2() |
| 109 |
} |
| 110 |
|
| 111 |
pub const fn height_log2(self) -> usize { |
| 112 |
use crate::data::block::BlockSize::*; |
| 113 |
|
| 114 |
match self { |
| 115 |
BLOCK_4X4 | BLOCK_8X4 | BLOCK_16X4 => 2, |
| 116 |
BLOCK_4X8 | BLOCK_8X8 | BLOCK_16X8 | BLOCK_32X8 => 3, |
| 117 |
BLOCK_4X16 | BLOCK_8X16 | BLOCK_16X16 | BLOCK_32X16 | BLOCK_64X16 => 4, |
| 118 |
BLOCK_8X32 | BLOCK_16X32 | BLOCK_32X32 | BLOCK_64X32 => 5, |
| 119 |
BLOCK_16X64 | BLOCK_32X64 | BLOCK_64X64 | BLOCK_128X64 => 6, |
| 120 |
BLOCK_64X128 | BLOCK_128X128 => 7, |
| 121 |
} |
| 122 |
} |
| 123 |
|
| 124 |
pub const fn tx_size(self) -> TxSize { |
| 125 |
use crate::data::block::{BlockSize::*, TxSize::*}; |
| 126 |
|
| 127 |
match self { |
| 128 |
BLOCK_4X4 => TX_4X4, |
| 129 |
BLOCK_4X8 => TX_4X8, |
| 130 |
BLOCK_8X4 => TX_8X4, |
| 131 |
BLOCK_8X8 => TX_8X8, |
| 132 |
BLOCK_8X16 => TX_8X16, |
| 133 |
BLOCK_16X8 => TX_16X8, |
| 134 |
BLOCK_16X16 => TX_16X16, |
| 135 |
BLOCK_16X32 => TX_16X32, |
| 136 |
BLOCK_32X16 => TX_32X16, |
| 137 |
BLOCK_32X32 => TX_32X32, |
| 138 |
BLOCK_32X64 => TX_32X64, |
| 139 |
BLOCK_64X32 => TX_64X32, |
| 140 |
BLOCK_4X16 => TX_4X16, |
| 141 |
BLOCK_16X4 => TX_16X4, |
| 142 |
BLOCK_8X32 => TX_8X32, |
| 143 |
BLOCK_32X8 => TX_32X8, |
| 144 |
BLOCK_16X64 => TX_16X64, |
| 145 |
BLOCK_64X16 => TX_64X16, |
| 146 |
_ => TX_64X64, |
| 147 |
} |
| 148 |
} |
| 149 |
} |
| 150 |
|
| 151 |
#[derive(Debug, Copy, Clone, Error, Eq, PartialEq)] |
| 152 |
pub struct InvalidBlockSize; |
| 153 |
|
| 154 |
impl Display for InvalidBlockSize { |
| 155 |
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 156 |
f.write_str("invalid block size") |
| 157 |
} |
| 158 |
} |
| 159 |
|
| 160 |
/// Transform Size |
| 161 |
#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)] |
| 162 |
#[allow(non_camel_case_types)] |
| 163 |
pub enum TxSize { |
| 164 |
TX_4X4, |
| 165 |
TX_8X8, |
| 166 |
TX_16X16, |
| 167 |
TX_32X32, |
| 168 |
TX_64X64, |
| 169 |
|
| 170 |
TX_4X8, |
| 171 |
TX_8X4, |
| 172 |
TX_8X16, |
| 173 |
TX_16X8, |
| 174 |
TX_16X32, |
| 175 |
TX_32X16, |
| 176 |
TX_32X64, |
| 177 |
TX_64X32, |
| 178 |
|
| 179 |
TX_4X16, |
| 180 |
TX_16X4, |
| 181 |
TX_8X32, |
| 182 |
TX_32X8, |
| 183 |
TX_16X64, |
| 184 |
TX_64X16, |
| 185 |
} |
| 186 |
|
| 187 |
impl TxSize { |
| 188 |
pub const fn width(self) -> usize { |
| 189 |
1 << self.width_log2() |
| 190 |
} |
| 191 |
|
| 192 |
pub const fn width_log2(self) -> usize { |
| 193 |
use crate::data::block::TxSize::*; |
| 194 |
match self { |
| 195 |
TX_4X4 | TX_4X8 | TX_4X16 => 2, |
| 196 |
TX_8X8 | TX_8X4 | TX_8X16 | TX_8X32 => 3, |
| 197 |
TX_16X16 | TX_16X8 | TX_16X32 | TX_16X4 | TX_16X64 => 4, |
| 198 |
TX_32X32 | TX_32X16 | TX_32X64 | TX_32X8 => 5, |
| 199 |
TX_64X64 | TX_64X32 | TX_64X16 => 6, |
| 200 |
} |
| 201 |
} |
| 202 |
|
| 203 |
pub const fn height(self) -> usize { |
| 204 |
1 << self.height_log2() |
| 205 |
} |
| 206 |
|
| 207 |
pub const fn height_log2(self) -> usize { |
| 208 |
use crate::data::block::TxSize::*; |
| 209 |
match self { |
| 210 |
TX_4X4 | TX_8X4 | TX_16X4 => 2, |
| 211 |
TX_8X8 | TX_4X8 | TX_16X8 | TX_32X8 => 3, |
| 212 |
TX_16X16 | TX_8X16 | TX_32X16 | TX_4X16 | TX_64X16 => 4, |
| 213 |
TX_32X32 | TX_16X32 | TX_64X32 | TX_8X32 => 5, |
| 214 |
TX_64X64 | TX_32X64 | TX_16X64 => 6, |
| 215 |
} |
| 216 |
} |
| 217 |
} |
| 218 |
|
| 219 |
/// Absolute offset in blocks, where a block is defined |
| 220 |
/// to be an `N*N` square where `N == (1 << BLOCK_TO_PLANE_SHIFT)`. |
| 221 |
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] |
| 222 |
pub struct BlockOffset { |
| 223 |
pub x: usize, |
| 224 |
pub y: usize, |
| 225 |
} |
| 226 |
|
| 227 |
impl BlockOffset { |
| 228 |
/// Convert to plane offset without decimation. |
| 229 |
pub const fn to_luma_plane_offset(self) -> PlaneOffset { |
| 230 |
PlaneOffset { |
| 231 |
x: (self.x as isize) << BLOCK_TO_PLANE_SHIFT, |
| 232 |
y: (self.y as isize) << BLOCK_TO_PLANE_SHIFT, |
| 233 |
} |
| 234 |
} |
| 235 |
|
| 236 |
pub fn with_offset(self, col_offset: isize, row_offset: isize) -> BlockOffset { |
| 237 |
let x = self.x as isize + col_offset; |
| 238 |
let y = self.y as isize + row_offset; |
| 239 |
debug_assert!(x >= 0); |
| 240 |
debug_assert!(y >= 0); |
| 241 |
|
| 242 |
BlockOffset { |
| 243 |
x: x as usize, |
| 244 |
y: y as usize, |
| 245 |
} |
| 246 |
} |
| 247 |
} |
| 248 |
|
| 249 |
#[derive(Clone)] |
| 250 |
pub struct FrameBlocks { |
| 251 |
blocks: Box<[Block]>, |
| 252 |
pub cols: usize, |
| 253 |
} |
| 254 |
|
| 255 |
impl Index<usize> for FrameBlocks { |
| 256 |
type Output = [Block]; |
| 257 |
|
| 258 |
fn index(&self, index: usize) -> &Self::Output { |
| 259 |
&self.blocks[index * self.cols..(index + 1) * self.cols] |
| 260 |
} |
| 261 |
} |
| 262 |
|
| 263 |
impl IndexMut<usize> for FrameBlocks { |
| 264 |
fn index_mut(&mut self, index: usize) -> &mut Self::Output { |
| 265 |
&mut self.blocks[index * self.cols..(index + 1) * self.cols] |
| 266 |
} |
| 267 |
} |
| 268 |
|
| 269 |
// for convenience, also index by BlockOffset |
| 270 |
|
| 271 |
impl Index<PlaneBlockOffset> for FrameBlocks { |
| 272 |
type Output = Block; |
| 273 |
|
| 274 |
fn index(&self, bo: PlaneBlockOffset) -> &Self::Output { |
| 275 |
&self[bo.0.y][bo.0.x] |
| 276 |
} |
| 277 |
} |
| 278 |
|
| 279 |
impl IndexMut<PlaneBlockOffset> for FrameBlocks { |
| 280 |
fn index_mut(&mut self, bo: PlaneBlockOffset) -> &mut Self::Output { |
| 281 |
&mut self[bo.0.y][bo.0.x] |
| 282 |
} |
| 283 |
} |
| 284 |
|
| 285 |
#[derive(Copy, Clone, Default)] |
| 286 |
pub struct Block {} |