1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 18:07:34 +00:00

LibVideo: Parameterize all tree parsing for motion vectors in VP9

This commit is contained in:
Zaggy1024 2022-11-07 04:09:59 -06:00 committed by Andrew Kaster
parent 84f1aed40a
commit e906bcc696
3 changed files with 97 additions and 102 deletions

View file

@ -581,29 +581,85 @@ ErrorOr<bool> TreeParser::parse_single_ref_part_2(BitStream& bit_stream, Probabi
return value;
}
ErrorOr<MvJoint> TreeParser::parse_motion_vector_joint(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter)
{
auto value = TRY(parse_tree_new<MvJoint>(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<bool> TreeParser::parse_motion_vector_sign(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component)
{
auto value = TRY(parse_tree_new<bool>(bit_stream, { binary_tree }, [&](u8) { return probability_table.mv_sign_prob()[component]; }));
increment_counter(counter.m_counts_mv_sign[component][value]);
return value;
}
ErrorOr<MvClass> TreeParser::parse_motion_vector_class(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component)
{
// 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<MvClass>(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<bool> TreeParser::parse_motion_vector_class0_bit(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component)
{
auto value = TRY(parse_tree_new<bool>(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<u8> 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<u8>(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;
}
ErrorOr<bool> TreeParser::parse_motion_vector_class0_hp(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component, bool use_hp)
{
TreeParser::TreeSelection tree { 1 };
if (use_hp)
tree = { binary_tree };
auto value = TRY(parse_tree_new<bool>(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<bool> 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<bool>(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<u8> TreeParser::parse_motion_vector_fr(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component)
{
auto value = TRY(parse_tree_new<u8>(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;
}
ErrorOr<bool> TreeParser::parse_motion_vector_hp(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 component, bool use_hp)
{
TreeParser::TreeSelection tree { 1 };
if (use_hp)
tree = { binary_tree };
auto value = TRY(parse_tree_new<u8>(bit_stream, tree, [&](u8) { return probability_table.mv_hp_prob()[component]; }));
increment_counter(counter.m_counts_mv_hp[component][value]);
return value;
}
/*
* Select a tree value based on the type of syntax element being parsed, as well as some parser state, as specified in section 9.3.1
*/
TreeParser::TreeSelection TreeParser::select_tree(SyntaxElementType type)
{
switch (type) {
case SyntaxElementType::MVSign:
case SyntaxElementType::MVClass0Bit:
case SyntaxElementType::MVBit:
case SyntaxElementType::MoreCoefs:
return { binary_tree };
case SyntaxElementType::MVJoint:
return { mv_joint_tree };
case SyntaxElementType::MVClass:
return { mv_class_tree };
case SyntaxElementType::MVClass0FR:
case SyntaxElementType::MVFR:
return { mv_fr_tree };
case SyntaxElementType::MVClass0HP:
case SyntaxElementType::MVHP:
if (m_decoder.m_use_hp)
return { binary_tree };
return { 1 };
case SyntaxElementType::Token:
return { token_tree };
default:
@ -618,28 +674,6 @@ TreeParser::TreeSelection TreeParser::select_tree(SyntaxElementType type)
u8 TreeParser::select_tree_probability(SyntaxElementType type, u8 node)
{
switch (type) {
case SyntaxElementType::MVSign:
return m_decoder.m_probability_tables->mv_sign_prob()[m_mv_component];
case SyntaxElementType::MVClass0Bit:
return m_decoder.m_probability_tables->mv_class0_bit_prob()[m_mv_component];
case SyntaxElementType::MVBit:
VERIFY(m_mv_bit < MV_OFFSET_BITS);
return m_decoder.m_probability_tables->mv_bits_prob()[m_mv_component][m_mv_bit];
case SyntaxElementType::MVJoint:
return m_decoder.m_probability_tables->mv_joint_probs()[node];
case SyntaxElementType::MVClass:
// Spec doesn't mention node, but the probabilities table has an extra dimension
// so we will use node for that.
return m_decoder.m_probability_tables->mv_class_probs()[m_mv_component][node];
case SyntaxElementType::MVClass0FR:
VERIFY(m_mv_class0_bit < CLASS0_SIZE);
return m_decoder.m_probability_tables->mv_class0_fr_probs()[m_mv_component][m_mv_class0_bit][node];
case SyntaxElementType::MVClass0HP:
return m_decoder.m_probability_tables->mv_class0_hp_prob()[m_mv_component];
case SyntaxElementType::MVFR:
return m_decoder.m_probability_tables->mv_fr_probs()[m_mv_component][node];
case SyntaxElementType::MVHP:
return m_decoder.m_probability_tables->mv_hp_prob()[m_mv_component];
case SyntaxElementType::Token:
return calculate_token_probability(node);
case SyntaxElementType::MoreCoefs:
@ -738,37 +772,6 @@ void TreeParser::count_syntax_element(SyntaxElementType type, int value)
increment_counter(count);
};
switch (type) {
case SyntaxElementType::MVSign:
increment(m_decoder.m_syntax_element_counter->m_counts_mv_sign[m_mv_component][value]);
return;
case SyntaxElementType::MVClass0Bit:
increment(m_decoder.m_syntax_element_counter->m_counts_mv_class0_bit[m_mv_component][value]);
return;
case SyntaxElementType::MVBit:
VERIFY(m_mv_bit < MV_OFFSET_BITS);
increment(m_decoder.m_syntax_element_counter->m_counts_mv_bits[m_mv_component][m_mv_bit][value]);
m_mv_bit = 0xFF;
return;
case SyntaxElementType::MVJoint:
increment(m_decoder.m_syntax_element_counter->m_counts_mv_joint[value]);
return;
case SyntaxElementType::MVClass:
increment(m_decoder.m_syntax_element_counter->m_counts_mv_class[m_mv_component][value]);
return;
case SyntaxElementType::MVClass0FR:
VERIFY(m_mv_class0_bit < CLASS0_SIZE);
increment(m_decoder.m_syntax_element_counter->m_counts_mv_class0_fr[m_mv_component][m_mv_class0_bit][value]);
m_mv_class0_bit = 0xFF;
return;
case SyntaxElementType::MVClass0HP:
increment(m_decoder.m_syntax_element_counter->m_counts_mv_class0_hp[m_mv_component][value]);
return;
case SyntaxElementType::MVFR:
increment(m_decoder.m_syntax_element_counter->m_counts_mv_fr[m_mv_component][value]);
return;
case SyntaxElementType::MVHP:
increment(m_decoder.m_syntax_element_counter->m_counts_mv_hp[m_mv_component][value]);
return;
case SyntaxElementType::Token:
increment(m_decoder.m_syntax_element_counter->m_counts_token[m_tx_size][m_plane > 0][m_decoder.m_is_inter][m_band][m_ctx][min(2, value)]);
return;