// Copyright (c) 2017-2020, The rav1e contributors. All rights reserved // // This source code is subject to the terms of the BSD 2 Clause License and // the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License // was not distributed with this source code in the LICENSE file, you can // obtain it at www.aomedia.org/license/software. If the Alliance for Open // Media Patent License 1.0 was not distributed with this source code in the // PATENTS file, you can obtain it at www.aomedia.org/license/patent. #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(dead_code)] use crate::context::*; use crate::partition::BlockSize::*; use crate::partition::*; use crate::transform::*; static has_null: &[u8] = &[]; // Tables to store if the top-right reference pixels are available. The flags // are represented with bits, packed into 8-bit integers. E.g., for the 32x32 // blocks in a 128x128 superblock, the index of the "o" block is 10 (in raster // order), so its flag is stored at the 3rd bit of the 2nd entry in the table, // i.e. (table[10 / 8] >> (10 % 8)) & 1. // . . . . // . . . . // . . o . // . . . . #[rustfmt::skip] static has_tr_4x4: &[u8] = &[ 255, 255, 255, 255, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, 127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, 255, 127, 255, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, 127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, 255, 255, 255, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, 127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, 255, 127, 255, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, 127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85, ]; static has_tr_4x8: &[u8] = &[ 255, 255, 255, 255, 119, 119, 119, 119, 127, 127, 127, 127, 119, 119, 119, 119, 255, 127, 255, 127, 119, 119, 119, 119, 127, 127, 127, 127, 119, 119, 119, 119, 255, 255, 255, 127, 119, 119, 119, 119, 127, 127, 127, 127, 119, 119, 119, 119, 255, 127, 255, 127, 119, 119, 119, 119, 127, 127, 127, 127, 119, 119, 119, 119, ]; #[rustfmt::skip] static has_tr_8x4: &[u8] = &[ 255, 255, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0, 127, 127, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0, 255, 127, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0, 127, 127, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0, ]; #[rustfmt::skip] static has_tr_8x8: &[u8] = &[ 255, 255, 85, 85, 119, 119, 85, 85, 127, 127, 85, 85, 119, 119, 85, 85, 255, 127, 85, 85, 119, 119, 85, 85, 127, 127, 85, 85, 119, 119, 85, 85, ]; static has_tr_8x16: &[u8] = &[ 255, 255, 119, 119, 127, 127, 119, 119, 255, 127, 119, 119, 127, 127, 119, 119, ]; static has_tr_16x8: &[u8] = &[255, 0, 85, 0, 119, 0, 85, 0, 127, 0, 85, 0, 119, 0, 85, 0]; static has_tr_16x16: &[u8] = &[255, 85, 119, 85, 127, 85, 119, 85]; static has_tr_16x32: &[u8] = &[255, 119, 127, 119]; static has_tr_32x16: &[u8] = &[15, 5, 7, 5]; static has_tr_32x32: &[u8] = &[95, 87]; static has_tr_32x64: &[u8] = &[127]; static has_tr_64x32: &[u8] = &[19]; static has_tr_64x64: &[u8] = &[7]; static has_tr_64x128: &[u8] = &[3]; static has_tr_128x64: &[u8] = &[1]; static has_tr_128x128: &[u8] = &[1]; static has_tr_4x16: &[u8] = &[ 255, 255, 255, 255, 127, 127, 127, 127, 255, 127, 255, 127, 127, 127, 127, 127, 255, 255, 255, 127, 127, 127, 127, 127, 255, 127, 255, 127, 127, 127, 127, 127, ]; static has_tr_16x4: &[u8] = &[ 255, 0, 0, 0, 85, 0, 0, 0, 119, 0, 0, 0, 85, 0, 0, 0, 127, 0, 0, 0, 85, 0, 0, 0, 119, 0, 0, 0, 85, 0, 0, 0, ]; static has_tr_8x32: &[u8] = &[255, 255, 127, 127, 255, 127, 127, 127]; static has_tr_32x8: &[u8] = &[15, 0, 5, 0, 7, 0, 5, 0]; static has_tr_16x64: &[u8] = &[255, 127]; static has_tr_64x16: &[u8] = &[3, 1]; static has_tr_tables: &[&[u8]] = &[ has_tr_4x4, // 4x4 has_tr_4x8, // 4x8 has_tr_8x4, // 8x4 has_tr_8x8, // 8x8 has_tr_8x16, // 8x16 has_tr_16x8, // 16x8 has_tr_16x16, // 16x16 has_tr_16x32, // 16x32 has_tr_32x16, // 32x16 has_tr_32x32, // 32x32 has_tr_32x64, // 32x64 has_tr_64x32, // 64x32 has_tr_64x64, // 64x64 has_tr_64x128, // 64x128 has_tr_128x64, // 128x64 has_tr_128x128, // 128x128 has_tr_4x16, // 4x16 has_tr_16x4, // 16x4 has_tr_8x32, // 8x32 has_tr_32x8, // 32x8 has_tr_16x64, // 16x64 has_tr_64x16, // 64x16 ]; #[rustfmt::skip] static has_tr_vert_8x8: &[u8] = &[ 255, 255, 0, 0, 119, 119, 0, 0, 127, 127, 0, 0, 119, 119, 0, 0, 255, 127, 0, 0, 119, 119, 0, 0, 127, 127, 0, 0, 119, 119, 0, 0, ]; static has_tr_vert_16x16: &[u8] = &[255, 0, 119, 0, 127, 0, 119, 0]; static has_tr_vert_32x32: &[u8] = &[15, 7]; static has_tr_vert_64x64: &[u8] = &[3]; // The _vert_* tables are like the ordinary tables above, but describe the // order we visit square blocks when doing a PARTITION_VERT_A or // PARTITION_VERT_B. This is the same order as normal except for on the last // split where we go vertically (TL, BL, TR, BR). We treat the rectangular block // as a pair of squares, which means that these tables work correctly for both // mixed vertical partition types. // // There are tables for each of the square sizes. Vertical rectangles (like // BLOCK_16X32) use their respective "non-vert" table static has_tr_vert_tables: &[&[u8]] = &[ has_null, // 4X4 has_tr_4x8, // 4X8 has_null, // 8X4 has_tr_vert_8x8, // 8X8 has_tr_8x16, // 8X16 has_null, // 16X8 has_tr_vert_16x16, // 16X16 has_tr_16x32, // 16X32 has_null, // 32X16 has_tr_vert_32x32, // 32X32 has_tr_32x64, // 32X64 has_null, // 64X32 has_tr_vert_64x64, // 64X64 has_tr_64x128, // 64x128 has_null, // 128x64 has_tr_128x128, // 128x128 ]; // TODO: Enable the case for PARTITION_VERT_A/B once they can be encoded by rav1e. pub fn get_has_tr_table( /*partition: PartitionType, */ bsize: BlockSize, ) -> &'static [u8] { let ret: &[u8]; // If this is a mixed vertical partition, look up bsize in orders_vert. /*if partition == PartitionType::PARTITION_VERT_A || partition == PartitionType::PARTITION_VERT_B { debug_assert!(bsize < BlockSize::BLOCK_SIZES); ret = has_tr_vert_tables[bsize as usize]; } else */ { ret = has_tr_tables[bsize as usize]; } //debug_assert!(ret != ptr::has_null()); ret } pub fn has_top_right( bsize: BlockSize, partition_bo: TileBlockOffset, top_available: bool, right_available: bool, tx_size: TxSize, row_off: usize, col_off: usize, ss_x: usize, _ss_y: usize, ) -> bool { if !top_available || !right_available { return false; }; let bw_unit = bsize.width_mi(); let plane_bw_unit = (bw_unit >> ss_x).max(1); let top_right_count_unit = tx_size.width_mi(); let mi_col = partition_bo.0.x; let mi_row = partition_bo.0.y; if row_off > 0 { // Just need to check if enough pixels on the right. // 128x128 SB is not supported yet by rav1e if bsize.width() > BLOCK_64X64.width() { // Special case: For 128x128 blocks, the transform unit whose // top-right corner is at the center of the block does in fact have // pixels available at its top-right corner. if row_off == BLOCK_64X64.height_mi() >> _ss_y && col_off + top_right_count_unit == BLOCK_64X64.width_mi() >> ss_x { return false; } let plane_bw_unit_64 = BLOCK_64X64.width_mi() >> ss_x; let col_off_64 = col_off % plane_bw_unit_64; return col_off_64 + top_right_count_unit < plane_bw_unit_64; } col_off + top_right_count_unit < plane_bw_unit } else { // All top-right pixels are in the block above, which is already available. if col_off + top_right_count_unit < plane_bw_unit { return true; }; let bw_in_mi_log2 = bsize.width_log2() - MI_SIZE_LOG2; let bh_in_mi_log2 = bsize.height_log2() - MI_SIZE_LOG2; let sb_mi_size: usize = 16; // 64x64 let blk_row_in_sb = (mi_row & (sb_mi_size - 1)) >> bh_in_mi_log2; let blk_col_in_sb = (mi_col & (sb_mi_size - 1)) >> bw_in_mi_log2; // Top row of superblock: so top-right pixels are in the top and/or // top-right superblocks, both of which are already available. if blk_row_in_sb == 0 { return true; }; // Rightmost column of superblock (and not the top row): so top-right pixels // fall in the right superblock, which is not available yet. if ((blk_col_in_sb + 1) << bw_in_mi_log2) >= sb_mi_size { return false; }; // General case (neither top row nor rightmost column): check if the // top-right block is coded before the current block. let this_blk_index = (blk_row_in_sb << (MAX_MIB_SIZE_LOG2 - bw_in_mi_log2)) + blk_col_in_sb; let idx1 = this_blk_index / 8; let idx2 = this_blk_index % 8; let has_tr_table: &[u8] = get_has_tr_table(/*partition,*/ bsize); ((has_tr_table[idx1] >> idx2) & 1) != 0 } } // Similar to the has_tr_* tables, but store if the bottom-left reference // pixels are available. static has_bl_4x4: &[u8] = &[ 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 1, 0, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 0, 0, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 1, 0, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 0, 0, ]; static has_bl_4x8: &[u8] = &[ 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 1, 0, 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 0, 0, 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 1, 0, 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 0, 0, ]; static has_bl_8x4: &[u8] = &[ 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 1, 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 0, 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 1, 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 0, ]; static has_bl_8x8: &[u8] = &[ 84, 85, 16, 17, 84, 85, 0, 1, 84, 85, 16, 17, 84, 85, 0, 0, 84, 85, 16, 17, 84, 85, 0, 1, 84, 85, 16, 17, 84, 85, 0, 0, ]; static has_bl_8x16: &[u8] = &[16, 17, 0, 1, 16, 17, 0, 0, 16, 17, 0, 1, 16, 17, 0, 0]; static has_bl_16x8: &[u8] = &[254, 84, 254, 16, 254, 84, 254, 0, 254, 84, 254, 16, 254, 84, 254, 0]; static has_bl_16x16: &[u8] = &[84, 16, 84, 0, 84, 16, 84, 0]; static has_bl_16x32: &[u8] = &[16, 0, 16, 0]; static has_bl_32x16: &[u8] = &[78, 14, 78, 14]; static has_bl_32x32: &[u8] = &[4, 4]; static has_bl_32x64: &[u8] = &[0]; static has_bl_64x32: &[u8] = &[34]; static has_bl_64x64: &[u8] = &[0]; static has_bl_64x128: &[u8] = &[0]; static has_bl_128x64: &[u8] = &[0]; static has_bl_128x128: &[u8] = &[0]; static has_bl_4x16: &[u8] = &[ 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, ]; static has_bl_16x4: &[u8] = &[ 254, 254, 254, 84, 254, 254, 254, 16, 254, 254, 254, 84, 254, 254, 254, 0, 254, 254, 254, 84, 254, 254, 254, 16, 254, 254, 254, 84, 254, 254, 254, 0, ]; static has_bl_8x32: &[u8] = &[0, 1, 0, 0, 0, 1, 0, 0]; static has_bl_32x8: &[u8] = &[238, 78, 238, 14, 238, 78, 238, 14]; static has_bl_16x64: &[u8] = &[0, 0]; static has_bl_64x16: &[u8] = &[42, 42]; static has_bl_tables: &[&[u8]] = &[ has_bl_4x4, // 4x4 has_bl_4x8, // 4x8 has_bl_8x4, // 8x4 has_bl_8x8, // 8x8 has_bl_8x16, // 8x16 has_bl_16x8, // 16x8 has_bl_16x16, // 16x16 has_bl_16x32, // 16x32 has_bl_32x16, // 32x16 has_bl_32x32, // 32x32 has_bl_32x64, // 32x64 has_bl_64x32, // 64x32 has_bl_64x64, // 64x64 has_bl_64x128, // 64x128 has_bl_128x64, // 128x64 has_bl_128x128, // 128x128 has_bl_4x16, // 4x16 has_bl_16x4, // 16x4 has_bl_8x32, // 8x32 has_bl_32x8, // 32x8 has_bl_16x64, // 16x64 has_bl_64x16, // 64x16 ]; #[rustfmt::skip] static has_bl_vert_8x8: &[u8] = &[ 254, 255, 16, 17, 254, 255, 0, 1, 254, 255, 16, 17, 254, 255, 0, 0, 254, 255, 16, 17, 254, 255, 0, 1, 254, 255, 16, 17, 254, 255, 0, 0, ]; static has_bl_vert_16x16: &[u8] = &[254, 16, 254, 0, 254, 16, 254, 0]; static has_bl_vert_32x32: &[u8] = &[14, 14]; static has_bl_vert_64x64: &[u8] = &[2]; // The _vert_* tables are like the ordinary tables above, but describe the // order we visit square blocks when doing a PARTITION_VERT_A or // PARTITION_VERT_B. This is the same order as normal except for on the last // split where we go vertically (TL, BL, TR, BR). We treat the rectangular block // as a pair of squares, which means that these tables work correctly for both // mixed vertical partition types. // // There are tables for each of the square sizes. Vertical rectangles (like // BLOCK_16X32) use their respective "non-vert" table static has_bl_vert_tables: &[&[u8]] = &[ has_null, // 4x4 has_bl_4x8, // 4x8 has_null, // 8x4 has_bl_vert_8x8, // 8x8 has_bl_8x16, // 8x16 has_null, // 16x8 has_bl_vert_16x16, // 16x16 has_bl_16x32, // 16x32 has_null, // 32x16 has_bl_vert_32x32, // 32x32 has_bl_32x64, // 32x64 has_null, // 64x32 has_bl_vert_64x64, // 64x64 has_bl_64x128, // 64x128 has_null, // 128x64 has_bl_128x128, // 128x128 ]; pub fn get_has_bl_table( /*partition: PartitionType, */ bsize: BlockSize, ) -> &'static [u8] { let ret: &[u8]; // If this is a mixed vertical partition, look up bsize in orders_vert. /*if (partition == PARTITION_VERT_A || partition == PARTITION_VERT_B) { //assert(bsize < BLOCK_SIZES); ret = has_bl_vert_tables[bsize as usize]; } else*/ { ret = has_bl_tables[bsize as usize]; } //debug_assert!(ret != ptr::has_null()); ret } pub fn has_bottom_left( bsize: BlockSize, partition_bo: TileBlockOffset, bottom_available: bool, left_available: bool, tx_size: TxSize, row_off: usize, col_off: usize, _ss_x: usize, ss_y: usize, ) -> bool { if !bottom_available || !left_available { return false; }; // Special case for 128x* blocks, when col_off is half the block width. // This is needed because 128x* superblocks are divided into 64x* blocks in // raster order // 128x128 SB is not supported yet by rav1e if bsize.width() > BLOCK_64X64.width() && col_off > 0 { let plane_bw_unit_64 = BLOCK_64X64.width_mi() >> _ss_x; let col_off_64 = col_off % plane_bw_unit_64; if col_off_64 == 0 { // We are at the left edge of top-right or bottom-right 64x* block. let plane_bh_unit_64 = BLOCK_64X64.height_mi() >> ss_y; let row_off_64 = row_off % plane_bh_unit_64; let plane_bh_unit = (bsize.height_mi() >> ss_y).min(plane_bh_unit_64); // Check if all bottom-left pixels are in the left 64x* block (which is // already coded). return row_off_64 + tx_size.height_mi() < plane_bh_unit; } } if col_off > 0 { // Bottom-left pixels are in the bottom-left block, which is not available. false } else { let bh_unit = bsize.height_mi(); let plane_bh_unit = (bh_unit >> ss_y).max(1); let bottom_left_count_unit = tx_size.height_mi(); let mi_col = partition_bo.0.x; let mi_row = partition_bo.0.y; // All bottom-left pixels are in the left block, which is already available. if row_off + bottom_left_count_unit < plane_bh_unit { return true; }; let bw_in_mi_log2 = bsize.width_log2() - MI_SIZE_LOG2; let bh_in_mi_log2 = bsize.height_log2() - MI_SIZE_LOG2; let sb_mi_size: usize = 16; // 64x64 let blk_row_in_sb = (mi_row & (sb_mi_size - 1)) >> bh_in_mi_log2; let blk_col_in_sb = (mi_col & (sb_mi_size - 1)) >> bw_in_mi_log2; // Leftmost column of superblock: so bottom-left pixels maybe in the left // and/or bottom-left superblocks. But only the left superblock is // available, so check if all required pixels fall in that superblock. if blk_col_in_sb == 0 { let blk_start_row_off = blk_row_in_sb << bh_in_mi_log2 >> ss_y; let row_off_in_sb = blk_start_row_off + row_off; let sb_height_unit = sb_mi_size >> ss_y; return row_off_in_sb + bottom_left_count_unit < sb_height_unit; //return row_off_in_sb + (bottom_left_count_unit << 1) < sb_height_unit; // Don't it need tx height? again? } // Bottom row of superblock (and not the leftmost column): so bottom-left // pixels fall in the bottom superblock, which is not available yet. if ((blk_row_in_sb + 1) << bh_in_mi_log2) >= sb_mi_size { return false; }; // General case (neither leftmost column nor bottom row): check if the // bottom-left block is coded before the current block. let this_blk_index = (blk_row_in_sb << (MAX_MIB_SIZE_LOG2 - bw_in_mi_log2)) + blk_col_in_sb; let idx1 = this_blk_index / 8; let idx2 = this_blk_index % 8; let has_bl_table: &[u8] = get_has_bl_table(/*partition,*/ bsize); ((has_bl_table[idx1] >> idx2) & 1) != 0 } }