diff --git a/Userland/Libraries/LibVideo/VP9/Context.h b/Userland/Libraries/LibVideo/VP9/Context.h index 403f204324..d0d3cbfebf 100644 --- a/Userland/Libraries/LibVideo/VP9/Context.h +++ b/Userland/Libraries/LibVideo/VP9/Context.h @@ -203,7 +203,7 @@ struct TokensContext { struct FrameBlockContext { bool is_intra_predicted() const { return ref_frames[0] == ReferenceFrameType::None; } bool is_single_reference() const { return ref_frames[1] == ReferenceFrameType::None; } - MotionVectorPair primary_motion_vector_pair() const { return { sub_block_motion_vectors[0][3], sub_block_motion_vectors[1][3] }; } + MotionVectorPair primary_motion_vector_pair() const { return sub_block_motion_vectors[3]; } bool is_available { false }; bool skip_coefficients { false }; @@ -212,7 +212,7 @@ struct FrameBlockContext { Array sub_modes { PredictionMode::DcPred, PredictionMode::DcPred, PredictionMode::DcPred, PredictionMode::DcPred }; InterpolationFilter interpolation_filter { InterpolationFilter::EightTap }; ReferenceFramePair ref_frames { ReferenceFrameType::None, ReferenceFrameType::None }; - Array, 2> sub_block_motion_vectors {}; + Array sub_block_motion_vectors; u8 segment_id { 0 }; }; @@ -382,8 +382,31 @@ struct BlockContext { u32 row { 0 }; u32 column { 0 }; BlockSubsize size; + Gfx::Size get_size_in_4x4_blocks() const + { + auto width = num_4x4_blocks_wide_lookup[size]; + auto height = num_4x4_blocks_high_lookup[size]; + return Gfx::Size(width, height); + } Vector2DView contexts_view; + + u8 segment_id { 0 }; + bool should_skip_residuals { false }; + + TXSize tx_size { TXSize::TX_4x4 }; + + ReferenceFramePair reference_frame_types; + bool is_inter_predicted() const { return reference_frame_types[0] > ReferenceFrameType::None; } + bool is_compound() const { return reference_frame_types[1] > ReferenceFrameType::None; } + + Array sub_block_prediction_modes; + PredictionMode y_prediction_mode() const { return sub_block_prediction_modes.last(); } + PredictionMode& y_prediction_mode() { return sub_block_prediction_modes.last(); } + PredictionMode uv_prediction_mode { 0 }; + + InterpolationFilter interpolation_filter { EightTap }; + Array sub_block_motion_vectors; }; } diff --git a/Userland/Libraries/LibVideo/VP9/Decoder.cpp b/Userland/Libraries/LibVideo/VP9/Decoder.cpp index 2168646ebc..4f194e21c2 100644 --- a/Userland/Libraries/LibVideo/VP9/Decoder.cpp +++ b/Userland/Libraries/LibVideo/VP9/Decoder.cpp @@ -351,11 +351,11 @@ DecoderErrorOr Decoder::predict_intra(u8 plane, BlockContext const& block_ // 3. Otherwise, mode is set equal to sub_modes[ blockIdx ]. PredictionMode mode; if (plane > 0) - mode = m_parser->m_uv_mode; + mode = block_context.uv_prediction_mode; else if (block_context.size >= Block_8x8) - mode = m_parser->m_y_mode; + mode = block_context.y_prediction_mode(); else - mode = m_parser->m_block_sub_modes[block_index]; + mode = block_context.sub_block_prediction_modes[block_index]; // The variable log2Size specifying the base 2 logarithm of the width of the transform block is set equal to txSz + 2. u8 log2_of_block_size = tx_size + 2; @@ -700,31 +700,33 @@ MotionVector Decoder::select_motion_vector(u8 plane, BlockContext const& block_c }; }; + auto vectors = block_context.sub_block_motion_vectors; + // The motion vector array mv is derived as follows: // − If plane is equal to 0, or MiSize is greater than or equal to BLOCK_8X8, mv is set equal to // BlockMvs[ refList ][ blockIdx ]. if (plane == 0 || block_context.size >= Block_8x8) - return m_parser->m_block_mvs[ref_list][block_index]; + return vectors[block_index][ref_list]; // − Otherwise, if subsampling_x is equal to 0 and subsampling_y is equal to 0, mv is set equal to // BlockMvs[ refList ][ blockIdx ]. if (!block_context.frame_context.color_config.subsampling_x && !block_context.frame_context.color_config.subsampling_y) - return m_parser->m_block_mvs[ref_list][block_index]; + return vectors[block_index][ref_list]; // − Otherwise, if subsampling_x is equal to 0 and subsampling_y is equal to 1, mv[ comp ] is set equal to // round_mv_comp_q2( BlockMvs[ refList ][ blockIdx ][ comp ] + BlockMvs[ refList ][ blockIdx + 2 ][ comp ] ) // for comp = 0..1. if (!block_context.frame_context.color_config.subsampling_x && block_context.frame_context.color_config.subsampling_y) - return round_mv_comp_q2(m_parser->m_block_mvs[ref_list][block_index] + m_parser->m_block_mvs[ref_list][block_index + 2]); + return round_mv_comp_q2(vectors[block_index][ref_list] + vectors[block_index + 2][ref_list]); // − Otherwise, if subsampling_x is equal to 1 and subsampling_y is equal to 0, mv[ comp ] is set equal to // round_mv_comp_q2( BlockMvs[ refList ][ blockIdx ][ comp ] + BlockMvs[ refList ][ blockIdx + 1 ][ comp ] ) // for comp = 0..1. if (block_context.frame_context.color_config.subsampling_x && !block_context.frame_context.color_config.subsampling_y) - return round_mv_comp_q2(m_parser->m_block_mvs[ref_list][block_index] + m_parser->m_block_mvs[ref_list][block_index + 1]); + return round_mv_comp_q2(vectors[block_index][ref_list] + vectors[block_index + 1][ref_list]); // − Otherwise, (subsampling_x is equal to 1 and subsampling_y is equal to 1), mv[ comp ] is set equal to // round_mv_comp_q4( BlockMvs[ refList ][ 0 ][ comp ] + BlockMvs[ refList ][ 1 ][ comp ] + // BlockMvs[ refList ][ 2 ][ comp ] + BlockMvs[ refList ][ 3 ][ comp ] ) for comp = 0..1. VERIFY(block_context.frame_context.color_config.subsampling_x && block_context.frame_context.color_config.subsampling_y); - return round_mv_comp_q4(m_parser->m_block_mvs[ref_list][0] + m_parser->m_block_mvs[ref_list][1] - + m_parser->m_block_mvs[ref_list][2] + m_parser->m_block_mvs[ref_list][3]); + return round_mv_comp_q4(vectors[0][ref_list] + vectors[1][ref_list] + + vectors[2][ref_list] + vectors[3][ref_list]); } MotionVector Decoder::clamp_motion_vector(u8 plane, BlockContext const& block_context, u32 block_row, u32 block_column, MotionVector vector) @@ -787,7 +789,7 @@ DecoderErrorOr Decoder::predict_inter_block(u8 plane, BlockContext const& // A variable refIdx specifying which reference frame is being used is set equal to // ref_frame_idx[ ref_frame[ refList ] - LAST_FRAME ]. - auto reference_frame_index = block_context.frame_context.reference_frame_indices[m_parser->m_ref_frame[ref_list] - LastFrame]; + auto reference_frame_index = block_context.frame_context.reference_frame_indices[block_context.reference_frame_types[ref_list] - LastFrame]; // It is a requirement of bitstream conformance that all the following conditions are satisfied: // − 2 * FrameWidth >= RefFrameWidth[ refIdx ] @@ -907,7 +909,7 @@ DecoderErrorOr Decoder::predict_inter_block(u8 plane, BlockContext const& auto sample = reference_frame_buffer_at( clip_3(0, scaled_bottom, (offset_scaled_block_y >> 4) + static_cast(row) - 3), clip_3(0, scaled_right, (samples_start >> 4) + static_cast(t) - 3)); - accumulated_samples += subpel_filters[m_parser->m_interp_filter][samples_start & 15][t] * sample; + accumulated_samples += subpel_filters[block_context.interpolation_filter][samples_start & 15][t] * sample; } intermediate_buffer_at(row, column) = clip_1(block_context.frame_context.color_config.bit_depth, round_2(accumulated_samples, 7)); } @@ -920,7 +922,7 @@ DecoderErrorOr Decoder::predict_inter_block(u8 plane, BlockContext const& i32 accumulated_samples = 0; for (auto t = 0u; t < 8u; t++) { auto sample = intermediate_buffer_at((samples_start >> 4) + t, column); - accumulated_samples += subpel_filters[m_parser->m_interp_filter][samples_start & 15][t] * sample; + accumulated_samples += subpel_filters[block_context.interpolation_filter][samples_start & 15][t] * sample; } block_buffer_at(row, column) = clip_1(block_context.frame_context.color_config.bit_depth, round_2(accumulated_samples, 7)); } @@ -942,7 +944,7 @@ DecoderErrorOr Decoder::predict_inter(u8 plane, BlockContext const& block_ // The outputs of this process are inter predicted samples in the current frame CurrFrame. // The variable isCompound is set equal to ref_frame[ 1 ] > NONE. - auto is_compound = m_parser->m_ref_frame[1] > None; + auto is_compound = block_context.reference_frame_types[1] > None; // The prediction arrays are formed by the following ordered steps: // 1. The variable refList is set equal to 0. // 2. through 5. @@ -1022,9 +1024,9 @@ u8 Decoder::get_base_quantizer_index(BlockContext const& block_context) { // The function get_qindex( ) returns the quantizer index for the current block and is specified by the following: // − If seg_feature_active( SEG_LVL_ALT_Q ) is equal to 1 the following ordered steps apply: - if (m_parser->seg_feature_active(SEG_LVL_ALT_Q)) { + if (m_parser->seg_feature_active(block_context, SEG_LVL_ALT_Q)) { // 1. Set the variable data equal to FeatureData[ segment_id ][ SEG_LVL_ALT_Q ]. - auto data = m_parser->m_feature_data[m_parser->m_segment_id][SEG_LVL_ALT_Q]; + auto data = m_parser->m_feature_data[block_context.segment_id][SEG_LVL_ALT_Q]; // 2. If segmentation_abs_or_delta_update is equal to 0, set data equal to base_q_idx + data if (!m_parser->m_segmentation_abs_or_delta_update) { diff --git a/Userland/Libraries/LibVideo/VP9/Parser.cpp b/Userland/Libraries/LibVideo/VP9/Parser.cpp index fba379a2f2..5e7874bebe 100644 --- a/Userland/Libraries/LibVideo/VP9/Parser.cpp +++ b/Userland/Libraries/LibVideo/VP9/Parser.cpp @@ -632,8 +632,8 @@ u8 Parser::inv_recenter_nonneg(u8 v, u8 m) DecoderErrorOr Parser::read_coef_probs() { - m_max_tx_size = tx_mode_to_biggest_tx_size[m_tx_mode]; - for (u8 tx_size = 0; tx_size <= m_max_tx_size; tx_size++) { + auto max_tx_size = tx_mode_to_biggest_tx_size[m_tx_mode]; + for (u8 tx_size = 0; tx_size <= max_tx_size; tx_size++) { auto update_probs = TRY_READ(m_bit_stream->read_literal(1)); if (update_probs == 1) { for (auto i = 0; i < 2; i++) { @@ -963,12 +963,12 @@ DecoderErrorOr Parser::decode_block(TileContext& tile_context, u32 row, u3 TRY(mode_info(block_context, above_context, left_context)); auto had_residual_tokens = TRY(residual(block_context, above_context.is_available, left_context.is_available)); - if (m_is_inter && subsize >= Block_8x8 && !had_residual_tokens) - m_skip = true; + if (block_context.is_inter_predicted() && subsize >= Block_8x8 && !had_residual_tokens) + block_context.should_skip_residuals = true; for (size_t y = 0; y < block_context.contexts_view.height(); y++) { for (size_t x = 0; x < block_context.contexts_view.width(); x++) { - auto sub_block_context = FrameBlockContext { true, m_skip, m_tx_size, m_y_mode, m_block_sub_modes, m_interp_filter, m_ref_frame, m_block_mvs, m_segment_id }; + auto sub_block_context = FrameBlockContext { true, block_context.should_skip_residuals, block_context.tx_size, block_context.y_prediction_mode(), block_context.sub_block_prediction_modes, block_context.interpolation_filter, block_context.reference_frame_types, block_context.sub_block_motion_vectors, block_context.segment_id }; block_context.contexts_view.at(y, x) = sub_block_context; VERIFY(block_context.frame_block_contexts().at(row + y, column + x).tx_size == sub_block_context.tx_size); } @@ -987,81 +987,72 @@ DecoderErrorOr Parser::mode_info(BlockContext& block_context, FrameBlockCo DecoderErrorOr Parser::intra_frame_mode_info(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context) { - TRY(intra_segment_id()); - TRY(read_skip(above_context, left_context)); - TRY(read_tx_size(block_context, above_context, left_context, true)); - m_ref_frame[0] = IntraFrame; - m_ref_frame[1] = None; - m_is_inter = false; + block_context.reference_frame_types = { ReferenceFrameType::None, ReferenceFrameType::None }; + VERIFY(!block_context.is_inter_predicted()); + TRY(set_intra_segment_id(block_context)); + block_context.should_skip_residuals = TRY(read_should_skip_residuals(block_context, above_context, left_context)); + block_context.tx_size = TRY(read_tx_size(block_context, above_context, left_context, true)); // FIXME: This if statement is also present in parse_default_intra_mode. The selection of parameters for // the probability table lookup should be inlined here. if (block_context.size >= Block_8x8) { - m_y_mode = TRY_READ(TreeParser::parse_default_intra_mode(*m_bit_stream, *m_probability_tables, block_context.size, above_context, left_context, m_block_sub_modes, 0, 0)); - for (auto& block_sub_mode : m_block_sub_modes) - block_sub_mode = m_y_mode; + auto mode = TRY_READ(TreeParser::parse_default_intra_mode(*m_bit_stream, *m_probability_tables, block_context.size, above_context, left_context, block_context.sub_block_prediction_modes, 0, 0)); + for (auto& block_sub_mode : block_context.sub_block_prediction_modes) + block_sub_mode = mode; } else { - m_num_4x4_w = num_4x4_blocks_wide_lookup[block_context.size]; - m_num_4x4_h = num_4x4_blocks_high_lookup[block_context.size]; - for (auto idy = 0; idy < 2; idy += m_num_4x4_h) { - for (auto idx = 0; idx < 2; idx += m_num_4x4_w) { - auto sub_mode = TRY_READ(TreeParser::parse_default_intra_mode(*m_bit_stream, *m_probability_tables, block_context.size, above_context, left_context, m_block_sub_modes, idx, idy)); + auto size_in_4x4_blocks = block_context.get_size_in_4x4_blocks(); + for (auto idy = 0; idy < 2; idy += size_in_4x4_blocks.height()) { + for (auto idx = 0; idx < 2; idx += size_in_4x4_blocks.width()) { + auto sub_mode = TRY_READ(TreeParser::parse_default_intra_mode(*m_bit_stream, *m_probability_tables, block_context.size, above_context, left_context, block_context.sub_block_prediction_modes, idx, idy)); - for (auto y = 0; y < m_num_4x4_h; y++) { - for (auto x = 0; x < m_num_4x4_w; x++) { + for (auto y = 0; y < size_in_4x4_blocks.height(); y++) { + for (auto x = 0; x < size_in_4x4_blocks.width(); x++) { auto index = (idy + y) * 2 + idx + x; - m_block_sub_modes[index] = sub_mode; + block_context.sub_block_prediction_modes[index] = sub_mode; } } } } - m_y_mode = m_block_sub_modes.last(); } - m_uv_mode = TRY_READ(TreeParser::parse_default_uv_mode(*m_bit_stream, *m_probability_tables, m_y_mode)); + block_context.uv_prediction_mode = TRY_READ(TreeParser::parse_default_uv_mode(*m_bit_stream, *m_probability_tables, block_context.y_prediction_mode())); return {}; } -DecoderErrorOr Parser::intra_segment_id() +DecoderErrorOr Parser::set_intra_segment_id(BlockContext& block_context) { if (m_segmentation_enabled && m_segmentation_update_map) - m_segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs)); + block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs)); else - m_segment_id = 0; + block_context.segment_id = 0; return {}; } -DecoderErrorOr Parser::read_skip(FrameBlockContext above_context, FrameBlockContext left_context) +DecoderErrorOr Parser::read_should_skip_residuals(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context) { - if (seg_feature_active(SEG_LVL_SKIP)) { - m_skip = true; - } else { - m_skip = TRY_READ(TreeParser::parse_skip(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); - } - return {}; + if (seg_feature_active(block_context, SEG_LVL_SKIP)) + return true; + return TRY_READ(TreeParser::parse_skip(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); } -bool Parser::seg_feature_active(u8 feature) +bool Parser::seg_feature_active(BlockContext const& block_context, u8 feature) { - return m_segmentation_enabled && m_feature_enabled[m_segment_id][feature]; + return m_segmentation_enabled && m_feature_enabled[block_context.segment_id][feature]; } -DecoderErrorOr Parser::read_tx_size(BlockContext const& block_context, FrameBlockContext above_context, FrameBlockContext left_context, bool allow_select) +DecoderErrorOr Parser::read_tx_size(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context, bool allow_select) { - // FIXME: This probably doesn't need to set max_tx_size, and can also return the TXSize it reads. - m_max_tx_size = max_txsize_lookup[block_context.size]; + auto max_tx_size = max_txsize_lookup[block_context.size]; if (allow_select && m_tx_mode == TXModeSelect && block_context.size >= Block_8x8) - m_tx_size = TRY_READ(TreeParser::parse_tx_size(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, m_max_tx_size, above_context, left_context)); - else - m_tx_size = min(m_max_tx_size, tx_mode_to_biggest_tx_size[m_tx_mode]); - return {}; + return (TRY_READ(TreeParser::parse_tx_size(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, max_tx_size, above_context, left_context))); + return min(max_tx_size, tx_mode_to_biggest_tx_size[m_tx_mode]); } DecoderErrorOr Parser::inter_frame_mode_info(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context) { - TRY(inter_segment_id(block_context)); - TRY(read_skip(above_context, left_context)); - TRY(read_is_inter(above_context, left_context)); - TRY(read_tx_size(block_context, above_context, left_context, !m_skip || !m_is_inter)); - if (m_is_inter) { + TRY(set_inter_segment_id(block_context)); + block_context.should_skip_residuals = TRY(read_should_skip_residuals(block_context, above_context, left_context)); + auto is_inter = TRY(read_is_inter(block_context, above_context, left_context)); + block_context.tx_size = TRY(read_tx_size(block_context, above_context, left_context, !block_context.should_skip_residuals || !is_inter)); + if (is_inter) { TRY(inter_block_mode_info(block_context, above_context, left_context)); } else { TRY(intra_block_mode_info(block_context)); @@ -1069,27 +1060,27 @@ DecoderErrorOr Parser::inter_frame_mode_info(BlockContext& block_context, return {}; } -DecoderErrorOr Parser::inter_segment_id(BlockContext const& block_context) +DecoderErrorOr Parser::set_inter_segment_id(BlockContext& block_context) { if (!m_segmentation_enabled) { - m_segment_id = 0; + block_context.segment_id = 0; return {}; } auto predicted_segment_id = get_segment_id(block_context); if (!m_segmentation_update_map) { - m_segment_id = predicted_segment_id; + block_context.segment_id = predicted_segment_id; return {}; } if (!m_segmentation_temporal_update) { - m_segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs)); + block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs)); return {}; } auto seg_id_predicted = TRY_READ(TreeParser::parse_segment_id_predicted(*m_bit_stream, m_segmentation_pred_prob, m_left_seg_pred_context[block_context.row], m_above_seg_pred_context[block_context.column])); if (seg_id_predicted) - m_segment_id = predicted_segment_id; + block_context.segment_id = predicted_segment_id; else - m_segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs)); + block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs)); for (size_t i = 0; i < num_8x8_blocks_wide_lookup[block_context.size]; i++) { auto index = block_context.column + i; @@ -1121,98 +1112,87 @@ u8 Parser::get_segment_id(BlockContext const& block_context) return segment; } -DecoderErrorOr Parser::read_is_inter(FrameBlockContext above_context, FrameBlockContext left_context) +DecoderErrorOr Parser::read_is_inter(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context) { - if (seg_feature_active(SEG_LVL_REF_FRAME)) - m_is_inter = m_feature_data[m_segment_id][SEG_LVL_REF_FRAME] != IntraFrame; - else - m_is_inter = TRY_READ(TreeParser::parse_block_is_inter_predicted(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); - return {}; + if (seg_feature_active(block_context, SEG_LVL_REF_FRAME)) + return m_feature_data[block_context.segment_id][SEG_LVL_REF_FRAME] != IntraFrame; + return TRY_READ(TreeParser::parse_block_is_inter_predicted(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); } DecoderErrorOr Parser::intra_block_mode_info(BlockContext& block_context) { - m_ref_frame[0] = IntraFrame; - m_ref_frame[1] = None; + block_context.reference_frame_types = { ReferenceFrameType::None, ReferenceFrameType::None }; + VERIFY(!block_context.is_inter_predicted()); + auto& sub_modes = block_context.sub_block_prediction_modes; if (block_context.size >= Block_8x8) { - m_y_mode = TRY_READ(TreeParser::parse_intra_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, block_context.size)); - for (auto& block_sub_mode : m_block_sub_modes) - block_sub_mode = m_y_mode; + auto mode = TRY_READ(TreeParser::parse_intra_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, block_context.size)); + for (auto& block_sub_mode : sub_modes) + block_sub_mode = mode; } else { - m_num_4x4_w = num_4x4_blocks_wide_lookup[block_context.size]; - m_num_4x4_h = num_4x4_blocks_high_lookup[block_context.size]; - PredictionMode sub_intra_mode; - for (auto idy = 0; idy < 2; idy += m_num_4x4_h) { - for (auto idx = 0; idx < 2; idx += m_num_4x4_w) { - sub_intra_mode = TRY_READ(TreeParser::parse_sub_intra_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter)); - for (auto y = 0; y < m_num_4x4_h; y++) { - for (auto x = 0; x < m_num_4x4_w; x++) - m_block_sub_modes[(idy + y) * 2 + idx + x] = sub_intra_mode; + auto size_in_4x4_blocks = block_context.get_size_in_4x4_blocks(); + for (auto idy = 0; idy < 2; idy += size_in_4x4_blocks.height()) { + for (auto idx = 0; idx < 2; idx += size_in_4x4_blocks.width()) { + auto sub_intra_mode = TRY_READ(TreeParser::parse_sub_intra_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter)); + for (auto y = 0; y < size_in_4x4_blocks.height(); y++) { + for (auto x = 0; x < size_in_4x4_blocks.width(); x++) + sub_modes[(idy + y) * 2 + idx + x] = sub_intra_mode; } } } - m_y_mode = sub_intra_mode; } - m_uv_mode = TRY_READ(TreeParser::parse_uv_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, m_y_mode)); + block_context.uv_prediction_mode = TRY_READ(TreeParser::parse_uv_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, block_context.y_prediction_mode())); return {}; } DecoderErrorOr Parser::inter_block_mode_info(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context) { TRY(read_ref_frames(block_context, above_context, left_context)); + VERIFY(block_context.is_inter_predicted()); for (auto j = 0; j < 2; j++) { - if (m_ref_frame[j] > IntraFrame) { - find_mv_refs(block_context, m_ref_frame[j], -1); + if (block_context.reference_frame_types[j] > IntraFrame) { + find_mv_refs(block_context, block_context.reference_frame_types[j], -1); find_best_ref_mvs(block_context, j); } } - auto is_compound = m_ref_frame[1] > IntraFrame; - if (seg_feature_active(SEG_LVL_SKIP)) { - m_y_mode = PredictionMode::ZeroMv; + if (seg_feature_active(block_context, SEG_LVL_SKIP)) { + block_context.y_prediction_mode() = PredictionMode::ZeroMv; } else if (block_context.size >= Block_8x8) { - m_y_mode = TRY_READ(TreeParser::parse_inter_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, m_mode_context[m_ref_frame[0]])); + block_context.y_prediction_mode() = TRY_READ(TreeParser::parse_inter_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, m_mode_context[block_context.reference_frame_types[0]])); } if (block_context.frame_context.interpolation_filter == Switchable) - m_interp_filter = TRY_READ(TreeParser::parse_interpolation_filter(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); + block_context.interpolation_filter = TRY_READ(TreeParser::parse_interpolation_filter(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); else - m_interp_filter = block_context.frame_context.interpolation_filter; + block_context.interpolation_filter = block_context.frame_context.interpolation_filter; if (block_context.size < Block_8x8) { - m_num_4x4_w = num_4x4_blocks_wide_lookup[block_context.size]; - m_num_4x4_h = num_4x4_blocks_high_lookup[block_context.size]; - for (auto idy = 0; idy < 2; idy += m_num_4x4_h) { - for (auto idx = 0; idx < 2; idx += m_num_4x4_w) { - m_y_mode = TRY_READ(TreeParser::parse_inter_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, m_mode_context[m_ref_frame[0]])); - if (m_y_mode == PredictionMode::NearestMv || m_y_mode == PredictionMode::NearMv) { - for (auto j = 0; j < 1 + is_compound; j++) + auto size_in_4x4_blocks = block_context.get_size_in_4x4_blocks(); + for (auto idy = 0; idy < 2; idy += size_in_4x4_blocks.height()) { + for (auto idx = 0; idx < 2; idx += size_in_4x4_blocks.width()) { + block_context.y_prediction_mode() = TRY_READ(TreeParser::parse_inter_mode(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, m_mode_context[block_context.reference_frame_types[0]])); + if (block_context.y_prediction_mode() == PredictionMode::NearestMv || block_context.y_prediction_mode() == PredictionMode::NearMv) { + for (auto j = 0; j < 1 + block_context.is_compound(); j++) append_sub8x8_mvs(block_context, idy * 2 + idx, j); } - TRY(assign_mv(block_context, is_compound)); - for (auto y = 0; y < m_num_4x4_h; y++) { - for (auto x = 0; x < m_num_4x4_w; x++) { - auto block = (idy + y) * 2 + idx + x; - for (auto ref_list = 0; ref_list < 1 + is_compound; ref_list++) { - m_block_mvs[ref_list][block] = m_mv[ref_list]; - } + auto new_motion_vector_pair = TRY(assign_mv(block_context)); + for (auto y = 0; y < size_in_4x4_blocks.height(); y++) { + for (auto x = 0; x < size_in_4x4_blocks.width(); x++) { + auto sub_block_index = (idy + y) * 2 + idx + x; + block_context.sub_block_motion_vectors[sub_block_index] = new_motion_vector_pair; } } } } return {}; } - TRY(assign_mv(block_context, is_compound)); - for (auto ref_list = 0; ref_list < 1 + is_compound; ref_list++) { - for (auto block = 0; block < 4; block++) { - m_block_mvs[ref_list][block] = m_mv[ref_list]; - } - } + auto new_motion_vector_pair = TRY(assign_mv(block_context)); + for (auto block = 0; block < 4; block++) + block_context.sub_block_motion_vectors[block] = new_motion_vector_pair; return {}; } DecoderErrorOr Parser::read_ref_frames(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context) { - if (seg_feature_active(SEG_LVL_REF_FRAME)) { - m_ref_frame[0] = static_cast(m_feature_data[m_segment_id][SEG_LVL_REF_FRAME]); - m_ref_frame[1] = None; + if (seg_feature_active(block_context, SEG_LVL_REF_FRAME)) { + block_context.reference_frame_types = { static_cast(m_feature_data[block_context.segment_id][SEG_LVL_REF_FRAME]), None }; return {}; } ReferenceMode comp_mode; @@ -1228,40 +1208,45 @@ DecoderErrorOr Parser::read_ref_frames(BlockContext& block_context, FrameB // FIXME: Create an enum for compound frame references using names Primary and Secondary. auto comp_ref = TRY_READ(TreeParser::parse_comp_ref(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, m_comp_fixed_ref, m_comp_var_ref, variable_reference_index, above_context, left_context)); - m_ref_frame[fixed_reference_index] = m_comp_fixed_ref; - m_ref_frame[variable_reference_index] = m_comp_var_ref[comp_ref]; + block_context.reference_frame_types[fixed_reference_index] = m_comp_fixed_ref; + block_context.reference_frame_types[variable_reference_index] = m_comp_var_ref[comp_ref]; return {}; } // FIXME: Maybe consolidate this into a tree. Context is different between part 1 and 2 but still, it would look nice here. auto single_ref_p1 = TRY_READ(TreeParser::parse_single_ref_part_1(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); if (single_ref_p1) { auto single_ref_p2 = TRY_READ(TreeParser::parse_single_ref_part_2(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context)); - m_ref_frame[0] = single_ref_p2 ? AltRefFrame : GoldenFrame; + block_context.reference_frame_types[0] = single_ref_p2 ? AltRefFrame : GoldenFrame; } else { - m_ref_frame[0] = LastFrame; + block_context.reference_frame_types[0] = LastFrame; } - m_ref_frame[1] = None; + block_context.reference_frame_types[1] = None; return {}; } -DecoderErrorOr Parser::assign_mv(BlockContext const& block_context, bool is_compound) +DecoderErrorOr Parser::assign_mv(BlockContext const& block_context) { - m_mv[1] = {}; - for (auto i = 0; i < 1 + is_compound; i++) { - if (m_y_mode == PredictionMode::NewMv) { - TRY(read_mv(block_context, i)); - } else if (m_y_mode == PredictionMode::NearestMv) { - m_mv[i] = m_nearest_mv[i]; - } else if (m_y_mode == PredictionMode::NearMv) { - m_mv[i] = m_near_mv[i]; - } else { - m_mv[i] = {}; + MotionVectorPair result; + for (auto i = 0; i < 1 + block_context.is_compound(); i++) { + switch (block_context.y_prediction_mode()) { + case PredictionMode::NewMv: + result[i] = TRY(read_mv(block_context, i)); + break; + case PredictionMode::NearestMv: + result[i] = m_nearest_mv[i]; + break; + case PredictionMode::NearMv: + result[i] = m_near_mv[i]; + break; + default: + result[i] = {}; + break; } } - return {}; + return result; } -DecoderErrorOr Parser::read_mv(BlockContext const& block_context, u8 ref) +DecoderErrorOr Parser::read_mv(BlockContext const& block_context, u8 ref) { m_use_hp = block_context.frame_context.high_precision_motion_vectors_allowed && use_mv_hp(m_best_mv[ref]); MotionVector diff_mv; @@ -1271,10 +1256,7 @@ DecoderErrorOr Parser::read_mv(BlockContext const& block_context, u8 ref) if (mv_joint == MvJointHnzvz || mv_joint == MvJointHnzvnz) diff_mv.set_column(TRY(read_mv_component(1))); - // FIXME: We probably don't need to assign MVs to a field, these can just - // be returned and assigned where they are requested. - m_mv[ref] = m_best_mv[ref] + diff_mv; - return {}; + return m_best_mv[ref] + diff_mv; } DecoderErrorOr Parser::read_mv_component(u8 component) @@ -1334,7 +1316,7 @@ DecoderErrorOr Parser::residual(BlockContext& block_context, bool has_bloc bool had_residual_tokens = false; auto block_size = block_context.size < Block_8x8 ? Block_8x8 : block_context.size; for (u8 plane = 0; plane < 3; plane++) { - auto tx_size = (plane > 0) ? get_uv_tx_size(block_context.frame_context.color_config.subsampling_x, block_context.frame_context.color_config.subsampling_y, m_tx_size, block_context.size) : m_tx_size; + auto tx_size = (plane > 0) ? get_uv_tx_size(block_context.frame_context.color_config.subsampling_x, block_context.frame_context.color_config.subsampling_y, block_context.tx_size, block_context.size) : block_context.tx_size; auto step = 1 << tx_size; auto plane_size = get_plane_block_size(block_context.frame_context.color_config.subsampling_x, block_context.frame_context.color_config.subsampling_y, block_size, plane); auto num_4x4_w = num_4x4_blocks_wide_lookup[plane_size]; @@ -1343,7 +1325,7 @@ DecoderErrorOr Parser::residual(BlockContext& block_context, bool has_bloc auto sub_y = (plane > 0) ? block_context.frame_context.color_config.subsampling_y : 0; auto base_x = (block_context.column * 8) >> sub_x; auto base_y = (block_context.row * 8) >> sub_y; - if (m_is_inter) { + if (block_context.is_inter_predicted()) { if (block_context.size < Block_8x8) { for (auto y = 0; y < num_4x4_h; y++) { for (auto x = 0; x < num_4x4_w; x++) { @@ -1363,9 +1345,9 @@ DecoderErrorOr Parser::residual(BlockContext& block_context, bool has_bloc auto start_y = base_y + (4 * y); auto non_zero = false; if (start_x < max_x && start_y < max_y) { - if (!m_is_inter) + if (!block_context.is_inter_predicted()) TRY(m_decoder.predict_intra(plane, block_context, start_x, start_y, has_block_left || x > 0, has_block_above || y > 0, (x + step) < num_4x4_w, tx_size, block_index)); - if (!m_skip) { + if (!block_context.should_skip_residuals) { non_zero = TRY(tokens(block_context, plane, start_x, start_y, tx_size, block_index)); had_residual_tokens = had_residual_tokens || non_zero; TRY(m_decoder.reconstruct(plane, block_context, start_x, start_y, tx_size)); @@ -1400,7 +1382,7 @@ DecoderErrorOr Parser::tokens(BlockContext& block_context, size_t plane, u for (; c < segment_eob; c++) { auto pos = scan[c]; auto band = (tx_size == TX_4x4) ? coefband_4x4[c] : coefband_8x8plus[c]; - auto tokens_context = TreeParser::get_tokens_context(block_context.frame_context.color_config.subsampling_x, block_context.frame_context.color_config.subsampling_y, block_context.frame_context.rows(), block_context.frame_context.columns(), m_above_nonzero_context, m_left_nonzero_context, m_token_cache, tx_size, m_tx_type, plane, start_x, start_y, pos, m_is_inter, band, c); + auto tokens_context = TreeParser::get_tokens_context(block_context.frame_context.color_config.subsampling_x, block_context.frame_context.color_config.subsampling_y, block_context.frame_context.rows(), block_context.frame_context.columns(), m_above_nonzero_context, m_left_nonzero_context, m_token_cache, tx_size, m_tx_type, plane, start_x, start_y, pos, block_context.is_inter_predicted(), band, c); if (check_eob) { auto more_coefs = TRY_READ(TreeParser::parse_more_coefficients(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, tokens_context)); if (!more_coefs) @@ -1428,12 +1410,12 @@ u32 const* Parser::get_scan(BlockContext const& block_context, size_t plane, TXS if (plane > 0 || tx_size == TX_32x32) { m_tx_type = DCT_DCT; } else if (tx_size == TX_4x4) { - if (block_context.frame_context.is_lossless() || m_is_inter) + if (block_context.frame_context.is_lossless() || block_context.is_inter_predicted()) m_tx_type = DCT_DCT; else - m_tx_type = mode_to_txfm_map[to_underlying(block_context.size < Block_8x8 ? m_block_sub_modes[block_index] : m_y_mode)]; + m_tx_type = mode_to_txfm_map[to_underlying(block_context.size < Block_8x8 ? block_context.sub_block_prediction_modes[block_index] : block_context.y_prediction_mode())]; } else { - m_tx_type = mode_to_txfm_map[to_underlying(m_y_mode)]; + m_tx_type = mode_to_txfm_map[to_underlying(block_context.y_prediction_mode())]; } if (tx_size == TX_4x4) { if (m_tx_type == ADST_DCT) @@ -1600,7 +1582,7 @@ void Parser::find_mv_refs(BlockContext& block_context, ReferenceFrameType refere { 3, 3 } }; auto index = block >= 0 ? idx_n_column_to_subblock[block][offset_vector.column() == 0] : 3; - m_candidate_mv[ref_list] = context.sub_block_motion_vectors[ref_list][index]; + m_candidate_mv[ref_list] = context.sub_block_motion_vectors[index][ref_list]; add_mv_ref_list(ref_list); break; @@ -1663,17 +1645,17 @@ void Parser::find_best_ref_mvs(BlockContext& block_context, u8 ref_list) void Parser::append_sub8x8_mvs(BlockContext& block_context, i32 block, u8 ref_list) { MotionVector sub_8x8_mvs[2]; - find_mv_refs(block_context, m_ref_frame[ref_list], block); + find_mv_refs(block_context, block_context.reference_frame_types[ref_list], block); auto destination_index = 0; if (block == 0) { for (auto i = 0u; i < 2; i++) sub_8x8_mvs[destination_index++] = m_ref_list_mv[i]; } else if (block <= 2) { - sub_8x8_mvs[destination_index++] = m_block_mvs[ref_list][0]; + sub_8x8_mvs[destination_index++] = block_context.sub_block_motion_vectors[0][ref_list]; } else { - sub_8x8_mvs[destination_index++] = m_block_mvs[ref_list][2]; + sub_8x8_mvs[destination_index++] = block_context.sub_block_motion_vectors[2][ref_list]; for (auto index = 1; index >= 0 && destination_index < 2; index--) { - auto block_vector = m_block_mvs[ref_list][index]; + auto block_vector = block_context.sub_block_motion_vectors[index][ref_list]; if (block_vector != sub_8x8_mvs[0]) sub_8x8_mvs[destination_index++] = block_vector; } diff --git a/Userland/Libraries/LibVideo/VP9/Parser.h b/Userland/Libraries/LibVideo/VP9/Parser.h index bfe3812135..91cdf7851c 100644 --- a/Userland/Libraries/LibVideo/VP9/Parser.h +++ b/Userland/Libraries/LibVideo/VP9/Parser.h @@ -105,19 +105,19 @@ private: DecoderErrorOr decode_block(TileContext&, u32 row, u32 column, BlockSubsize subsize); DecoderErrorOr mode_info(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context); DecoderErrorOr intra_frame_mode_info(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context); - DecoderErrorOr intra_segment_id(); - DecoderErrorOr read_skip(FrameBlockContext above_context, FrameBlockContext left_context); - bool seg_feature_active(u8 feature); - DecoderErrorOr read_tx_size(BlockContext const&, FrameBlockContext above_context, FrameBlockContext left_context, bool allow_select); + DecoderErrorOr set_intra_segment_id(BlockContext&); + DecoderErrorOr read_should_skip_residuals(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context); + bool seg_feature_active(BlockContext const&, u8 feature); + DecoderErrorOr read_tx_size(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context, bool allow_select); DecoderErrorOr inter_frame_mode_info(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context); - DecoderErrorOr inter_segment_id(BlockContext const&); + DecoderErrorOr set_inter_segment_id(BlockContext&); u8 get_segment_id(BlockContext const&); - DecoderErrorOr read_is_inter(FrameBlockContext above_context, FrameBlockContext left_context); + DecoderErrorOr read_is_inter(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context); DecoderErrorOr intra_block_mode_info(BlockContext&); DecoderErrorOr inter_block_mode_info(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context); DecoderErrorOr read_ref_frames(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context); - DecoderErrorOr assign_mv(BlockContext const&, bool is_compound); - DecoderErrorOr read_mv(BlockContext const&, u8 ref); + DecoderErrorOr assign_mv(BlockContext const&); + DecoderErrorOr read_mv(BlockContext const&, u8 ref); DecoderErrorOr read_mv_component(u8 component); DecoderErrorOr residual(BlockContext&, bool has_block_above, bool has_block_left); DecoderErrorOr tokens(BlockContext&, size_t plane, u32 x, u32 y, TXSize tx_size, u32 block_index); @@ -167,25 +167,6 @@ private: Vector m_above_partition_context; Vector m_left_partition_context; - u8 m_segment_id { 0 }; - // FIXME: Should this be an enum? - // skip equal to 0 indicates that there may be some transform coefficients to read for this block; skip equal to 1 - // indicates that there are no transform coefficients. - // - // skip may be set to 0 even if transform blocks contain immediate end of block markers. - bool m_skip { false }; - TXSize m_max_tx_size { TX_4x4 }; - TXSize m_tx_size { TX_4x4 }; - ReferenceFramePair m_ref_frame; - bool m_is_inter { false }; - PredictionMode m_y_mode { 0 }; - Array m_block_sub_modes; - u8 m_num_4x4_w { 0 }; - u8 m_num_4x4_h { 0 }; - PredictionMode m_uv_mode { 0 }; // FIXME: Is u8 the right size? - // The current block's interpolation filter. - InterpolationFilter m_interp_filter { EightTap }; - MotionVectorPair m_mv; MotionVectorPair m_near_mv; MotionVectorPair m_nearest_mv; MotionVectorPair m_best_mv; @@ -205,8 +186,6 @@ private: ReferenceMode m_reference_mode; ReferenceFrameType m_comp_fixed_ref; ReferenceFramePair m_comp_var_ref; - // FIXME: Use Array instead. - Array, 2> m_block_mvs; MotionVectorPair m_candidate_mv; ReferenceFramePair m_candidate_frame;