RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 02:07:36 +00:00
Code Issues Activity Actions

LibVideo: Use Gfx::Size for VP9 frame sizes

Browse source 
Frame sizes will now be represented by Gfx::Size instead of storing
width and height separately.
This commit is contained in:
Zaggy1024 2022-11-04 18:00:37 -05:00 • committed by Andrew Kaster
parent 40b0bb0914
commit 1c6d0a9777
3 changed files with 48 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

34
Userland/Libraries/LibVideo/VP9/Decoder.cpp
View file

@ -87,13 +87,10 @@ DecoderErrorOr<void> Decoder::decode_frame(ReadonlyBytes frame_data)
DecoderErrorOr<void> Decoder::create_video_frame()
{
size_t decoded_y_width = m_parser->m_mi_cols * 8;
Gfx::Size<size_t> output_y_size = {
m_parser->m_frame_width,
m_parser->m_frame_height,
};
u32 decoded_y_width = m_parser->m_mi_cols * 8;
Gfx::Size<u32> output_y_size = m_parser->m_frame_size;
auto decoded_uv_width = decoded_y_width >> m_parser->m_subsampling_x;
Gfx::Size<size_t> output_uv_size = {
Gfx::Size<u32> output_uv_size = {
output_y_size.width() >> m_parser->m_subsampling_x,
output_y_size.height() >> m_parser->m_subsampling_y,
};
@ -816,11 +813,11 @@ DecoderErrorOr<void> Decoder::predict_inter_block(u8 plane, u8 ref_list, u32 x,
// − FrameHeight <= 16 * RefFrameHeight[ refIdx ]
if (m_parser->m_frame_store[reference_frame_index][plane].is_empty())
return DecoderError::format(DecoderErrorCategory::Corrupted, "Attempted to use reference frame {} that has not been saved", reference_frame_index);
if (2 * m_parser->m_frame_width < m_parser->m_ref_frame_width[reference_frame_index]
|| 2 * m_parser->m_frame_height < m_parser->m_ref_frame_height[reference_frame_index])
auto ref_frame_size = m_parser->m_ref_frame_size[reference_frame_index];
auto double_frame_size = m_parser->m_frame_size.scaled_by(2);
if (double_frame_size.width() < ref_frame_size.width() || double_frame_size.height() < ref_frame_size.height())
return DecoderError::format(DecoderErrorCategory::Corrupted, "Inter frame size is too small relative to reference frame {}", reference_frame_index);
if (m_parser->m_frame_width > 16 * m_parser->m_ref_frame_width[reference_frame_index]
|| m_parser->m_frame_height > 16 * m_parser->m_ref_frame_height[reference_frame_index])
if (!ref_frame_size.scaled_by(16).contains(m_parser->m_frame_size))
return DecoderError::format(DecoderErrorCategory::Corrupted, "Inter frame size is too large relative to reference frame {}", reference_frame_index);
// FIXME: Convert all the operations in this function to vector operations supported by
@ -830,8 +827,8 @@ DecoderErrorOr<void> Decoder::predict_inter_block(u8 plane, u8 ref_list, u32 x,
// A variable yScale is set equal to (RefFrameHeight[ refIdx ] << REF_SCALE_SHIFT) / FrameHeight.
// (xScale and yScale specify the size of the reference frame relative to the current frame in units where 16 is
// equivalent to the reference frame having the same size.)
i32 x_scale = (m_parser->m_ref_frame_width[reference_frame_index] << REF_SCALE_SHIFT) / m_parser->m_frame_width;
i32 y_scale = (m_parser->m_ref_frame_height[reference_frame_index] << REF_SCALE_SHIFT) / m_parser->m_frame_height;
i32 x_scale = (ref_frame_size.width() << REF_SCALE_SHIFT) / m_parser->m_frame_size.width();
i32 y_scale = (ref_frame_size.height() << REF_SCALE_SHIFT) / m_parser->m_frame_size.height();
// The variable baseX is set equal to (x * xScale) >> REF_SCALE_SHIFT.
// The variable baseY is set equal to (y * yScale) >> REF_SCALE_SHIFT.
@ -885,7 +882,7 @@ DecoderErrorOr<void> Decoder::predict_inter_block(u8 plane, u8 ref_list, u32 x,
// A variable ref specifying the reference frame contents is set equal to FrameStore[ refIdx ].
auto& reference_frame_buffer = m_parser->m_frame_store[reference_frame_index][plane];
auto reference_frame_width = m_parser->m_ref_frame_width[reference_frame_index] >> subsampling_x;
auto reference_frame_width = m_parser->m_ref_frame_size[reference_frame_index].width() >> subsampling_x;
auto reference_frame_buffer_at = [&](u32 row, u32 column) -> u16& {
return reference_frame_buffer[row * reference_frame_width + column];
};
@ -898,8 +895,8 @@ DecoderErrorOr<void> Decoder::predict_inter_block(u8 plane, u8 ref_list, u32 x,
// The variable lastX is set equal to ( (RefFrameWidth[ refIdx ] + subX) >> subX) - 1.
// The variable lastY is set equal to ( (RefFrameHeight[ refIdx ] + subY) >> subY) - 1.
// (lastX and lastY specify the coordinates of the bottom right sample of the reference plane.)
i32 scaled_right = ((m_parser->m_ref_frame_width[reference_frame_index] + subsampling_x) >> subsampling_x) - 1;
i32 scaled_bottom = ((m_parser->m_ref_frame_height[reference_frame_index] + subsampling_y) >> subsampling_y) - 1;
i32 scaled_right = ((m_parser->m_ref_frame_size[reference_frame_index].width() + subsampling_x) >> subsampling_x) - 1;
i32 scaled_bottom = ((m_parser->m_ref_frame_size[reference_frame_index].height() + subsampling_y) >> subsampling_y) - 1;
// The variable intermediateHeight specifying the height required for the intermediate array is set equal to (((h -
// 1) * yStep + 15) >> 4) + 8.
@ -1779,9 +1776,8 @@ DecoderErrorOr<void> Decoder::update_reference_frames()
for (auto i = 0; i < NUM_REF_FRAMES; i++) {
if ((refresh_flags & 1) != 0) {
// − RefFrameWidth[ i ] is set equal to FrameWidth.
m_parser->m_ref_frame_width[i] = m_parser->m_frame_width;
// − RefFrameHeight[ i ] is set equal to FrameHeight.
m_parser->m_ref_frame_height[i] = m_parser->m_frame_height;
m_parser->m_ref_frame_size[i] = m_parser->m_frame_size;
// − RefSubsamplingX[ i ] is set equal to subsampling_x.
m_parser->m_ref_subsampling_x[i] = m_parser->m_subsampling_x;
// − RefSubsamplingY[ i ] is set equal to subsampling_y.
@ -1798,8 +1794,8 @@ DecoderErrorOr<void> Decoder::update_reference_frames()
// FIXME: Frame width is not equal to the buffer's stride. If we store the stride of the buffer with the reference
// frame, we can just copy the framebuffer data instead. Alternatively, we should crop the output framebuffer.
for (auto plane = 0u; plane < 3; plane++) {
auto width = m_parser->m_frame_width;
auto height = m_parser->m_frame_height;
auto width = m_parser->m_frame_size.width();
auto height = m_parser->m_frame_size.height();
auto stride = m_parser->m_mi_cols * 8;
if (plane > 0) {

60
Userland/Libraries/LibVideo/VP9/Parser.cpp
View file

@ -168,8 +168,8 @@ DecoderErrorOr<void> Parser::uncompressed_header()
if (m_frame_type == KeyFrame) {
TRY(frame_sync_code());
TRY(color_config());
TRY(frame_size());
TRY(render_size());
m_frame_size = TRY(frame_size());
m_render_size = TRY(render_size(m_frame_size));
m_refresh_frame_flags = 0xFF;
m_frame_is_intra = true;
} else {
@ -193,20 +193,23 @@ DecoderErrorOr<void> Parser::uncompressed_header()
}
m_refresh_frame_flags = TRY_READ(m_bit_stream->read_f8());
TRY(frame_size());
TRY(render_size());
m_frame_size = TRY(frame_size());
m_render_size = TRY(render_size(m_frame_size));
} else {
m_refresh_frame_flags = TRY_READ(m_bit_stream->read_f8());
for (auto i = 0; i < 3; i++) {
m_ref_frame_idx[i] = TRY_READ(m_bit_stream->read_bits(3));
m_ref_frame_sign_bias[LastFrame + i] = TRY_READ(m_bit_stream->read_bit());
}
TRY(frame_size_with_refs());
m_frame_size = TRY(frame_size_with_refs());
m_render_size = TRY(render_size(m_frame_size));
m_allow_high_precision_mv = TRY_READ(m_bit_stream->read_bit());
TRY(read_interpolation_filter());
}
}
compute_image_size();
if (!m_error_resilient_mode) {
m_refresh_frame_context = TRY_READ(m_bit_stream->read_bit());
m_frame_parallel_decoding_mode = TRY_READ(m_bit_stream->read_bit());
@ -284,51 +287,38 @@ DecoderErrorOr<void> Parser::color_config()
return {};
}
DecoderErrorOr<void> Parser::frame_size()
DecoderErrorOr<Gfx::Size<u32>> Parser::frame_size()
{
m_frame_width = TRY_READ(m_bit_stream->read_f16()) + 1;
m_frame_height = TRY_READ(m_bit_stream->read_f16()) + 1;
compute_image_size();
return {};
return Gfx::Size<u32> { TRY_READ(m_bit_stream->read_f16()) + 1, TRY_READ(m_bit_stream->read_f16()) + 1 };
}
DecoderErrorOr<void> Parser::render_size()
DecoderErrorOr<Gfx::Size<u32>> Parser::render_size(Gfx::Size<u32> frame_size)
{
if (TRY_READ(m_bit_stream->read_bit())) {
m_render_width = TRY_READ(m_bit_stream->read_f16()) + 1;
m_render_height = TRY_READ(m_bit_stream->read_f16()) + 1;
} else {
m_render_width = m_frame_width;
m_render_height = m_frame_height;
}
return {};
if (!TRY_READ(m_bit_stream->read_bit()))
return frame_size;
return Gfx::Size<u32> { TRY_READ(m_bit_stream->read_f16()) + 1, TRY_READ(m_bit_stream->read_f16()) + 1 };
}
DecoderErrorOr<void> Parser::frame_size_with_refs()
DecoderErrorOr<Gfx::Size<u32>> Parser::frame_size_with_refs()
{
bool found_ref;
Optional<Gfx::Size<u32>> size;
for (auto frame_index : m_ref_frame_idx) {
found_ref = TRY_READ(m_bit_stream->read_bit());
if (found_ref) {
m_frame_width = m_ref_frame_width[frame_index];
m_frame_height = m_ref_frame_height[frame_index];
if (TRY_READ(m_bit_stream->read_bit())) {
size.emplace(m_ref_frame_size[frame_index]);
break;
}
}
if (!found_ref) {
TRY(frame_size());
} else {
compute_image_size();
}
if (size.has_value())
return size.value();
return render_size();
return TRY(frame_size());
}
void Parser::compute_image_size()
{
auto new_cols = (m_frame_width + 7u) >> 3u;
auto new_rows = (m_frame_height + 7u) >> 3u;
auto new_cols = (m_frame_size.width() + 7u) >> 3u;
auto new_rows = (m_frame_size.height() + 7u) >> 3u;
// 7.2.6 Compute image size semantics
// When compute_image_size is invoked, the following ordered steps occur:
@ -1728,8 +1718,8 @@ void Parser::append_sub8x8_mvs(i32 block, u8 ref_list)
void Parser::dump_info()
{
outln("Frame dimensions: {}x{}", m_frame_width, m_frame_height);
outln("Render dimensions: {}x{}", m_render_width, m_render_height);
outln("Frame dimensions: {}x{}", m_frame_size.width(), m_frame_size.height());
outln("Render dimensions: {}x{}", m_render_size.width(), m_render_size.height());
outln("Bit depth: {}", m_bit_depth);
outln("Show frame: {}", m_show_frame);
}

18
Userland/Libraries/LibVideo/VP9/Parser.h
View file

@ -11,7 +11,7 @@
#include <AK/OwnPtr.h>
#include <AK/Span.h>
#include <AK/Vector.h>
#include <LibGfx/Forward.h>
#include <LibGfx/Size.h>
#include <LibVideo/Color/CodingIndependentCodePoints.h>
#include <LibVideo/DecoderError.h>
@ -60,9 +60,10 @@ private:
DecoderErrorOr<void> uncompressed_header();
DecoderErrorOr<void> frame_sync_code();
DecoderErrorOr<void> color_config();
DecoderErrorOr<void> frame_size();
DecoderErrorOr<void> render_size();
DecoderErrorOr<void> frame_size_with_refs();
DecoderErrorOr<void> set_frame_size_and_compute_image_size();
DecoderErrorOr<Gfx::Size<u32>> frame_size();
DecoderErrorOr<Gfx::Size<u32>> frame_size_with_refs();
DecoderErrorOr<Gfx::Size<u32>> render_size(Gfx::Size<u32> frame_size);
void compute_image_size();
DecoderErrorOr<void> read_interpolation_filter();
DecoderErrorOr<void> loop_filter_params();
@ -171,10 +172,8 @@ private:
ColorRange m_color_range;
bool m_subsampling_x { false };
bool m_subsampling_y { false };
u32 m_frame_width { 0 };
u32 m_frame_height { 0 };
u16 m_render_width { 0 };
u16 m_render_height { 0 };
Gfx::Size<u32> m_frame_size { 0, 0 };
Gfx::Size<u32> m_render_size { 0, 0 };
bool m_render_and_frame_size_different { false };
u32 m_mi_cols { 0 };
u32 m_mi_rows { 0 };
@ -257,8 +256,7 @@ private:
MotionVector m_nearest_mv[2];
MotionVector m_best_mv[2];
// FIXME: Move these to a struct to store together in one array.
u32 m_ref_frame_width[NUM_REF_FRAMES];
u32 m_ref_frame_height[NUM_REF_FRAMES];
Gfx::Size<u32> m_ref_frame_size[NUM_REF_FRAMES];
bool m_ref_subsampling_x[NUM_REF_FRAMES];
bool m_ref_subsampling_y[NUM_REF_FRAMES];
u8 m_ref_bit_depth[NUM_REF_FRAMES];