mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 11:28:12 +00:00
LibVideo: Parameterize all tree parsing for motion vectors in VP9
This commit is contained in:
Zaggy1024
Andrew Kaster
parent
84f1aed40a
commit
e906bcc696
3 changed files with 97 additions and 102 deletions
|
|
@ -1338,7 +1338,7 @@ DecoderErrorOr<void> Parser::read_mv(u8 ref)
|
|||
{
|
||||
m_use_hp = m_allow_high_precision_mv && use_mv_hp(m_best_mv[ref]);
|
||||
MotionVector diff_mv;
|
||||
auto mv_joint = TRY_READ(m_tree_parser->parse_tree<MvJoint>(SyntaxElementType::MVJoint));
|
||||
auto mv_joint = TRY_READ(TreeParser::parse_motion_vector_joint(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter));
|
||||
if (mv_joint == MvJointHzvnz || mv_joint == MvJointHnzvnz)
|
||||
diff_mv.set_row(TRY(read_mv_component(0)));
|
||||
if (mv_joint == MvJointHnzvz || mv_joint == MvJointHnzvnz)
|
||||
|
|
@ -1352,27 +1352,26 @@ DecoderErrorOr<void> Parser::read_mv(u8 ref)
|
|||
|
||||
DecoderErrorOr<i32> Parser::read_mv_component(u8 component)
|
||||
{
|
||||
m_tree_parser->set_mv_component(component);
|
||||
auto mv_sign = TRY_READ(m_tree_parser->parse_tree<bool>(SyntaxElementType::MVSign));
|
||||
auto mv_class = TRY_READ(m_tree_parser->parse_tree<MvClass>(SyntaxElementType::MVClass));
|
||||
u32 mag;
|
||||
auto mv_sign = TRY_READ(TreeParser::parse_motion_vector_sign(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component));
|
||||
auto mv_class = TRY_READ(TreeParser::parse_motion_vector_class(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component));
|
||||
u32 magnitude;
|
||||
if (mv_class == MvClass0) {
|
||||
u32 mv_class0_bit = TRY_READ(m_tree_parser->parse_tree<bool>(SyntaxElementType::MVClass0Bit));
|
||||
u32 mv_class0_fr = TRY_READ(m_tree_parser->parse_mv_class0_fr(mv_class0_bit));
|
||||
u32 mv_class0_hp = TRY_READ(m_tree_parser->parse_tree<bool>(SyntaxElementType::MVClass0HP));
|
||||
mag = ((mv_class0_bit << 3) | (mv_class0_fr << 1) | mv_class0_hp) + 1;
|
||||
auto mv_class0_bit = TRY_READ(TreeParser::parse_motion_vector_class0_bit(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component));
|
||||
auto mv_class0_fr = TRY_READ(TreeParser::parse_motion_vector_class0_fr(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component, mv_class0_bit));
|
||||
auto mv_class0_hp = TRY_READ(TreeParser::parse_motion_vector_class0_hp(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component, m_use_hp));
|
||||
magnitude = ((mv_class0_bit << 3) | (mv_class0_fr << 1) | mv_class0_hp) + 1;
|
||||
} else {
|
||||
u32 d = 0;
|
||||
u32 bits = 0;
|
||||
for (u8 i = 0; i < mv_class; i++) {
|
||||
u32 mv_bit = TRY_READ(m_tree_parser->parse_mv_bit(i));
|
||||
d |= mv_bit << i;
|
||||
auto mv_bit = TRY_READ(TreeParser::parse_motion_vector_bit(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component, i));
|
||||
bits |= mv_bit << i;
|
||||
}
|
||||
mag = CLASS0_SIZE << (mv_class + 2);
|
||||
u32 mv_fr = TRY_READ(m_tree_parser->parse_tree<u8>(SyntaxElementType::MVFR));
|
||||
u32 mv_hp = TRY_READ(m_tree_parser->parse_tree<bool>(SyntaxElementType::MVHP));
|
||||
mag += ((d << 3) | (mv_fr << 1) | mv_hp) + 1;
|
||||
magnitude = CLASS0_SIZE << (mv_class + 2);
|
||||
auto mv_fr = TRY_READ(TreeParser::parse_motion_vector_fr(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component));
|
||||
auto mv_hp = TRY_READ(TreeParser::parse_motion_vector_hp(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, component, m_use_hp));
|
||||
magnitude += ((bits << 3) | (mv_fr << 1) | mv_hp) + 1;
|
||||
}
|
||||
return (mv_sign ? -1 : 1) * static_cast<i32>(mag);
|
||||
return (mv_sign ? -1 : 1) * static_cast<i32>(magnitude);
|
||||
}
|
||||
|
||||
Gfx::Point<size_t> Parser::get_decoded_point_for_plane(u32 column, u32 row, u8 plane)
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -81,6 +81,16 @@ public:
|
|||
static ErrorOr<bool> parse_single_ref_part_1(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, Optional<bool> above_single, Optional<bool> left_single, Optional<bool> above_intra, Optional<bool> left_intra, Optional<ReferenceFramePair> above_ref_frame, Optional<ReferenceFramePair> left_ref_frame);
|
||||
static ErrorOr<bool> parse_single_ref_part_2(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, Optional<bool> above_single, Optional<bool> left_single, Optional<bool> above_intra, Optional<bool> left_intra, Optional<ReferenceFramePair> above_ref_frame, Optional<ReferenceFramePair> left_ref_frame);
|
||||
|
||||
static ErrorOr<MvJoint> parse_motion_vector_joint(BitStream&, ProbabilityTables const&, SyntaxElementCounter&);
|
||||
static ErrorOr<bool> parse_motion_vector_sign(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component);
|
||||
static ErrorOr<MvClass> parse_motion_vector_class(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component);
|
||||
static ErrorOr<bool> parse_motion_vector_class0_bit(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component);
|
||||
static ErrorOr<u8> parse_motion_vector_class0_fr(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component, bool class_0_bit);
|
||||
static ErrorOr<bool> parse_motion_vector_class0_hp(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component, bool use_hp);
|
||||
static ErrorOr<bool> parse_motion_vector_bit(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component, u8 bit_index);
|
||||
static ErrorOr<u8> parse_motion_vector_fr(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component);
|
||||
static ErrorOr<bool> parse_motion_vector_hp(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 component, bool use_hp);
|
||||
|
||||
void set_default_intra_mode_variables(u8 idx, u8 idy)
|
||||
{
|
||||
m_idx = idx;
|
||||
|
|
@ -95,23 +105,6 @@ public:
|
|||
m_start_y = start_y;
|
||||
}
|
||||
|
||||
void set_mv_component(u8 component)
|
||||
{
|
||||
m_mv_component = component;
|
||||
}
|
||||
|
||||
ErrorOr<bool> parse_mv_bit(u8 bit)
|
||||
{
|
||||
m_mv_bit = bit;
|
||||
return parse_tree<bool>(SyntaxElementType::MVBit);
|
||||
}
|
||||
|
||||
ErrorOr<u8> parse_mv_class0_fr(bool mv_class0_bit)
|
||||
{
|
||||
m_mv_class0_bit = mv_class0_bit;
|
||||
return parse_tree<u8>(SyntaxElementType::MVClass0FR);
|
||||
}
|
||||
|
||||
private:
|
||||
u8 calculate_token_probability(u8 node);
|
||||
u8 calculate_more_coefs_probability();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue