From 9dc622475eba17ef3a3d7ea146961d66a2397317 Mon Sep 17 00:00:00 2001 From: Zaggy1024 Date: Mon, 7 Nov 2022 18:48:57 -0600 Subject: [PATCH] LibVideo: Rename parse_tree_new to parse_tree in VP9/TreeParser.cpp It is now the only function used to parse the binary trees in the VP9 decoder. --- .../Libraries/LibVideo/VP9/TreeParser.cpp | 58 +++++++++---------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/Userland/Libraries/LibVideo/VP9/TreeParser.cpp b/Userland/Libraries/LibVideo/VP9/TreeParser.cpp index 2ad8515c3f..57b7ab2311 100644 --- a/Userland/Libraries/LibVideo/VP9/TreeParser.cpp +++ b/Userland/Libraries/LibVideo/VP9/TreeParser.cpp @@ -21,7 +21,7 @@ namespace Video::VP9 { // - 9.3.4: Counting each syntax element when it is read. template -inline ErrorOr parse_tree_new(BitStream& bit_stream, TreeParser::TreeSelection tree_selection, Function const& probability_getter) +inline ErrorOr parse_tree(BitStream& bit_stream, TreeParser::TreeSelection tree_selection, Function const& probability_getter) { // 9.3.3: The tree decoding function. if (tree_selection.is_single_value()) @@ -75,7 +75,7 @@ ErrorOr TreeParser::parse_partition(BitStream& bit_stream, Probabilit return probabilities[2]; }; - auto value = TRY(parse_tree_new(bit_stream, tree, probability_getter)); + auto value = TRY(parse_tree(bit_stream, tree, probability_getter)); increment_counter(counter.m_counts_partition[context][value]); return value; } @@ -105,7 +105,7 @@ ErrorOr TreeParser::parse_default_intra_mode(BitStream& bit_stre } u8 const* probabilities = probability_table.kf_y_mode_probs()[to_underlying(above_mode)][to_underlying(left_mode)]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); // Default intra mode is not counted. return value; } @@ -118,7 +118,7 @@ ErrorOr TreeParser::parse_default_uv_mode(BitStream& bit_stream, // Probabilities u8 const* probabilities = probability_table.kf_uv_mode_prob()[to_underlying(y_mode)]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); // Default UV mode is not counted. return value; } @@ -132,7 +132,7 @@ ErrorOr TreeParser::parse_intra_mode(BitStream& bit_stream, Prob auto context = size_group_lookup[mi_size]; u8 const* probabilities = probability_table.y_mode_probs()[context]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); increment_counter(counter.m_counts_intra_mode[context][to_underlying(value)]); return value; } @@ -145,7 +145,7 @@ ErrorOr TreeParser::parse_sub_intra_mode(BitStream& bit_stream, // Probabilities u8 const* probabilities = probability_table.y_mode_probs()[0]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); increment_counter(counter.m_counts_intra_mode[0][to_underlying(value)]); return value; } @@ -158,14 +158,14 @@ ErrorOr TreeParser::parse_uv_mode(BitStream& bit_stream, Probabi // Probabilities u8 const* probabilities = probability_table.uv_mode_probs()[to_underlying(y_mode)]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); increment_counter(counter.m_counts_uv_mode[to_underlying(y_mode)][to_underlying(value)]); return value; } ErrorOr TreeParser::parse_segment_id(BitStream& bit_stream, u8 const probabilities[7]) { - auto value = TRY(parse_tree_new(bit_stream, { segment_tree }, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, { segment_tree }, [&](u8 node) { return probabilities[node]; })); // Segment ID is not counted. return value; } @@ -173,7 +173,7 @@ ErrorOr TreeParser::parse_segment_id(BitStream& bit_stream, u8 const probabi ErrorOr TreeParser::parse_segment_id_predicted(BitStream& bit_stream, u8 const probabilities[3], u8 above_seg_pred_context, u8 left_seg_pred_context) { auto context = left_seg_pred_context + above_seg_pred_context; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probabilities[context]; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probabilities[context]; })); // Segment ID prediction is not counted. return value; } @@ -186,7 +186,7 @@ ErrorOr TreeParser::parse_inter_mode(BitStream& bit_stream, Prob // Probabilities u8 const* probabilities = probability_table.inter_mode_probs()[mode_context_for_ref_frame_0]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); increment_counter(counter.m_counts_inter_mode[mode_context_for_ref_frame_0][to_underlying(value) - to_underlying(PredictionMode::NearestMv)]); return value; } @@ -215,7 +215,7 @@ ErrorOr TreeParser::parse_interpolation_filter(BitStream& b context = above_interp; u8 const* probabilities = probability_table.interp_filter_probs()[context]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); increment_counter(counter.m_counts_interp_filter[context][to_underlying(value)]); return value; } @@ -228,7 +228,7 @@ ErrorOr TreeParser::parse_skip(BitStream& bit_stream, ProbabilityTables co context += static_cast(left_skip.value_or(false)); u8 probability = probability_table.skip_prob()[context]; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability; })); increment_counter(counter.m_counts_skip[context][value]); return value; } @@ -260,7 +260,7 @@ ErrorOr TreeParser::parse_tx_size(BitStream& bit_stream, ProbabilityTabl auto context = (above + left) > max_tx_size; u8 const* probabilities = probability_table.tx_probs()[max_tx_size][context]; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8 node) { return probabilities[node]; })); increment_counter(counter.m_counts_tx_size[max_tx_size][context][value]); return value; } @@ -277,7 +277,7 @@ ErrorOr TreeParser::parse_is_inter(BitStream& bit_stream, ProbabilityTable context = 2 * static_cast(above_intra.has_value() ? above_intra.value() : left_intra.value()); u8 probability = probability_table.is_inter_prob()[context]; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability; })); increment_counter(counter.m_counts_is_inter[context][value]); return value; } @@ -317,7 +317,7 @@ ErrorOr TreeParser::parse_comp_mode(BitStream& bit_stream, Probab } u8 probability = probability_table.comp_mode_prob()[context]; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability; })); increment_counter(counter.m_counts_comp_mode[context][value]); return value; } @@ -399,7 +399,7 @@ ErrorOr TreeParser::parse_comp_ref(BitStream& bit_stream, ProbabilityTable u8 probability = probability_table.comp_ref_prob()[context]; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability; })); increment_counter(counter.m_counts_comp_ref[context][value]); return value; } @@ -466,7 +466,7 @@ ErrorOr TreeParser::parse_single_ref_part_1(BitStream& bit_stream, Probabi } u8 probability = probability_table.single_ref_prob()[context][0]; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability; })); increment_counter(counter.m_counts_single_ref[context][0][value]); return value; } @@ -552,21 +552,21 @@ ErrorOr TreeParser::parse_single_ref_part_2(BitStream& bit_stream, Probabi } u8 probability = probability_table.single_ref_prob()[context][1]; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability; })); increment_counter(counter.m_counts_single_ref[context][1][value]); return value; } ErrorOr TreeParser::parse_motion_vector_joint(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter) { - auto value = TRY(parse_tree_new(bit_stream, { mv_joint_tree }, [&](u8 node) { return probability_table.mv_joint_probs()[node]; })); + auto value = TRY(parse_tree(bit_stream, { mv_joint_tree }, [&](u8 node) { return probability_table.mv_joint_probs()[node]; })); increment_counter(counter.m_counts_mv_joint[value]); return value; } ErrorOr TreeParser::parse_motion_vector_sign(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component) { - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability_table.mv_sign_prob()[component]; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability_table.mv_sign_prob()[component]; })); increment_counter(counter.m_counts_mv_sign[component][value]); return value; } @@ -575,21 +575,21 @@ ErrorOr TreeParser::parse_motion_vector_class(BitStream& bit_stream, Pr { // Spec doesn't mention node, but the probabilities table has an extra dimension // so we will use node for that. - auto value = TRY(parse_tree_new(bit_stream, { mv_class_tree }, [&](u8 node) { return probability_table.mv_class_probs()[component][node]; })); + auto value = TRY(parse_tree(bit_stream, { mv_class_tree }, [&](u8 node) { return probability_table.mv_class_probs()[component][node]; })); increment_counter(counter.m_counts_mv_class[component][value]); return value; } ErrorOr TreeParser::parse_motion_vector_class0_bit(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component) { - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability_table.mv_class0_bit_prob()[component]; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability_table.mv_class0_bit_prob()[component]; })); increment_counter(counter.m_counts_mv_class0_bit[component][value]); return value; } ErrorOr TreeParser::parse_motion_vector_class0_fr(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component, bool class_0_bit) { - auto value = TRY(parse_tree_new(bit_stream, { mv_fr_tree }, [&](u8 node) { return probability_table.mv_class0_fr_probs()[component][class_0_bit][node]; })); + auto value = TRY(parse_tree(bit_stream, { mv_fr_tree }, [&](u8 node) { return probability_table.mv_class0_fr_probs()[component][class_0_bit][node]; })); increment_counter(counter.m_counts_mv_class0_fr[component][class_0_bit][value]); return value; } @@ -599,21 +599,21 @@ ErrorOr TreeParser::parse_motion_vector_class0_hp(BitStream& bit_stream, P TreeParser::TreeSelection tree { 1 }; if (use_hp) tree = { binary_tree }; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8) { return probability_table.mv_class0_hp_prob()[component]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8) { return probability_table.mv_class0_hp_prob()[component]; })); increment_counter(counter.m_counts_mv_class0_hp[component][value]); return value; } ErrorOr TreeParser::parse_motion_vector_bit(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component, u8 bit_index) { - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability_table.mv_bits_prob()[component][bit_index]; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability_table.mv_bits_prob()[component][bit_index]; })); increment_counter(counter.m_counts_mv_bits[component][bit_index][value]); return value; } ErrorOr TreeParser::parse_motion_vector_fr(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component) { - auto value = TRY(parse_tree_new(bit_stream, { mv_fr_tree }, [&](u8 node) { return probability_table.mv_fr_probs()[component][node]; })); + auto value = TRY(parse_tree(bit_stream, { mv_fr_tree }, [&](u8 node) { return probability_table.mv_fr_probs()[component][node]; })); increment_counter(counter.m_counts_mv_fr[component][value]); return value; } @@ -623,7 +623,7 @@ ErrorOr TreeParser::parse_motion_vector_hp(BitStream& bit_stream, Probabil TreeParser::TreeSelection tree { 1 }; if (use_hp) tree = { binary_tree }; - auto value = TRY(parse_tree_new(bit_stream, tree, [&](u8) { return probability_table.mv_hp_prob()[component]; })); + auto value = TRY(parse_tree(bit_stream, tree, [&](u8) { return probability_table.mv_hp_prob()[component]; })); increment_counter(counter.m_counts_mv_hp[component][value]); return value; } @@ -682,7 +682,7 @@ TokensContext TreeParser::get_tokens_context(bool subsampling_x, bool subsamplin ErrorOr TreeParser::parse_more_coefficients(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, TokensContext const& context) { auto probability = probability_table.coef_probs()[context.m_tx_size][context.m_is_uv_plane][context.m_is_inter][context.m_band][context.m_context_index][0]; - auto value = TRY(parse_tree_new(bit_stream, { binary_tree }, [&](u8) { return probability; })); + auto value = TRY(parse_tree(bit_stream, { binary_tree }, [&](u8) { return probability; })); increment_counter(counter.m_counts_more_coefs[context.m_tx_size][context.m_is_uv_plane][context.m_is_inter][context.m_band][context.m_context_index][value]); return value; } @@ -700,7 +700,7 @@ ErrorOr TreeParser::parse_token(BitStream& bit_stream, ProbabilityTables return (pareto_table[x][node - 2] + pareto_table[x + 1][node - 2]) >> 1; }; - auto value = TRY(parse_tree_new(bit_stream, { token_tree }, probability_getter)); + auto value = TRY(parse_tree(bit_stream, { token_tree }, probability_getter)); increment_counter(counter.m_counts_token[context.m_tx_size][context.m_is_uv_plane][context.m_is_inter][context.m_band][context.m_context_index][min(2, value)]); return value; }