diff options
Diffstat (limited to 'src/tile/tile.cc')
| -rw-r--r-- | src/tile/tile.cc | 142 |
1 files changed, 94 insertions, 48 deletions
diff --git a/src/tile/tile.cc b/src/tile/tile.cc index 9699517..5070bb6 100644 --- a/src/tile/tile.cc +++ b/src/tile/tile.cc @@ -463,6 +463,7 @@ Tile::Tile(int tile_number, const uint8_t* const data, size_t size, : 1), current_frame_(*current_frame), cdef_index_(frame_scratch_buffer->cdef_index), + cdef_skip_(frame_scratch_buffer->cdef_skip), inter_transform_sizes_(frame_scratch_buffer->inter_transform_sizes), thread_pool_(thread_pool), residual_buffer_pool_(frame_scratch_buffer->residual_buffer_pool.get()), @@ -541,16 +542,6 @@ Tile::Tile(int tile_number, const uint8_t* const data, size_t size, buffer_[plane].Reset(Align(buffer.height(plane), max_tx_length), buffer.stride(plane), post_filter_.GetUnfilteredBuffer(plane)); - const int plane_height = - SubsampledValue(frame_header_.height, subsampling_y_[plane]); - deblock_row_limit_[plane] = - std::min(frame_header_.rows4x4, DivideBy4(plane_height + 3) - << subsampling_y_[plane]); - const int plane_width = - SubsampledValue(frame_header_.width, subsampling_x_[plane]); - deblock_column_limit_[plane] = - std::min(frame_header_.columns4x4, DivideBy4(plane_width + 3) - << subsampling_x_[plane]); } } @@ -598,6 +589,10 @@ bool Tile::Init() { column4x4_end_, &motion_field_); } ResetLoopRestorationParams(); + if (!top_context_.Resize(superblock_columns_)) { + LIBGAV1_DLOG(ERROR, "Allocation of top_context_ failed."); + return false; + } return true; } @@ -1019,7 +1014,8 @@ TransformType Tile::ComputeTransformType(const Block& block, Plane plane, int block_y) { const BlockParameters& bp = *block.bp; const TransformSize tx_size_square_max = kTransformSizeSquareMax[tx_size]; - if (frame_header_.segmentation.lossless[bp.segment_id] || + if (frame_header_.segmentation + .lossless[bp.prediction_parameters->segment_id] || tx_size_square_max == kTransformSize64x64) { return kTransformTypeDctDct; } @@ -1034,7 +1030,7 @@ TransformType Tile::ComputeTransformType(const Block& block, Plane plane, const int y4 = std::max(block.row4x4, block_y << subsampling_y_[kPlaneU]); tx_type = transform_types_[y4 - block.row4x4][x4 - block.column4x4]; } else { - tx_type = kModeToTransformType[bp.uv_mode]; + tx_type = kModeToTransformType[bp.prediction_parameters->uv_mode]; } return kTransformTypeInSetMask[tx_set].Contains(tx_type) ? tx_type @@ -1048,7 +1044,8 @@ void Tile::ReadTransformType(const Block& block, int x4, int y4, TransformType tx_type = kTransformTypeDctDct; if (tx_set != kTransformSetDctOnly && - frame_header_.segmentation.qindex[bp.segment_id] > 0) { + frame_header_.segmentation.qindex[bp.prediction_parameters->segment_id] > + 0) { const int cdf_index = SymbolDecoderContext::TxTypeIndex(tx_set); const int cdf_tx_size_index = TransformSizeToSquareTransformIndex(kTransformSizeSquareMin[tx_size]); @@ -1309,7 +1306,7 @@ bool Tile::ReadSignAndApplyDequantization( int length = 0; bool golomb_length_bit = false; do { - golomb_length_bit = static_cast<bool>(reader_.ReadBit()); + golomb_length_bit = reader_.ReadBit() != 0; ++length; if (length > 20) { LIBGAV1_DLOG(ERROR, "Invalid golomb_length %d", length); @@ -1454,7 +1451,7 @@ int Tile::ReadTransformCoefficients(const Block& block, Plane plane, for (int i = 1; i < eob_pt - 2; ++i) { assert(eob_pt - i >= 3); assert(eob_pt <= kEobPt1024SymbolCount); - if (static_cast<bool>(reader_.ReadBit())) { + if (reader_.ReadBit() != 0) { eob += 1 << (eob_pt - i - 3); } } @@ -1500,15 +1497,17 @@ int Tile::ReadTransformCoefficients(const Block& block, Plane plane, coeff_base_range_cdf, residual, level_buffer); } const int max_value = (1 << (7 + sequence_header_.color_config.bitdepth)) - 1; - const int current_quantizer_index = GetQIndex( - frame_header_.segmentation, bp.segment_id, current_quantizer_index_); + const int current_quantizer_index = + GetQIndex(frame_header_.segmentation, + bp.prediction_parameters->segment_id, current_quantizer_index_); const int dc_q_value = quantizer_.GetDcValue(plane, current_quantizer_index); const int ac_q_value = quantizer_.GetAcValue(plane, current_quantizer_index); const int shift = kQuantizationShift[tx_size]; const uint8_t* const quantizer_matrix = (frame_header_.quantizer.use_matrix && *tx_type < kTransformTypeIdentityIdentity && - !frame_header_.segmentation.lossless[bp.segment_id] && + !frame_header_.segmentation + .lossless[bp.prediction_parameters->segment_id] && frame_header_.quantizer.matrix_level[plane] < 15) ? quantizer_matrix_[frame_header_.quantizer.matrix_level[plane]] [plane_type][adjusted_tx_size] @@ -1587,15 +1586,17 @@ bool Tile::TransformBlock(const Block& block, Plane plane, int base_x, const bool do_decode = mode == kProcessingModeDecodeOnly || mode == kProcessingModeParseAndDecode; if (do_decode && !bp.is_inter) { - if (bp.palette_mode_info.size[GetPlaneType(plane)] > 0) { + if (bp.prediction_parameters->palette_mode_info.size[GetPlaneType(plane)] > + 0) { CALL_BITDEPTH_FUNCTION(PalettePrediction, block, plane, start_x, start_y, x, y, tx_size); } else { const PredictionMode mode = - (plane == kPlaneY) - ? bp.y_mode - : (bp.uv_mode == kPredictionModeChromaFromLuma ? kPredictionModeDc - : bp.uv_mode); + (plane == kPlaneY) ? bp.y_mode + : (bp.prediction_parameters->uv_mode == + kPredictionModeChromaFromLuma + ? kPredictionModeDc + : bp.prediction_parameters->uv_mode); const int tr_row4x4 = (sub_block_row4x4 >> subsampling_y); const int tr_column4x4 = (sub_block_column4x4 >> subsampling_x) + step_x + 1; @@ -1609,7 +1610,8 @@ bool Tile::TransformBlock(const Block& block, Plane plane, int base_x, block.scratch_buffer->block_decoded[plane][tr_row4x4][tr_column4x4], block.scratch_buffer->block_decoded[plane][bl_row4x4][bl_column4x4], mode, tx_size); - if (plane != kPlaneY && bp.uv_mode == kPredictionModeChromaFromLuma) { + if (plane != kPlaneY && + bp.prediction_parameters->uv_mode == kPredictionModeChromaFromLuma) { CALL_BITDEPTH_FUNCTION(ChromaFromLumaPrediction, block, plane, start_x, start_y, tx_size); } @@ -1738,14 +1740,16 @@ void Tile::ReconstructBlock(const Block& block, Plane plane, int start_x, buffer_[plane].rows(), buffer_[plane].columns() / sizeof(uint16_t), reinterpret_cast<uint16_t*>(&buffer_[plane][0][0])); Reconstruct(dsp_, tx_type, tx_size, - frame_header_.segmentation.lossless[block.bp->segment_id], + frame_header_.segmentation + .lossless[block.bp->prediction_parameters->segment_id], reinterpret_cast<int32_t*>(*block.residual), start_x, start_y, &buffer, non_zero_coeff_count); } else // NOLINT #endif { Reconstruct(dsp_, tx_type, tx_size, - frame_header_.segmentation.lossless[block.bp->segment_id], + frame_header_.segmentation + .lossless[block.bp->prediction_parameters->segment_id], reinterpret_cast<int16_t*>(*block.residual), start_x, start_y, &buffer_[plane], non_zero_coeff_count); } @@ -1772,12 +1776,15 @@ bool Tile::Residual(const Block& block, ProcessingMode mode) { // kTransformSize4x4. So we can simply use |bp.transform_size| here as // the Y plane's transform size (part of Section 5.11.37 in the spec). const TransformSize tx_size = - (plane == kPlaneY) ? bp.transform_size : bp.uv_transform_size; + (plane == kPlaneY) + ? inter_transform_sizes_[block.row4x4][block.column4x4] + : bp.uv_transform_size; const BlockSize plane_size = kPlaneResidualSize[size_chunk4x4][subsampling_x][subsampling_y]; assert(plane_size != kBlockInvalid); if (bp.is_inter && - !frame_header_.segmentation.lossless[bp.segment_id] && + !frame_header_.segmentation + .lossless[bp.prediction_parameters->segment_id] && plane == kPlaneY) { const int row_chunk4x4 = block.row4x4 + MultiplyBy16(chunk_y); const int column_chunk4x4 = block.column4x4 + MultiplyBy16(chunk_x); @@ -2112,15 +2119,53 @@ void Tile::PopulateDeblockFilterLevel(const Block& block) { for (int i = 0; i < kFrameLfCount; ++i) { if (delta_lf_all_zero_) { bp.deblock_filter_level[i] = post_filter_.GetZeroDeltaDeblockFilterLevel( - bp.segment_id, i, bp.reference_frame[0], mode_id); + bp.prediction_parameters->segment_id, i, bp.reference_frame[0], + mode_id); } else { bp.deblock_filter_level[i] = - deblock_filter_levels_[bp.segment_id][i][bp.reference_frame[0]] - [mode_id]; + deblock_filter_levels_[bp.prediction_parameters->segment_id][i] + [bp.reference_frame[0]][mode_id]; } } } +void Tile::PopulateCdefSkip(const Block& block) { + if (!post_filter_.DoCdef() || block.bp->skip || + (frame_header_.cdef.bits > 0 && + cdef_index_[DivideBy16(block.row4x4)][DivideBy16(block.column4x4)] == + -1)) { + return; + } + // The rest of this function is an efficient version of the following code: + // for (int y = block.row4x4; y < block.row4x4 + block.height4x4; y++) { + // for (int x = block.column4x4; y < block.column4x4 + block.width4x4; + // x++) { + // const uint8_t mask = uint8_t{1} << ((x >> 1) & 0x7); + // cdef_skip_[y >> 1][x >> 4] |= mask; + // } + // } + + // For all block widths other than 32, the mask will fit in uint8_t. For + // block width == 32, the mask is always 0xFFFF. + const int bw4 = + std::max(DivideBy2(block.width4x4) + (block.column4x4 & 1), 1); + const uint8_t mask = (block.width4x4 == 32) + ? 0xFF + : (uint8_t{0xFF} >> (8 - bw4)) + << (DivideBy2(block.column4x4) & 0x7); + uint8_t* cdef_skip = &cdef_skip_[block.row4x4 >> 1][block.column4x4 >> 4]; + const int stride = cdef_skip_.columns(); + int row = 0; + do { + *cdef_skip |= mask; + if (block.width4x4 == 32) { + *(cdef_skip + 1) = 0xFF; + } + cdef_skip += stride; + row += 2; + } while (row < block.height4x4); +} + bool Tile::ProcessBlock(int row4x4, int column4x4, BlockSize block_size, TileScratchBuffer* const scratch_buffer, ResidualPtr* residual) { @@ -2150,7 +2195,7 @@ bool Tile::ProcessBlock(int row4x4, int column4x4, BlockSize block_size, return false; } BlockParameters& bp = *bp_ptr; - Block block(*this, block_size, row4x4, column4x4, scratch_buffer, residual); + Block block(this, block_size, row4x4, column4x4, scratch_buffer, residual); bp.size = block_size; bp.prediction_parameters = split_parse_and_decode_ ? std::unique_ptr<PredictionParameters>( @@ -2158,17 +2203,16 @@ bool Tile::ProcessBlock(int row4x4, int column4x4, BlockSize block_size, : std::move(prediction_parameters_); if (bp.prediction_parameters == nullptr) return false; if (!DecodeModeInfo(block)) return false; - bp.is_global_mv_block = (bp.y_mode == kPredictionModeGlobalMv || - bp.y_mode == kPredictionModeGlobalGlobalMv) && - !IsBlockDimension4(bp.size); PopulateDeblockFilterLevel(block); if (!ReadPaletteTokens(block)) return false; DecodeTransformSize(block); // Part of Section 5.11.37 in the spec (implemented as a simple lookup). - bp.uv_transform_size = frame_header_.segmentation.lossless[bp.segment_id] - ? kTransformSize4x4 - : kUVTransformSize[block.residual_size[kPlaneU]]; + bp.uv_transform_size = + frame_header_.segmentation.lossless[bp.prediction_parameters->segment_id] + ? kTransformSize4x4 + : kUVTransformSize[block.residual_size[kPlaneU]]; if (bp.skip) ResetEntropyContext(block); + PopulateCdefSkip(block); if (split_parse_and_decode_) { if (!Residual(block, kProcessingModeParseOnly)) return false; } else { @@ -2177,22 +2221,24 @@ bool Tile::ProcessBlock(int row4x4, int column4x4, BlockSize block_size, return false; } } - // If frame_header_.segmentation.enabled is false, bp.segment_id is 0 for all - // blocks. We don't need to call save bp.segment_id in the current frame - // because the current frame's segmentation map will be cleared to all 0s. + // If frame_header_.segmentation.enabled is false, + // bp.prediction_parameters->segment_id is 0 for all blocks. We don't need to + // call save bp.prediction_parameters->segment_id in the current frame because + // the current frame's segmentation map will be cleared to all 0s. // // If frame_header_.segmentation.enabled is true and // frame_header_.segmentation.update_map is false, we will copy the previous // frame's segmentation map to the current frame. So we don't need to call - // save bp.segment_id in the current frame. + // save bp.prediction_parameters->segment_id in the current frame. if (frame_header_.segmentation.enabled && frame_header_.segmentation.update_map) { const int x_limit = std::min(frame_header_.columns4x4 - column4x4, static_cast<int>(block.width4x4)); const int y_limit = std::min(frame_header_.rows4x4 - row4x4, static_cast<int>(block.height4x4)); - current_frame_.segmentation_map()->FillBlock(row4x4, column4x4, x_limit, - y_limit, bp.segment_id); + current_frame_.segmentation_map()->FillBlock( + row4x4, column4x4, x_limit, y_limit, + bp.prediction_parameters->segment_id); } StoreMotionFieldMvsIntoCurrentFrame(block); if (!split_parse_and_decode_) { @@ -2208,7 +2254,7 @@ bool Tile::DecodeBlock(int row4x4, int column4x4, BlockSize block_size, column4x4 >= frame_header_.columns4x4) { return true; } - Block block(*this, block_size, row4x4, column4x4, scratch_buffer, residual); + Block block(this, block_size, row4x4, column4x4, scratch_buffer, residual); if (!ComputePrediction(block) || !Residual(block, kProcessingModeDecodeOnly)) { return false; @@ -2382,7 +2428,7 @@ void Tile::ResetLoopRestorationParams() { } void Tile::ResetCdef(const int row4x4, const int column4x4) { - if (!sequence_header_.enable_cdef) return; + if (frame_header_.cdef.bits == 0) return; const int row = DivideBy16(row4x4); const int column = DivideBy16(column4x4); cdef_index_[row][column] = -1; @@ -2562,8 +2608,8 @@ void Tile::StoreMotionFieldMvsIntoCurrentFrame(const Block& block) { // Must make a local copy so that StoreMotionFieldMvs() knows there is no // overlap between load and store. const MotionVector mv_to_store = bp.mv.mv[i]; - const int mv_row = std::abs(mv_to_store.mv[MotionVector::kRow]); - const int mv_column = std::abs(mv_to_store.mv[MotionVector::kColumn]); + const int mv_row = std::abs(mv_to_store.mv[0]); + const int mv_column = std::abs(mv_to_store.mv[1]); if (reference_frame_to_store > kReferenceFrameIntra && // kRefMvsLimit equals 0x07FF, so we can first bitwise OR the two // absolute values and then compare with kRefMvsLimit to save a branch. |