KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
mesa/src/gallium/frontends/omx/bellagio/vid_dec_av1.c

2471 lines
84 KiB
C
Raw Blame History

/**************************************************************************
*
* Copyright 2020 Advanced Micro Devices, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "pipe/p_video_codec.h"
#include "util/u_memory.h"
#include "util/u_video.h"
#include "vl/vl_video_buffer.h"
#include "vl/vl_codec.h"
#include "entrypoint.h"
#include "vid_dec.h"
#include "vid_dec_av1.h"
static unsigned av1_f(struct vl_vlc *vlc, unsigned n)
{
unsigned valid = vl_vlc_valid_bits(vlc);
if (n == 0)
return 0;
if (valid < 32)
vl_vlc_fillbits(vlc);
return vl_vlc_get_uimsbf(vlc, n);
}
static unsigned av1_uvlc(struct vl_vlc *vlc)
{
unsigned value;
unsigned leadingZeros = 0;
while (1) {
bool done = av1_f(vlc, 1);
if (done)
break;
leadingZeros++;
}
if (leadingZeros >= 32)
return 0xffffffff;
value = av1_f(vlc, leadingZeros);
return value + (1 << leadingZeros) - 1;
}
static int av1_le(struct vl_vlc *vlc, const unsigned n)
{
unsigned byte, t = 0;
unsigned i;
for (i = 0; i < n; ++i) {
byte = av1_f(vlc, 8);
t += (byte << (i * 8));
}
return t;
}
static unsigned av1_uleb128(struct vl_vlc *vlc)
{
unsigned value = 0;
unsigned leb128Bytes = 0;
unsigned i;
for (i = 0; i < 8; ++i) {
leb128Bytes = av1_f(vlc, 8);
value |= ((leb128Bytes & 0x7f) << (i * 7));
if (!(leb128Bytes & 0x80))
break;
}
return value;
}
static int av1_su(struct vl_vlc *vlc, const unsigned n)
{
unsigned value = av1_f(vlc, n);
unsigned signMask = 1 << (n - 1);
if (value && signMask)
value = value - 2 * signMask;
return value;
}
static unsigned FloorLog2(unsigned x)
{
unsigned s = 0;
unsigned x1 = x;
while (x1 != 0) {
x1 = x1 >> 1;
s++;
}
return s - 1;
}
static unsigned av1_ns(struct vl_vlc *vlc, unsigned n)
{
unsigned w = FloorLog2(n) + 1;
unsigned m = (1 << w) - n;
unsigned v = av1_f(vlc, w - 1);
if (v < m)
return v;
bool extra_bit = av1_f(vlc, 1);
return (v << 1) - m + extra_bit;
}
static void av1_byte_alignment(struct vl_vlc *vlc)
{
vl_vlc_eatbits(vlc, vl_vlc_valid_bits(vlc) % 8);
}
static void sequence_header_obu(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
bool timing_info_present_flag;
bool initial_display_delay_present_flag;
uint8_t seq_level_idx;
bool initial_display_delay_present_for_this_op;
bool high_bitdepth;
bool twelve_bit;
bool color_description_present_flag;
uint8_t color_primaries;
uint8_t transfer_characteristics;
uint8_t matrix_coefficients;
int i;
seq->seq_profile = av1_f(vlc, 3);
assert(seq->seq_profile < 3);
av1_f(vlc, 1); /* still_picture */
seq->reduced_still_picture_header = av1_f(vlc, 1);
if (seq->reduced_still_picture_header) {
timing_info_present_flag = 0;
seq->decoder_model_info_present_flag = 0;
initial_display_delay_present_flag = 0;
seq->operating_points_cnt_minus_1 = 0;
seq->operating_point_idc[0] = 0;
seq_level_idx = av1_f(vlc, 5);
seq->decoder_model_present_for_this_op[0] = 0;
initial_display_delay_present_for_this_op = 0;
} else {
uint8_t buffer_delay_length_minus_1 = 0;
timing_info_present_flag = av1_f(vlc, 1);
if (timing_info_present_flag) {
av1_f(vlc, 32); /* num_units_in_display_tick */
av1_f(vlc, 32); /* time_scale */
seq->timing_info.equal_picture_interval = av1_f(vlc, 1);
if (seq->timing_info.equal_picture_interval)
av1_uvlc(vlc); /* num_ticks_per_picture_minus_1 */
seq->decoder_model_info_present_flag = av1_f(vlc, 1);
if (seq->decoder_model_info_present_flag) {
/* decoder_model_info */
buffer_delay_length_minus_1 = av1_f(vlc, 5);
seq->decoder_model_info.num_units_in_decoding_tick = av1_f(vlc, 32);
seq->decoder_model_info.buffer_removal_time_length_minus_1 = av1_f(vlc, 5);
seq->decoder_model_info.frame_presentation_time_length_minus_1 = av1_f(vlc, 5);
}
} else {
seq->decoder_model_info_present_flag = 0;
}
initial_display_delay_present_flag = av1_f(vlc, 1);
seq->operating_points_cnt_minus_1 = av1_f(vlc, 5);
for (i = 0; i < seq->operating_points_cnt_minus_1 + 1; ++i) {
seq->operating_point_idc[i] = av1_f(vlc, 12);
seq_level_idx = av1_f(vlc, 5);
if (seq_level_idx > 7)
av1_f(vlc, 1); /* seq_tier */
if (seq->decoder_model_info_present_flag) {
seq->decoder_model_present_for_this_op[i] = av1_f(vlc, 1);
if (seq->decoder_model_present_for_this_op[i]) {
uint8_t n = buffer_delay_length_minus_1 + 1;
av1_f(vlc, n); /* decoder_buffer_delay */
av1_f(vlc, n); /* encoder_buffer_delay */
av1_f(vlc, 1); /* low_delay_mode_flag */
}
} else {
seq->decoder_model_present_for_this_op[i] = 0;
}
if (initial_display_delay_present_flag) {
initial_display_delay_present_for_this_op = av1_f(vlc, 1);
if (initial_display_delay_present_for_this_op)
av1_f(vlc, 4); /* initial_display_delay_minus_1 */
}
}
}
seq->frame_width_bits_minus_1 = av1_f(vlc, 4);
seq->frame_height_bits_minus_1 = av1_f(vlc, 4);
seq->max_frame_width_minus_1 = av1_f(vlc, seq->frame_width_bits_minus_1 + 1);
seq->max_frame_height_minus_1 = av1_f(vlc, seq->frame_height_bits_minus_1 + 1);
if (seq->reduced_still_picture_header)
seq->frame_id_numbers_present_flag = 0;
else
seq->frame_id_numbers_present_flag = av1_f(vlc, 1);
if (seq->frame_id_numbers_present_flag) {
seq->delta_frame_id_length_minus_2 = av1_f(vlc, 4);
seq->additional_frame_id_length_minus_1 = av1_f(vlc, 3);
}
seq->use_128x128_superblock = av1_f(vlc, 1);
seq->enable_filter_intra = av1_f(vlc, 1);
seq->enable_intra_edge_filter = av1_f(vlc, 1);
if (seq->reduced_still_picture_header) {
seq->enable_interintra_compound = 0;
seq->enable_masked_compound = 0;
seq->enable_warped_motion = 0;
seq->enable_dual_filter = 0;
seq->enable_order_hint = 0;
seq->enable_jnt_comp = 0;
seq->enable_ref_frame_mvs = 0;
seq->seq_force_screen_content_tools = AV1_SELECT_SCREEN_CONTENT_TOOLS;
seq->seq_force_integer_mv = AV1_SELECT_INTEGER_MV;
seq->OrderHintBits = 0;
} else {
bool seq_choose_screen_content_tools;
seq->enable_interintra_compound = av1_f(vlc, 1);
seq->enable_masked_compound = av1_f(vlc, 1);
seq->enable_warped_motion = av1_f(vlc, 1);
seq->enable_dual_filter = av1_f(vlc, 1);
seq->enable_order_hint = av1_f(vlc, 1);
if (seq->enable_order_hint) {
seq->enable_jnt_comp = av1_f(vlc, 1);
seq->enable_ref_frame_mvs = av1_f(vlc, 1);
} else {
seq->enable_jnt_comp = 0;
seq->enable_ref_frame_mvs = 0;
}
seq_choose_screen_content_tools = av1_f(vlc, 1);
seq->seq_force_screen_content_tools =
seq_choose_screen_content_tools ? AV1_SELECT_SCREEN_CONTENT_TOOLS : av1_f(vlc, 1);
if (seq->seq_force_screen_content_tools > 0) {
bool seq_choose_integer_mv = av1_f(vlc, 1);
seq->seq_force_integer_mv =
seq_choose_integer_mv ? AV1_SELECT_INTEGER_MV : av1_f(vlc, 1);
} else {
seq->seq_force_integer_mv = AV1_SELECT_INTEGER_MV;
}
if (seq->enable_order_hint) {
seq->order_hint_bits_minus_1 = av1_f(vlc, 3);
seq->OrderHintBits = seq->order_hint_bits_minus_1 + 1;
} else {
seq->OrderHintBits = 0;
}
}
seq->enable_superres = av1_f(vlc, 1);
seq->enable_cdef = av1_f(vlc, 1);
seq->enable_restoration = av1_f(vlc, 1);
high_bitdepth = av1_f(vlc, 1);
if (seq->seq_profile == 2 && high_bitdepth) {
twelve_bit = av1_f(vlc, 1);
seq->color_config.BitDepth = twelve_bit ? 12 : 10;
} else if (seq->seq_profile <= 2) {
seq->color_config.BitDepth = high_bitdepth ? 10 : 8;
}
seq->color_config.mono_chrome = (seq->seq_profile == 1) ? 0 : av1_f(vlc, 1);
seq->color_config.NumPlanes = seq->color_config.mono_chrome ? 1 : 3;
color_description_present_flag = av1_f(vlc, 1);
if (color_description_present_flag) {
color_primaries = av1_f(vlc, 8);
transfer_characteristics = av1_f(vlc, 8);
matrix_coefficients = av1_f(vlc, 8);
} else {
color_primaries = AV1_CP_UNSPECIFIED;
transfer_characteristics = AV1_TC_UNSPECIFIED;
matrix_coefficients = AV1_MC_UNSPECIFIED;
}
if (seq->color_config.mono_chrome) {
av1_f(vlc, 1); /* color_range */
seq->color_config.subsampling_x = 1;
seq->color_config.subsampling_y = 1;
seq->color_config.separate_uv_delta_q = 0;
} else if (color_primaries == AV1_CP_BT_709 &&
transfer_characteristics == AV1_TC_SRGB &&
matrix_coefficients == AV1_MC_IDENTITY) {
seq->color_config.subsampling_x = 0;
seq->color_config.subsampling_y = 0;
} else {
av1_f(vlc, 1); /* color_range */
if (seq->seq_profile == 0) {
seq->color_config.subsampling_x = 1;
seq->color_config.subsampling_y = 1;
} else if (seq->seq_profile == 1 ) {
seq->color_config.subsampling_x = 0;
seq->color_config.subsampling_y = 0;
} else {
if (seq->color_config.BitDepth == 12) {
seq->color_config.subsampling_x = av1_f(vlc, 1);
if (seq->color_config.subsampling_x)
seq->color_config.subsampling_y = av1_f(vlc, 1);
else
seq->color_config.subsampling_y = 0;
} else {
seq->color_config.subsampling_x = 1;
seq->color_config.subsampling_y = 0;
}
}
if (seq->color_config.subsampling_x && seq->color_config.subsampling_y)
av1_f(vlc, 2); /* chroma_sample_position */
}
if (!seq->color_config.mono_chrome)
seq->color_config.separate_uv_delta_q = av1_f(vlc, 1);
seq->film_grain_params_present = av1_f(vlc, 1);
priv->picture.av1.picture_parameter.profile = seq->seq_profile;
priv->picture.av1.picture_parameter.seq_info_fields.use_128x128_superblock =
seq->use_128x128_superblock;
priv->picture.av1.picture_parameter.seq_info_fields.enable_filter_intra =
seq->enable_filter_intra;
priv->picture.av1.picture_parameter.seq_info_fields.enable_intra_edge_filter =
seq->enable_intra_edge_filter;
priv->picture.av1.picture_parameter.order_hint_bits_minus_1 =
seq->order_hint_bits_minus_1;
priv->picture.av1.picture_parameter.max_width = seq->max_frame_width_minus_1 + 1;
priv->picture.av1.picture_parameter.max_height = seq->max_frame_height_minus_1 + 1;
priv->picture.av1.picture_parameter.seq_info_fields.enable_interintra_compound =
seq->enable_interintra_compound;
priv->picture.av1.picture_parameter.seq_info_fields.enable_masked_compound =
seq->enable_masked_compound;
priv->picture.av1.picture_parameter.seq_info_fields.enable_dual_filter =
seq->enable_dual_filter;
priv->picture.av1.picture_parameter.seq_info_fields.enable_order_hint =
seq->enable_order_hint;
priv->picture.av1.picture_parameter.seq_info_fields.enable_jnt_comp =
seq->enable_jnt_comp;
priv->picture.av1.picture_parameter.seq_info_fields.ref_frame_mvs =
seq->enable_ref_frame_mvs;
priv->picture.av1.picture_parameter.bit_depth_idx =
(seq->color_config.BitDepth - 8) >> 1;
priv->picture.av1.picture_parameter.seq_info_fields.mono_chrome =
seq->color_config.mono_chrome;
}
static void superres_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
unsigned coded_denom;
if (seq->enable_superres)
hdr->use_superres = av1_f(vlc, 1);
else
hdr->use_superres = 0;
if (hdr->use_superres) {
coded_denom = av1_f(vlc, 3 /* SUPERRES_DENOM_BITS */);
hdr->SuperresDenom = coded_denom + 9 /* SUPERRES_DENOM_MIN */;
} else {
hdr->SuperresDenom = 8 /* SUPERRES_NUM */;
}
hdr->UpscaledWidth = hdr->FrameWidth;
hdr->FrameWidth = (hdr->UpscaledWidth * 8 + (hdr->SuperresDenom / 2)) /
hdr->SuperresDenom;
}
static void compute_image_size(vid_dec_PrivateType *priv)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
hdr->MiCols = 2 * ((hdr->FrameWidth + 7) >> 3);
hdr->MiRows = 2 * ((hdr->FrameHeight + 7) >> 3);
}
static void frame_size(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
unsigned frame_width_minus_1;
unsigned frame_height_minus_1;
if (hdr->frame_size_override_flag) {
frame_width_minus_1 = av1_f(vlc, seq->frame_width_bits_minus_1 + 1);
frame_height_minus_1 = av1_f(vlc, seq->frame_height_bits_minus_1 + 1);
hdr->FrameWidth = frame_width_minus_1 + 1;
hdr->FrameHeight = frame_height_minus_1 + 1;
} else {
hdr->FrameWidth = seq->max_frame_width_minus_1 + 1;
hdr->FrameHeight = seq->max_frame_height_minus_1 + 1;
}
superres_params(priv, vlc);
compute_image_size(priv);
}
static void render_size(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
bool render_and_frame_size_different;
unsigned render_width_minus_1;
unsigned render_height_minus_1;
render_and_frame_size_different = av1_f(vlc, 1);
if (render_and_frame_size_different) {
render_width_minus_1 = av1_f(vlc, 16);
render_height_minus_1 = av1_f(vlc, 16);
hdr->RenderWidth = render_width_minus_1 + 1;
hdr->RenderHeight = render_height_minus_1 + 1;
} else {
hdr->RenderWidth = hdr->UpscaledWidth;
hdr->RenderHeight = hdr->FrameHeight;
}
}
static int get_relative_dist(vid_dec_PrivateType *priv, int a, int b)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
int diff;
unsigned m;
if (!seq->enable_order_hint)
return 0;
diff = a - b;
m = 1 << (seq->OrderHintBits - 1);
diff = (diff & (m - 1)) - (diff & m);
return diff;
}
static uint8_t find_latest_backward(vid_dec_PrivateType *priv)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
uint8_t ref = 0xff;
unsigned latestOrderHint = 0;
int i;
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i) {
unsigned hint = hdr->shiftedOrderHints[i];
if (!hdr->usedFrame[i] &&
hint >= hdr->curFrameHint &&
(ref == 0xff || hint >= latestOrderHint)) {
ref = i;
latestOrderHint = hint;
}
}
return ref;
}
static uint8_t find_earliest_backward(vid_dec_PrivateType *priv)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
uint8_t ref = 0xff;
unsigned earliestOrderHint = 0;
int i;
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i) {
unsigned hint = hdr->shiftedOrderHints[i];
if (!hdr->usedFrame[i] &&
hint >= hdr->curFrameHint &&
(ref == 0xff || hint < earliestOrderHint)) {
ref = i;
earliestOrderHint = hint;
}
}
return ref;
}
static uint8_t find_latest_forward(vid_dec_PrivateType *priv)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
uint8_t ref = 0xff;
unsigned latestOrderHint = 0;
int i;
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i) {
unsigned hint = hdr->shiftedOrderHints[i];
if (!hdr->usedFrame[i] &&
hint < hdr->curFrameHint &&
(ref == 0xff || hint >= latestOrderHint)) {
ref = i;
latestOrderHint = hint;
}
}
return ref;
}
static void set_frame_refs(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
uint8_t Ref_Frame_List[5] = { AV1_LAST2_FRAME , AV1_LAST3_FRAME, AV1_BWDREF_FRAME,
AV1_ALTREF2_FRAME, AV1_ALTREF_FRAME };
unsigned earliestOrderHint = 0;
uint8_t ref;
int i;
for (i = 0; i < AV1_REFS_PER_FRAME; ++i)
hdr->ref_frame_idx[i] = 0xff;
hdr->ref_frame_idx[0] = hdr->last_frame_idx;
hdr->ref_frame_idx[AV1_GOLDEN_FRAME - AV1_LAST_FRAME] = hdr->gold_frame_idx;
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i)
hdr->usedFrame[i] = 0;
hdr->usedFrame[hdr->last_frame_idx] = 1;
hdr->usedFrame[hdr->gold_frame_idx] = 1;
hdr->curFrameHint = 1 << (seq->OrderHintBits - 1);
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i)
hdr->shiftedOrderHints[i] =
hdr->curFrameHint +
get_relative_dist(priv, hdr->RefOrderHint[i], hdr->OrderHint);
ref = find_latest_backward(priv);
if (ref != 0xff) {
hdr->ref_frame_idx[AV1_ALTREF_FRAME - AV1_LAST_FRAME] = ref;
hdr->usedFrame[ref] = 1;
}
ref = find_earliest_backward(priv);
if (ref != 0xff) {
hdr->ref_frame_idx[AV1_BWDREF_FRAME - AV1_LAST_FRAME] = ref;
hdr->usedFrame[ref] = 1;
}
ref = find_earliest_backward(priv);
if (ref != 0xff) {
hdr->ref_frame_idx[AV1_ALTREF2_FRAME - AV1_LAST_FRAME] = ref;
hdr->usedFrame[ref] = 1;
}
for (i = 0; i < AV1_REFS_PER_FRAME - 2; ++i) {
uint8_t refFrame = Ref_Frame_List[i];
if (hdr->ref_frame_idx[refFrame - AV1_LAST_FRAME] == 0xff) {
ref = find_latest_forward(priv);
if (ref != 0xff) {
hdr->ref_frame_idx[refFrame - AV1_LAST_FRAME] = ref;
hdr->usedFrame[ref] = 1;
}
}
}
ref = 0xff;
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i) {
unsigned hint = hdr->shiftedOrderHints[i];
if (ref == 0xff || hint < earliestOrderHint) {
ref = i;
earliestOrderHint = hint;
}
}
for (i = 0; i < AV1_REFS_PER_FRAME; ++i) {
if (hdr->ref_frame_idx[i] == 0xff)
hdr->ref_frame_idx[i] = ref;
}
}
static void frame_size_with_refs(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
bool found_ref;
int i;
for (i = 0; i < AV1_REFS_PER_FRAME; ++i) {
found_ref = av1_f(vlc, 1);
if (found_ref) {
hdr->UpscaledWidth =
priv->codec_data.av1.RefFrames[hdr->ref_frame_idx[i]].RefUpscaledWidth;
hdr->FrameWidth = hdr->UpscaledWidth;
hdr->FrameHeight =
priv->codec_data.av1.RefFrames[hdr->ref_frame_idx[i]].RefFrameHeight;
hdr->RenderWidth =
priv->codec_data.av1.RefFrames[hdr->ref_frame_idx[i]].RefRenderWidth;
hdr->RenderHeight =
priv->codec_data.av1.RefFrames[hdr->ref_frame_idx[i]].RefRenderHeight;
break;
}
}
if (!found_ref) {
frame_size(priv, vlc);
render_size(priv, vlc);
} else {
superres_params(priv, vlc);
compute_image_size(priv);
}
}
static unsigned tile_log2(unsigned blkSize, unsigned target)
{
unsigned k = 0;
for (k = 0; (blkSize << k) < target; k++);
return k;
}
static void tile_info(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct tile_info *ti = &(priv->codec_data.av1.uncompressed_header.ti);
unsigned sbCols;
unsigned sbRows;
int width_sb;
int height_sb;
unsigned sbSize;
unsigned maxTileWidthSb;
unsigned minLog2TileCols;
unsigned maxLog2TileCols;
unsigned maxLog2TileRows;
unsigned minLog2Tiles;
bool uniform_tile_spacing_flag;
unsigned maxTileAreaSb;
unsigned startSb, i;
sbCols = (seq->use_128x128_superblock) ?
((hdr->MiCols + 31) >> 5) : ((hdr->MiCols + 15) >> 4);
sbRows = (seq->use_128x128_superblock) ?
((hdr->MiRows + 31) >> 5) : ((hdr->MiRows + 15) >> 4);
width_sb = sbCols;
height_sb = sbRows;
sbSize = (seq->use_128x128_superblock ? 5 : 4) + 2;
maxTileWidthSb = AV1_MAX_TILE_WIDTH >> sbSize;
maxTileAreaSb = AV1_MAX_TILE_AREA >> (2 * sbSize);
minLog2TileCols = tile_log2(maxTileWidthSb, sbCols);
maxLog2TileCols = tile_log2(1, MIN2(sbCols, AV1_MAX_TILE_COLS));
maxLog2TileRows = tile_log2(1, MIN2(sbRows, AV1_MAX_TILE_ROWS));
minLog2Tiles = MAX2(minLog2TileCols, tile_log2(maxTileAreaSb, sbRows * sbCols));
uniform_tile_spacing_flag = av1_f(vlc, 1);
if (uniform_tile_spacing_flag) {
unsigned tileWidthSb, tileHeightSb;
unsigned minLog2TileRows;
ti->TileColsLog2 = minLog2TileCols;
while (ti->TileColsLog2 < maxLog2TileCols) {
bool increment_tile_cols_log2 = av1_f(vlc, 1);
if (increment_tile_cols_log2)
ti->TileColsLog2++;
else
break;
}
tileWidthSb = (sbCols + (1 << ti->TileColsLog2) - 1) >> ti->TileColsLog2;
i = 0;
for (startSb = 0; startSb < sbCols; startSb += tileWidthSb) {
ti->tile_col_start_sb[i] = startSb;
i++;
}
ti->tile_col_start_sb[i] = sbCols;
ti->TileCols = i;
minLog2TileRows = (minLog2Tiles > ti->TileColsLog2)?
(minLog2Tiles - ti->TileColsLog2) : 0;
ti->TileRowsLog2 = minLog2TileRows;
while (ti->TileRowsLog2 < maxLog2TileRows) {
bool increment_tile_rows_log2 = av1_f(vlc, 1);
if (increment_tile_rows_log2)
ti->TileRowsLog2++;
else
break;
}
tileHeightSb = (sbRows + (1 << ti->TileRowsLog2) - 1) >> ti->TileRowsLog2;
i = 0;
for (startSb = 0; startSb < sbRows; startSb += tileHeightSb) {
ti->tile_row_start_sb[i] = startSb;
i++;
}
ti->tile_row_start_sb[i] = sbRows;
ti->TileRows = i;
} else {
unsigned widestTileSb = 0;
unsigned maxTileHeightSb;
startSb = 0;
for (i = 0; startSb < sbCols; ++i) {
uint8_t maxWidth;
unsigned sizeSb;
unsigned width_in_sbs_minus_1;
ti->tile_col_start_sb[i] = startSb;
maxWidth = MIN2(sbCols - startSb, maxTileWidthSb);
width_in_sbs_minus_1 = av1_ns(vlc, maxWidth);
sizeSb = width_in_sbs_minus_1 + 1;
widestTileSb = MAX2(sizeSb, widestTileSb);
startSb += sizeSb;
width_sb -= sizeSb;
}
ti->TileCols = i;
ti->tile_col_start_sb[i] = startSb + width_sb;
ti->TileColsLog2 = tile_log2(1, ti->TileCols);
if (minLog2Tiles > 0)
maxTileAreaSb = (sbRows * sbCols) >> (minLog2Tiles + 1);
else
maxTileAreaSb = (sbRows * sbCols);
maxTileHeightSb = MAX2(maxTileAreaSb / widestTileSb, 1);
startSb = 0;
for (i = 0; startSb < sbRows; ++i) {
uint8_t maxHeight;
unsigned height_in_sbs_minus_1;
maxHeight = MIN2(sbRows - startSb, maxTileHeightSb);
height_in_sbs_minus_1 = av1_ns(vlc, maxHeight);
ti->tile_row_start_sb[i] = startSb;
startSb += height_in_sbs_minus_1 + 1;
height_sb -= height_in_sbs_minus_1 + 1;
}
ti->TileRows = i;
ti->tile_row_start_sb[i] = startSb + height_sb;
ti->TileRowsLog2 = tile_log2(1, ti->TileRows);
}
if (ti->TileColsLog2 > 0 || ti->TileRowsLog2 > 0) {
ti->context_update_tile_id =
av1_f(vlc, ti->TileRowsLog2 + ti->TileColsLog2);
uint8_t tile_size_bytes_minus_1 = av1_f(vlc, 2);
ti->TileSizeBytes = tile_size_bytes_minus_1 + 1;
} else {
ti->context_update_tile_id = 0;
}
}
static int read_delta_q(struct vl_vlc *vlc)
{
bool delta_coded = av1_f(vlc, 1);
int delta_q = 0;
if (delta_coded)
delta_q = av1_su(vlc, 7);
return delta_q;
}
static void quantization_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct quantization_params* qp = &(priv->codec_data.av1.uncompressed_header.qp);
bool using_qmatrix;
qp->base_q_idx = av1_f(vlc, 8);
qp->DeltaQYDc = read_delta_q(vlc);
if (seq->color_config.NumPlanes > 1) {
bool diff_uv_delta =
(seq->color_config.separate_uv_delta_q) ? av1_f(vlc, 1) : 0;
qp->DeltaQUDc = read_delta_q(vlc);
qp->DeltaQUAc = read_delta_q(vlc);
if (diff_uv_delta) {
qp->DeltaQVDc = read_delta_q(vlc);
qp->DeltaQVAc = read_delta_q(vlc);
} else {
qp->DeltaQVDc = qp->DeltaQUDc;
qp->DeltaQVAc = qp->DeltaQUAc;
}
} else {
qp->DeltaQVDc = 0;
qp->DeltaQVAc = 0;
qp->DeltaQUDc = 0;
qp->DeltaQUAc = 0;
}
using_qmatrix = av1_f(vlc, 1);
if (using_qmatrix) {
qp->qm_y = av1_f(vlc, 4);
qp->qm_u = av1_f(vlc, 4);
if (!seq->color_config.separate_uv_delta_q)
qp->qm_v = qp->qm_u;
else
qp->qm_v = av1_f(vlc, 4);
} else {
qp->qm_y = 0xf;
qp->qm_u = 0xf;
qp->qm_v = 0xf;
}
}
static void segmentation_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct segmentation_params* sp = &(priv->codec_data.av1.uncompressed_header.sp);
int i, j;
sp->segmentation_enabled = av1_f(vlc, 1);
if (sp->segmentation_enabled) {
bool segmentation_update_data;
if (hdr->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
sp->segmentation_update_map = 1;
sp->segmentation_temporal_update = 0;
segmentation_update_data = 1;
} else {
sp->segmentation_update_map = av1_f(vlc, 1);
if (sp->segmentation_update_map)
sp->segmentation_temporal_update = av1_f(vlc, 1);
else
sp->segmentation_temporal_update = 0;
segmentation_update_data = av1_f(vlc, 1);
}
if (segmentation_update_data) {
uint8_t Segmentation_Feature_Bits[AV1_SEG_LVL_MAX] = { 8, 6, 6, 6, 6, 3, 0, 0 };
bool Segmentation_Feature_Signed[AV1_SEG_LVL_MAX] = { 1, 1, 1, 1, 1, 0, 0, 0 };
unsigned Segmentation_Feature_Max[AV1_SEG_LVL_MAX] = { 255, 63, 63, 63, 63, 7, 0, 0 };
memset(sp->FeatureData, 0, sizeof(sp->FeatureData));
memset(sp->FeatureMask, 0, sizeof(sp->FeatureMask));
for (i = 0; i < AV1_MAX_SEGMENTS; ++i) {
for (j = 0; j < AV1_SEG_LVL_MAX; ++j) {
int feature_value = 0;
bool feature_enabled = av1_f(vlc, 1);
sp->FeatureEnabled[i][j] = feature_enabled;
int clippedValue = 0;
if (feature_enabled) {
uint8_t bitsToRead = Segmentation_Feature_Bits[j];
int limit = Segmentation_Feature_Max[j];
if (Segmentation_Feature_Signed[j]) {
feature_value = av1_su(vlc, 1 + bitsToRead);
clippedValue = CLAMP(feature_value, -limit, limit);
sp->FeatureMask[i] |= 1 << j;
} else {
feature_value = av1_f(vlc, bitsToRead);
clippedValue = CLAMP(feature_value, 0, limit);
sp->FeatureMask[i] |= 1 << j;
}
}
sp->FeatureData[i][j] = clippedValue;
}
}
} else {
int r = hdr->ref_frame_idx[hdr->primary_ref_frame];
memcpy(sp, &(priv->codec_data.av1.refs[r].sp), sizeof(*sp));
}
} else {
memset(sp, 0, sizeof(*sp));
}
}
static void delta_q_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct quantization_params* qp = &(priv->codec_data.av1.uncompressed_header.qp);
struct delta_q_params * dqp = &(priv->codec_data.av1.uncompressed_header.dqp);
dqp->delta_q_present = 0;
dqp->delta_q_res = 0;
if (qp->base_q_idx > 0)
dqp->delta_q_present = av1_f(vlc, 1);
if (dqp->delta_q_present)
dqp->delta_q_res = av1_f(vlc, 2);
}
static void delta_lf_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct delta_q_params * dqp = &(priv->codec_data.av1.uncompressed_header.dqp);
struct delta_lf_params* dlfp = &(priv->codec_data.av1.uncompressed_header.dlfp);
dlfp->delta_lf_present = 0;
dlfp->delta_lf_res = 0;
dlfp->delta_lf_multi = 0;
if (dqp->delta_q_present) {
if (!hdr->allow_intrabc)
dlfp->delta_lf_present = av1_f(vlc, 1);
if (dlfp->delta_lf_present) {
dlfp->delta_lf_res = av1_f(vlc, 2);
dlfp->delta_lf_multi = av1_f(vlc, 1);
}
}
}
static unsigned get_qindex(vid_dec_PrivateType * priv, bool ignoreDeltaQ, unsigned segmentId)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct segmentation_params* sp = &(priv->codec_data.av1.uncompressed_header.sp);
struct quantization_params* qp = &(priv->codec_data.av1.uncompressed_header.qp);
unsigned qindex = 0;
if (sp->segmentation_enabled && sp->FeatureEnabled[segmentId][AV1_SEG_LVL_ALT_Q]) {
unsigned data = sp->FeatureData[segmentId][AV1_SEG_LVL_ALT_Q];
qindex = qp->base_q_idx + data;
if (!ignoreDeltaQ && hdr->dqp.delta_q_present)
qindex = data;
return CLAMP(qindex, 0, 255);
}
if (!ignoreDeltaQ && hdr->dqp.delta_q_present)
return 0;
return qp->base_q_idx;
}
static void loop_filter_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct loop_filter_params *lfp = &(priv->codec_data.av1.uncompressed_header.lfp);
int i;
if (hdr->CodedLossless || hdr->allow_intrabc) {
lfp->loop_filter_level[0] = 0;
lfp->loop_filter_level[1] = 0;
lfp->loop_filter_ref_deltas[AV1_INTRA_FRAME] = 1;
lfp->loop_filter_ref_deltas[AV1_LAST_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_LAST2_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_LAST3_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_BWDREF_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_GOLDEN_FRAME] = -1;
lfp->loop_filter_ref_deltas[AV1_ALTREF2_FRAME] = -1;
lfp->loop_filter_ref_deltas[AV1_ALTREF_FRAME] = -1;
lfp->loop_filter_mode_deltas[0] = 0;
lfp->loop_filter_mode_deltas[1] = 0;
return;
}
if (hdr->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
lfp->loop_filter_ref_deltas[AV1_INTRA_FRAME] = 1;
lfp->loop_filter_ref_deltas[AV1_LAST_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_LAST2_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_LAST3_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_BWDREF_FRAME] = 0;
lfp->loop_filter_ref_deltas[AV1_GOLDEN_FRAME] = -1;
lfp->loop_filter_ref_deltas[AV1_ALTREF2_FRAME] = -1;
lfp->loop_filter_ref_deltas[AV1_ALTREF_FRAME] = -1;
lfp->loop_filter_mode_deltas[0] = 0;
lfp->loop_filter_mode_deltas[1] = 0;
} else {
int r = hdr->ref_frame_idx[hdr->primary_ref_frame];
memcpy(lfp->loop_filter_ref_deltas,
priv->codec_data.av1.refs[r].lfp.loop_filter_ref_deltas, 8);
memcpy(lfp->loop_filter_mode_deltas,
priv->codec_data.av1.refs[r].lfp.loop_filter_mode_deltas, 2);
}
lfp->loop_filter_level[0] = av1_f(vlc, 6);
lfp->loop_filter_level[1] = av1_f(vlc, 6);
if (seq->color_config.NumPlanes > 1) {
if (lfp->loop_filter_level[0] || lfp->loop_filter_level[1]) {
lfp->loop_filter_level[2] = av1_f(vlc, 6);
lfp->loop_filter_level[3] = av1_f(vlc, 6);
}
}
lfp->loop_filter_sharpness = av1_f(vlc, 3);
lfp->loop_filter_delta_enabled = av1_f(vlc, 1);
if (lfp->loop_filter_delta_enabled) {
lfp->loop_filter_delta_update = av1_f(vlc, 1);
if (lfp->loop_filter_delta_update) {
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i) {
int8_t update_ref_delta = av1_f(vlc, 1);
if (update_ref_delta)
lfp->loop_filter_ref_deltas[i] = av1_su(vlc, 7);
}
for (i = 0; i < 2; ++i) {
int8_t update_mode_delta = av1_f(vlc, 1);
if (update_mode_delta)
lfp->loop_filter_mode_deltas[i] = av1_su(vlc, 7);
}
}
}
}
static void cdef_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct cdef_params *cdefp = &(priv->codec_data.av1.uncompressed_header.cdefp);;
int i;
if (hdr->CodedLossless || hdr->allow_intrabc || !seq->enable_cdef) {
cdefp->cdef_bits = 0;
cdefp->cdef_y_strengths[0] = 0;
cdefp->cdef_uv_strengths[0] = 0;
return;
}
cdefp->cdef_damping_minus_3 = av1_f(vlc, 2);
cdefp->cdef_bits = av1_f(vlc, 2);
for (i = 0; i < (1 << cdefp->cdef_bits); ++i) {
cdefp->cdef_y_strengths[i] = av1_f(vlc, 6);
if (seq->color_config.NumPlanes > 1)
cdefp->cdef_uv_strengths[i] = av1_f(vlc, 6);
}
}
static void lr_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct loop_restoration_params *lrp = &(priv->codec_data.av1.uncompressed_header.lrp);
uint8_t Remap_Lr_Type[4] =
{ AV1_RESTORE_NONE, AV1_RESTORE_SWITCHABLE, AV1_RESTORE_WIENER, AV1_RESTORE_SGRPROJ };
bool UsesLr = false;
bool UsesChromaLr = false;
uint8_t lr_unit_shift, lr_uv_shift;
int i;
if (hdr->AllLossless || hdr->allow_intrabc || !seq->enable_restoration) {
lrp->FrameRestorationType[0] = AV1_RESTORE_NONE;
lrp->FrameRestorationType[1] = AV1_RESTORE_NONE;
lrp->FrameRestorationType[2] = AV1_RESTORE_NONE;
return;
}
for (i = 0; i < seq->color_config.NumPlanes; ++i) {
uint8_t lr_type = av1_f(vlc, 2);
lrp->FrameRestorationType[i] = Remap_Lr_Type[lr_type];
if (lrp->FrameRestorationType[i] != AV1_RESTORE_NONE) {
UsesLr = true;
if (i > 0)
UsesChromaLr = true;
}
}
if (UsesLr) {
if (seq->use_128x128_superblock) {
lr_unit_shift = av1_f(vlc, 1) + 1;
} else {
lr_unit_shift = av1_f(vlc, 1);
if (lr_unit_shift) {
uint8_t lr_unit_extra_shift = av1_f(vlc, 1);
lr_unit_shift += lr_unit_extra_shift;
}
}
lrp->LoopRestorationSize[0] = AV1_RESTORATION_TILESIZE >> (2 - lr_unit_shift);
lr_uv_shift =
(seq->color_config.subsampling_x && seq->color_config.subsampling_y && UsesChromaLr) ?
av1_f(vlc, 1) : 0;
lrp->LoopRestorationSize[1] = lrp->LoopRestorationSize[0] >> lr_uv_shift;
lrp->LoopRestorationSize[2] = lrp->LoopRestorationSize[0] >> lr_uv_shift;
} else {
lrp->LoopRestorationSize[0] = lrp->LoopRestorationSize[1] =
lrp->LoopRestorationSize[2] = (1 << 8);
}
}
static void tx_mode(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct tx_mode_params *tm = &(priv->codec_data.av1.uncompressed_header.tm);
if (hdr->CodedLossless) {
tm->TxMode = AV1_ONLY_4X4;
} else {
bool tx_mode_select = av1_f(vlc, 1);
tm->TxMode = (tx_mode_select) ? AV1_TX_MODE_SELECT : AV1_TX_MODE_LARGEST;
}
}
static void frame_reference_mode(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
if (hdr->FrameIsIntra)
hdr->reference_select = SINGLE_REFERENCE;
else
hdr->reference_select = av1_f(vlc, 1) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
}
static void skip_mode_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct skip_mode_params *smp = &(priv->codec_data.av1.uncompressed_header.smp);;
bool skipModeAllowed;
int i;
if (hdr->FrameIsIntra || hdr->reference_select == SINGLE_REFERENCE ||
!seq->enable_order_hint) {
skipModeAllowed = 0;
} else {
int ref_frame_offset[2] = { -1, INT_MAX };
int ref_idx[2] = { -1, -1 };
skipModeAllowed = 0;
for (i = 0; i < AV1_REFS_PER_FRAME; ++i) {
unsigned ref_offset = priv->codec_data.av1.refs[hdr->ref_frame_idx[i]].OrderHint;
if (get_relative_dist(priv, ref_offset, hdr->OrderHint) < 0) {
if (ref_frame_offset[0] == -1 ||
get_relative_dist(priv, ref_offset, ref_frame_offset[0]) > 0) {
ref_frame_offset[0] = ref_offset;
ref_idx[0] = i;
}
} else if (get_relative_dist(priv, ref_offset, hdr->OrderHint) > 0) {
if (ref_frame_offset[1] == INT_MAX ||
get_relative_dist(priv, ref_offset, ref_frame_offset[1]) < 0) {
ref_frame_offset[1] = ref_offset;
ref_idx[1] = i;
}
}
}
if (ref_idx[0] != -1 && ref_idx[1] != -1) {
skipModeAllowed = 1;
} else if (ref_idx[0] != -1 && ref_idx[1] == -1) {
ref_frame_offset[1] = -1;
for (i = 0; i < AV1_ALTREF_FRAME - AV1_LAST_FRAME + 1; ++i) {
unsigned ref_offset = priv->codec_data.av1.refs[hdr->ref_frame_idx[i]].OrderHint;
if ((ref_frame_offset[0] != -1 &&
get_relative_dist(priv, ref_offset, ref_frame_offset[0]) < 0) &&
(ref_frame_offset[1] == -1 ||
get_relative_dist(priv, ref_offset, ref_frame_offset[1]) > 0)) {
ref_frame_offset[1] = ref_offset;
ref_idx[1] = i;
}
}
if (ref_frame_offset[1] != -1)
skipModeAllowed = 1;
}
}
smp->skip_mode_present = skipModeAllowed ? av1_f(vlc, 1) : 0;
}
static unsigned inverse_recenter(unsigned r, unsigned v)
{
if (v > (2 * r))
return v;
else if (v & 1)
return (r - ((v + 1) >> 1));
else
return (r + (v >> 1));
}
static unsigned decode_subexp(struct vl_vlc *vlc, unsigned numSyms)
{
unsigned i = 0;
unsigned mk = 0;
unsigned k = 3;
while (1) {
unsigned b2 = (i) ? (k + i - 1) : k;
unsigned a = 1 << b2;
if (numSyms <= (mk + 3 * a)) {
unsigned subexp_final_bits = av1_ns(vlc, (numSyms - mk));
return (subexp_final_bits + mk);
} else {
bool subexp_more_bits = av1_f(vlc, 1);
if (subexp_more_bits) {
i++;
mk += a;
} else {
unsigned subexp_bits = av1_f(vlc, b2);
return (subexp_bits + mk);
}
}
}
}
static unsigned decode_unsigned_subexp_with_ref(struct vl_vlc *vlc,
unsigned mx, unsigned r)
{
unsigned smart;
unsigned v = decode_subexp(vlc, mx);
if ((r << 1) <= mx) {
smart = inverse_recenter(r, v);
return smart;
} else {
smart = inverse_recenter(mx - 1 - r, v);
return (mx - 1 - smart);
}
}
static int decode_signed_subexp_with_ref(struct vl_vlc *vlc, int low, int high, int r)
{
int x = decode_unsigned_subexp_with_ref(vlc, high - low, r - low);
return (x + low);
}
static void read_global_param(struct global_motion_params* global_params,
struct global_motion_params* ref_params,
vid_dec_PrivateType *priv, struct vl_vlc *vlc,
uint8_t type, uint8_t ref, uint8_t idx)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
uint8_t absBits = 12; /* GM_ABS_ALPHA_BITS */
uint8_t precBits = 15; /* GM_ALPHA_PREC_BITS */
int precDiff, round, sub, mx, r = 0;
if (idx < 2) {
if (type == AV1_TRANSLATION) {
absBits = 9 /* GM_ABS_TRANS_ONLY_BITS */ - !hdr->allow_high_precision_mv;
precBits = 3 /* GM_TRANS_ONLY_PREC_BITS */ - !hdr->allow_high_precision_mv;
} else {
absBits = 12; /* GM_ABS_TRANS_BITS */
precBits = 6; /* GM_TRANS_PREC_BITS */;
}
}
precDiff = AV1_WARPEDMODEL_PREC_BITS - precBits;
round = ((idx % 3) == 2) ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0;
sub = ((idx % 3) == 2) ? (1 << precBits) : 0;
mx = (int)(1 << absBits);
if (ref_params)
r = (ref_params->gm_params[ref][idx] >> precDiff) - sub;
global_params->gm_params[ref][idx] =
(decode_signed_subexp_with_ref(vlc, -mx, mx + 1, r) << precDiff) + round;
}
static void global_motion_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct global_motion_params *gmp = &(priv->codec_data.av1.uncompressed_header.gmp);
struct global_motion_params *ref_gmp = NULL;
unsigned ref, i;
if (hdr->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
for (ref = 0; ref < AV1_NUM_REF_FRAMES; ++ref) {
gmp->GmType[ref] = AV1_IDENTITY;
for (i = 0; i < 6; ++i)
gmp->gm_params[ref][i] = (((i % 3) == 2) ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0);
}
} else {
const int r = hdr->ref_frame_idx[hdr->primary_ref_frame];
ref_gmp = &(priv->codec_data.av1.refs[r].gmp);
}
for (ref = AV1_LAST_FRAME; ref <= AV1_ALTREF_FRAME; ++ref) {
gmp->GmType[ref] = AV1_IDENTITY;
for (i = 0; i < 6; ++i)
gmp->gm_params[ref][i] = (((i % 3) == 2) ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0);
}
if (hdr->FrameIsIntra)
return;
for (ref = AV1_LAST_FRAME; ref <= AV1_ALTREF_FRAME; ++ref) {
uint8_t type = AV1_IDENTITY;
bool is_global;
gmp->GmType[ref] = AV1_IDENTITY;
for (i = 0; i < 6; ++i)
gmp->gm_params[ref][i] = (((i % 3) == 2) ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0);
is_global = av1_f(vlc, 1);
if (is_global) {
bool is_rot_zoom = av1_f(vlc, 1);
if (is_rot_zoom) {
type = AV1_ROTZOOM;
} else {
bool is_translation = av1_f(vlc, 1);
type = is_translation ? AV1_TRANSLATION : AV1_AFFINE;
}
}
gmp->GmType[ref] = type;
if (type >= AV1_ROTZOOM) {
read_global_param(gmp, ref_gmp, priv, vlc, type, ref, 2);
read_global_param(gmp, ref_gmp, priv, vlc, type, ref, 3);
if (type == AV1_AFFINE) {
read_global_param(gmp, ref_gmp, priv, vlc, type, ref, 4);
read_global_param(gmp, ref_gmp, priv, vlc, type, ref, 5);
} else {
gmp->gm_params[ref][4] = -gmp->gm_params[ref][3];
gmp->gm_params[ref][5] = gmp->gm_params[ref][2];
}
}
if (type >= AV1_TRANSLATION) {
read_global_param(gmp, ref_gmp, priv, vlc, type, ref, 0);
read_global_param(gmp, ref_gmp, priv, vlc, type, ref, 1);
}
}
}
static void film_grain_params(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
struct film_grain_params *fgp = &(priv->codec_data.av1.uncompressed_header.fgp);
bool update_grain;
uint8_t numPosLuma;
uint8_t numPosChroma;
unsigned i;
if (!seq->film_grain_params_present ||
(!hdr->show_frame && !hdr->showable_frame)) {
memset(fgp, 0, sizeof(*fgp));
return;
}
fgp->apply_grain = av1_f(vlc, 1);
if (!fgp->apply_grain) {
memset(fgp, 0, sizeof(*fgp));
return;
}
fgp->grain_seed = av1_f(vlc, 16);
update_grain =
(hdr->frame_type == AV1_INTER_FRAME) ? av1_f(vlc, 1) : 1;
if (!update_grain) {
uint8_t film_grain_params_ref_idx = av1_f(vlc, 3);
uint16_t tempGrainSeed = fgp->grain_seed;
memcpy(fgp, &(priv->codec_data.av1.refs[film_grain_params_ref_idx].fgp),
sizeof(*fgp));
fgp->grain_seed = tempGrainSeed;
return;
}
fgp->num_y_points = av1_f(vlc, 4);
for (i = 0; i < fgp->num_y_points; ++i) {
fgp->point_y_value[i] = av1_f(vlc, 8);
fgp->point_y_scaling[i] = av1_f(vlc, 8);
}
fgp->chroma_scaling_from_luma =
(seq->color_config.mono_chrome) ? 0 : av1_f(vlc, 1);
if (seq->color_config.mono_chrome || fgp->chroma_scaling_from_luma ||
(seq->color_config.subsampling_x && seq->color_config.subsampling_y &&
(fgp->num_y_points == 0))) {
fgp->num_cb_points = 0;
fgp->num_cr_points = 0;
} else {
fgp->num_cb_points = av1_f(vlc, 4);
for (i = 0; i < fgp->num_cb_points; ++i) {
fgp->point_cb_value[i] = av1_f(vlc, 8);
fgp->point_cb_scaling[i] = av1_f(vlc, 8);
}
fgp->num_cr_points = av1_f(vlc, 4);
for (i = 0; i < fgp->num_cr_points; ++i) {
fgp->point_cr_value[i] = av1_f(vlc, 8);
fgp->point_cr_scaling[i] = av1_f(vlc, 8);
}
}
fgp->grain_scaling_minus_8 = av1_f(vlc, 2);
fgp->ar_coeff_lag = av1_f(vlc, 2);
numPosLuma = 2 * fgp->ar_coeff_lag * (fgp->ar_coeff_lag + 1);
if (fgp->num_y_points) {
numPosChroma = numPosLuma + 1;
for (i = 0; i < numPosLuma; ++i) {
uint8_t ar_coeffs_y_plus_128 = av1_f(vlc, 8);
fgp->ar_coeffs_y[i] = ar_coeffs_y_plus_128 - 128;
}
} else {
numPosChroma = numPosLuma;
}
if (fgp->chroma_scaling_from_luma || fgp->num_cb_points) {
for (i = 0; i < numPosChroma; ++i) {
uint8_t ar_coeffs_cb_plus_128 = av1_f(vlc, 8);
fgp->ar_coeffs_cb[i] = ar_coeffs_cb_plus_128 - 128;
}
}
if (fgp->chroma_scaling_from_luma || fgp->num_cr_points) {
for (i = 0; i < numPosChroma; ++i) {
uint8_t ar_coeffs_cr_plus_128 = av1_f(vlc, 8);
fgp->ar_coeffs_cr[i] = ar_coeffs_cr_plus_128 - 128;
}
}
fgp->ar_coeff_shift_minus_6 = av1_f(vlc, 2);
fgp->grain_scale_shift = av1_f(vlc, 2);
if (fgp->num_cb_points) {
fgp->cb_mult = av1_f(vlc, 8);
fgp->cb_luma_mult = av1_f(vlc, 8);
fgp->cb_offset = av1_f(vlc, 9);
}
if (fgp->num_cr_points) {
fgp->cr_mult = av1_f(vlc, 8);
fgp->cr_luma_mult = av1_f(vlc, 8);
fgp->cr_offset = av1_f(vlc, 9);
}
fgp->overlap_flag = av1_f(vlc, 1);
fgp->clip_to_restricted_range = av1_f(vlc, 1);
}
static void frame_header_obu(vid_dec_PrivateType *priv, struct vl_vlc *vlc)
{
struct av1_sequence_header_obu *seq = &(priv->codec_data.av1.seq);
struct av1_uncompressed_header_obu *hdr = &(priv->codec_data.av1.uncompressed_header);
unsigned idLen = 0;
unsigned allFrames;
int i, j;
memset(hdr, 0, sizeof(*hdr));
if (seq->frame_id_numbers_present_flag)
idLen = seq->additional_frame_id_length_minus_1 +
seq->delta_frame_id_length_minus_2 + 3;
allFrames = (1 << AV1_NUM_REF_FRAMES) - 1;
if (seq->reduced_still_picture_header) {
hdr->show_existing_frame = 0;
hdr->frame_type = AV1_KEY_FRAME;
hdr->FrameIsIntra = 1;
hdr->show_frame = 1;
hdr->showable_frame = 0;
} else {
hdr->show_existing_frame = av1_f(vlc, 1);
if (hdr->show_existing_frame) {
hdr->frame_to_show_map_idx = av1_f(vlc, 3);
if (seq->decoder_model_info_present_flag &&
!seq->timing_info.equal_picture_interval)
av1_f(vlc, seq->decoder_model_info.
frame_presentation_time_length_minus_1 + 1);
hdr->refresh_frame_flags = 0;
if (seq->frame_id_numbers_present_flag)
av1_f(vlc, idLen); /* display_frame_id */
hdr->frame_type =
priv->codec_data.av1.RefFrames[priv->codec_data.av1.uncompressed_header.
frame_to_show_map_idx].RefFrameType;
return;
}
hdr->frame_type = av1_f(vlc, 2);
hdr->FrameIsIntra = (hdr->frame_type == AV1_INTRA_ONLY_FRAME ||
hdr->frame_type == AV1_KEY_FRAME);
hdr->show_frame = av1_f(vlc, 1);
if (hdr->show_frame && seq->decoder_model_info_present_flag &&
!seq->timing_info.equal_picture_interval)
av1_f(vlc, seq->decoder_model_info.frame_presentation_time_length_minus_1 + 1);
hdr->showable_frame =
hdr->show_frame ? (hdr->frame_type != AV1_KEY_FRAME) : av1_f(vlc, 1);
hdr->error_resilient_mode = (hdr->frame_type == AV1_SWITCH_FRAME ||
(hdr->frame_type == AV1_KEY_FRAME && hdr->show_frame)) ? 1 : av1_f(vlc, 1);
}
if (hdr->frame_type == AV1_KEY_FRAME && hdr->show_frame) {
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i)
hdr->RefOrderHint[i] = 0;
}
hdr->disable_cdf_update = av1_f(vlc, 1);
hdr->allow_screen_content_tools =
(seq->seq_force_screen_content_tools == AV1_SELECT_SCREEN_CONTENT_TOOLS) ?
av1_f(vlc, 1) : seq->seq_force_screen_content_tools;
if (hdr->allow_screen_content_tools) {
if (seq->seq_force_integer_mv == AV1_SELECT_INTEGER_MV)
hdr->force_integer_mv = av1_f(vlc, 1);
else
hdr->force_integer_mv = seq->seq_force_integer_mv;
} else {
hdr->force_integer_mv = 0;
}
if (hdr->FrameIsIntra)
hdr->force_integer_mv = 1;
hdr->current_frame_id =
seq->frame_id_numbers_present_flag ? av1_f(vlc, idLen) : 0;
if (hdr->frame_type == AV1_SWITCH_FRAME)
hdr->frame_size_override_flag = 1;
else if (seq->reduced_still_picture_header)
hdr->frame_size_override_flag = 0;
else
hdr->frame_size_override_flag = av1_f(vlc, 1);
hdr->OrderHint = av1_f(vlc, seq->OrderHintBits);
if (hdr->FrameIsIntra || hdr->error_resilient_mode)
hdr->primary_ref_frame = AV1_PRIMARY_REF_NONE;
else
hdr->primary_ref_frame = av1_f(vlc, 3);
if (seq->decoder_model_info_present_flag) {
bool buffer_removal_time_present_flag = av1_f(vlc, 1);
if (buffer_removal_time_present_flag) {
for (i = 0; i <= seq->operating_points_cnt_minus_1; ++i) {
if (seq->decoder_model_present_for_this_op[i]) {
unsigned opPtIdc;
bool inTemporalLayer;
bool inSpatialLayer;
opPtIdc = seq->operating_point_idc[i];
inTemporalLayer =
(opPtIdc >> priv->codec_data.av1.ext.temporal_id) & 1;
inSpatialLayer =
(opPtIdc >> (priv->codec_data.av1.ext.spatial_id + 8)) & 1;
if ((opPtIdc == 0) || (inTemporalLayer && inSpatialLayer))
av1_f(vlc, seq->decoder_model_info.
buffer_removal_time_length_minus_1 + 1);
}
}
}
}
hdr->allow_high_precision_mv = 0;
hdr->use_ref_frame_mvs = 0;
hdr->allow_intrabc = 0;
hdr->refresh_frame_flags = allFrames = (hdr->frame_type == AV1_SWITCH_FRAME ||
(hdr->frame_type == AV1_KEY_FRAME && hdr->show_frame)) ?
allFrames : av1_f(vlc, AV1_NUM_REF_FRAMES);
if (!hdr->FrameIsIntra || hdr->refresh_frame_flags != allFrames) {
if (hdr->error_resilient_mode && seq->enable_order_hint) {
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i)
av1_f(vlc, seq->OrderHintBits);
}
}
if (hdr->FrameIsIntra) {
frame_size(priv, vlc);
render_size(priv, vlc);
if (hdr->allow_screen_content_tools && (hdr->UpscaledWidth == hdr->FrameWidth))
hdr->allow_intrabc = av1_f(vlc, 1);
} else {
bool is_filter_switchable;
bool frame_refs_short_signaling;
if (!seq->enable_order_hint) {
frame_refs_short_signaling = 0;
} else {
frame_refs_short_signaling = av1_f(vlc, 1);
if (frame_refs_short_signaling) {
hdr->last_frame_idx = av1_f(vlc, 3);
hdr->gold_frame_idx = av1_f(vlc, 3);
set_frame_refs(priv, vlc);
}
}
for (i = 0; i < AV1_REFS_PER_FRAME; ++i) {
if (!frame_refs_short_signaling)
hdr->ref_frame_idx[i] = av1_f(vlc, 3);
if (seq->frame_id_numbers_present_flag)
av1_f(vlc, seq->delta_frame_id_length_minus_2 + 2);
}
if (hdr->frame_size_override_flag && !hdr->error_resilient_mode) {
frame_size_with_refs(priv, vlc);
} else {
frame_size(priv, vlc);
render_size(priv, vlc);
}
hdr->allow_high_precision_mv = hdr->force_integer_mv ? 0 : av1_f(vlc, 1);
is_filter_switchable = av1_f(vlc, 1);
hdr->interpolation_filter = is_filter_switchable ? 4 /* SWITCHABLE */ : av1_f(vlc, 2);
hdr->is_motion_mode_switchable = av1_f(vlc, 1);
hdr->use_ref_frame_mvs =
(hdr->error_resilient_mode || !seq->enable_ref_frame_mvs) ? 0 : av1_f(vlc, 1);
}
hdr->disable_frame_end_update_cdf =
(seq->reduced_still_picture_header || hdr->disable_cdf_update) ? 1 : av1_f(vlc, 1);
tile_info(priv, vlc);
quantization_params(priv, vlc);
segmentation_params(priv, vlc);
delta_q_params(priv, vlc);
delta_lf_params(priv, vlc);
hdr->CodedLossless = 1;
for (i = 0; i < AV1_MAX_SEGMENTS; ++i) {
unsigned qindex = get_qindex(priv, 1, i);
bool LosslessArray =
(qindex == 0) && (hdr->qp.DeltaQYDc == 0) &&
(hdr->qp.DeltaQUAc == 0) && (hdr->qp.DeltaQUDc == 0) &&
(hdr->qp.DeltaQVAc == 0) && (hdr->qp.DeltaQVDc == 0);
if (!LosslessArray)
hdr->CodedLossless = 0;
}
hdr->AllLossless = hdr->CodedLossless && (hdr->FrameWidth == hdr->UpscaledWidth);
loop_filter_params(priv, vlc);
cdef_params(priv, vlc);
lr_params(priv, vlc);
tx_mode(priv, vlc);
frame_reference_mode(priv, vlc);
skip_mode_params(priv, vlc);
if (hdr->FrameIsIntra || hdr->error_resilient_mode || !seq->enable_warped_motion)
hdr->allow_warped_motion = 0;
else
hdr->allow_warped_motion = av1_f(vlc, 1);
hdr->reduced_tx_set = av1_f(vlc, 1);
global_motion_params(priv, vlc);
film_grain_params(priv, vlc);
priv->picture.av1.picture_parameter.pic_info_fields.frame_type = hdr->frame_type;
priv->picture.av1.picture_parameter.pic_info_fields.show_frame = hdr->show_frame;
priv->picture.av1.picture_parameter.pic_info_fields.error_resilient_mode =
hdr->error_resilient_mode;
priv->picture.av1.picture_parameter.pic_info_fields.disable_cdf_update =
hdr->disable_cdf_update;
priv->picture.av1.picture_parameter.pic_info_fields.allow_screen_content_tools =
hdr->allow_screen_content_tools;
priv->picture.av1.picture_parameter.pic_info_fields.force_integer_mv =
hdr->force_integer_mv;
priv->picture.av1.picture_parameter.current_frame_id = hdr->current_frame_id;
priv->picture.av1.picture_parameter.order_hint = hdr->OrderHint;
priv->picture.av1.picture_parameter.primary_ref_frame = hdr->primary_ref_frame;
priv->picture.av1.picture_parameter.frame_width = hdr->FrameWidth;
priv->picture.av1.picture_parameter.frame_height = hdr->FrameHeight;
priv->picture.av1.picture_parameter.pic_info_fields.use_superres =
hdr->use_superres;
priv->picture.av1.picture_parameter.superres_scale_denominator =
hdr->SuperresDenom;
for (i = 0; i < AV1_REFS_PER_FRAME; ++i)
priv->picture.av1.picture_parameter.ref_frame_idx[i] = hdr->ref_frame_idx[i];
priv->picture.av1.picture_parameter.pic_info_fields.allow_high_precision_mv =
hdr->allow_high_precision_mv;
priv->picture.av1.picture_parameter.pic_info_fields.allow_intrabc = hdr->allow_intrabc;
priv->picture.av1.picture_parameter.pic_info_fields.use_ref_frame_mvs =
hdr->use_ref_frame_mvs;
priv->picture.av1.picture_parameter.interp_filter = hdr->interpolation_filter;
priv->picture.av1.picture_parameter.pic_info_fields.is_motion_mode_switchable =
hdr->is_motion_mode_switchable;
priv->picture.av1.picture_parameter.refresh_frame_flags =
hdr->refresh_frame_flags;
priv->picture.av1.picture_parameter.pic_info_fields.disable_frame_end_update_cdf =
hdr->disable_frame_end_update_cdf;
/* Tile Info */
priv->picture.av1.picture_parameter.tile_rows = hdr->ti.TileRows;
priv->picture.av1.picture_parameter.tile_cols = hdr->ti.TileCols;
priv->picture.av1.picture_parameter.context_update_tile_id =
hdr->ti.context_update_tile_id;
for (i = 0; i <AV1_MAX_TILE_ROWS; ++i)
priv->picture.av1.picture_parameter.tile_row_start_sb[i] =
hdr->ti.tile_row_start_sb[i];
for (i = 0; i <AV1_MAX_TILE_COLS; ++i)
priv->picture.av1.picture_parameter.tile_col_start_sb[i] =
hdr->ti.tile_col_start_sb[i];
/* Quantization Params */
priv->picture.av1.picture_parameter.base_qindex = hdr->qp.base_q_idx;
priv->picture.av1.picture_parameter.y_dc_delta_q = hdr->qp.DeltaQYDc;
priv->picture.av1.picture_parameter.u_dc_delta_q = hdr->qp.DeltaQUDc;
priv->picture.av1.picture_parameter.u_ac_delta_q = hdr->qp.DeltaQUAc;
priv->picture.av1.picture_parameter.v_dc_delta_q = hdr->qp.DeltaQVDc;
priv->picture.av1.picture_parameter.v_ac_delta_q = hdr->qp.DeltaQVAc;
priv->picture.av1.picture_parameter.qmatrix_fields.qm_y = hdr->qp.qm_y;
priv->picture.av1.picture_parameter.qmatrix_fields.qm_u = hdr->qp.qm_u;
priv->picture.av1.picture_parameter.qmatrix_fields.qm_v = hdr->qp.qm_v;
/* Segmentation Params */
priv->picture.av1.picture_parameter.seg_info.segment_info_fields.enabled =
hdr->sp.segmentation_enabled;
priv->picture.av1.picture_parameter.seg_info.segment_info_fields.update_map =
hdr->sp.segmentation_update_map;
priv->picture.av1.picture_parameter.seg_info.segment_info_fields.temporal_update =
hdr->sp.segmentation_temporal_update;
for (i = 0; i < AV1_MAX_SEGMENTS; ++i) {
for (j = 0; j < AV1_SEG_LVL_MAX; ++j)
priv->picture.av1.picture_parameter.seg_info.feature_data[i][j] =
hdr->sp.FeatureData[i][j];
priv->picture.av1.picture_parameter.seg_info.feature_mask[i] =
hdr->sp.FeatureMask[i];
}
/* Delta Q Params */
priv->picture.av1.picture_parameter.mode_control_fields.delta_q_present_flag =
hdr->dqp.delta_q_present;
priv->picture.av1.picture_parameter.mode_control_fields.log2_delta_q_res =
hdr->dqp.delta_q_res;
/* Delta LF Params */
priv->picture.av1.picture_parameter.mode_control_fields.delta_lf_present_flag =
hdr->dlfp.delta_lf_present;
priv->picture.av1.picture_parameter.mode_control_fields.log2_delta_lf_res =
hdr->dlfp.delta_lf_res;
priv->picture.av1.picture_parameter.mode_control_fields.delta_lf_multi =
hdr->dlfp.delta_lf_multi;
/* Loop Filter Params */
for (i = 0; i < 2; ++i)
priv->picture.av1.picture_parameter.filter_level[i] = hdr->lfp.loop_filter_level[i];
priv->picture.av1.picture_parameter.filter_level_u = hdr->lfp.loop_filter_level[2];
priv->picture.av1.picture_parameter.filter_level_v = hdr->lfp.loop_filter_level[3];
priv->picture.av1.picture_parameter.loop_filter_info_fields.sharpness_level =
hdr->lfp.loop_filter_sharpness;
priv->picture.av1.picture_parameter.loop_filter_info_fields.mode_ref_delta_enabled =
hdr->lfp.loop_filter_delta_enabled;
priv->picture.av1.picture_parameter.loop_filter_info_fields.mode_ref_delta_update =
hdr->lfp.loop_filter_delta_update;
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i)
priv->picture.av1.picture_parameter.ref_deltas[i] =
hdr->lfp.loop_filter_ref_deltas[i];
for (i = 0; i < 2; ++i)
priv->picture.av1.picture_parameter.mode_deltas[i] =
hdr->lfp.loop_filter_mode_deltas[i];
/* CDEF Params */
priv->picture.av1.picture_parameter.cdef_damping_minus_3 =
hdr->cdefp.cdef_damping_minus_3;
priv->picture.av1.picture_parameter.cdef_bits = hdr->cdefp.cdef_bits;
for (i = 0; i < AV1_MAX_CDEF_BITS_ARRAY; ++i) {
priv->picture.av1.picture_parameter.cdef_y_strengths[i] =
hdr->cdefp.cdef_y_strengths[i];
priv->picture.av1.picture_parameter.cdef_uv_strengths[i] =
hdr->cdefp.cdef_uv_strengths[i];
}
/* Loop Restoration Params */
priv->picture.av1.picture_parameter.loop_restoration_fields.yframe_restoration_type =
hdr->lrp.FrameRestorationType[0];
priv->picture.av1.picture_parameter.loop_restoration_fields.cbframe_restoration_type =
hdr->lrp.FrameRestorationType[1];
priv->picture.av1.picture_parameter.loop_restoration_fields.crframe_restoration_type =
hdr->lrp.FrameRestorationType[2];
for (i = 0; i < 3; ++i)
priv->picture.av1.picture_parameter.lr_unit_size[i] = hdr->lrp.LoopRestorationSize[i];
priv->picture.av1.picture_parameter.mode_control_fields.tx_mode = hdr->tm.TxMode;
priv->picture.av1.picture_parameter.mode_control_fields.reference_select =
(hdr->reference_select == REFERENCE_MODE_SELECT) ? COMPOUND_REFERENCE : SINGLE_REFERENCE;
priv->picture.av1.picture_parameter.mode_control_fields.skip_mode_present =
hdr->smp.skip_mode_present;
priv->picture.av1.picture_parameter.pic_info_fields.allow_warped_motion =
hdr->allow_warped_motion;
priv->picture.av1.picture_parameter.mode_control_fields.reduced_tx_set_used =
hdr->reduced_tx_set;
/* Global Motion Params */
for (i = 0; i < 7; ++i) {
priv->picture.av1.picture_parameter.wm[i].wmtype = hdr->gmp.GmType[i + 1];
for (j = 0; j < 6; ++j)
priv->picture.av1.picture_parameter.wm[i].wmmat[j] = hdr->gmp.gm_params[i + 1][j];
}
/* Film Grain Params */
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.apply_grain =
hdr->fgp.apply_grain;
priv->picture.av1.picture_parameter.film_grain_info.grain_seed =
hdr->fgp.grain_seed;
priv->picture.av1.picture_parameter.film_grain_info.num_y_points =
hdr->fgp.num_y_points;
for (i = 0; i < AV1_FG_MAX_NUM_Y_POINTS; ++i) {
priv->picture.av1.picture_parameter.film_grain_info.point_y_value[i] =
hdr->fgp.point_y_value[i];
priv->picture.av1.picture_parameter.film_grain_info.point_y_scaling[i] =
hdr->fgp.point_y_scaling[i];
}
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.
chroma_scaling_from_luma = hdr->fgp.chroma_scaling_from_luma;
priv->picture.av1.picture_parameter.film_grain_info.num_cb_points =
hdr->fgp.num_cb_points;
priv->picture.av1.picture_parameter.film_grain_info.num_cr_points =
hdr->fgp.num_cr_points;
for (i = 0; i < AV1_FG_MAX_NUM_CBR_POINTS; ++i) {
priv->picture.av1.picture_parameter.film_grain_info.point_cb_value[i] =
hdr->fgp.point_cb_value[i];
priv->picture.av1.picture_parameter.film_grain_info.point_cb_scaling[i] =
hdr->fgp.point_cb_scaling[i];
priv->picture.av1.picture_parameter.film_grain_info.point_cr_value[i] =
hdr->fgp.point_cr_value[i];
priv->picture.av1.picture_parameter.film_grain_info.point_cr_scaling[i] =
hdr->fgp.point_cr_scaling[i];
}
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.
grain_scaling_minus_8 = hdr->fgp.grain_scaling_minus_8;
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.
ar_coeff_lag = hdr->fgp.ar_coeff_lag;
for (i = 0; i < AV1_FG_MAX_NUM_POS_LUMA; ++i)
priv->picture.av1.picture_parameter.film_grain_info.ar_coeffs_y[i] =
hdr->fgp.ar_coeffs_y[i];
for (i = 0; i < AV1_FG_MAX_NUM_POS_CHROMA; ++i) {
priv->picture.av1.picture_parameter.film_grain_info.ar_coeffs_cb[i] =
hdr->fgp.ar_coeffs_cb[i];
priv->picture.av1.picture_parameter.film_grain_info.ar_coeffs_cr[i] =
hdr->fgp.ar_coeffs_cr[i];
}
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.
ar_coeff_shift_minus_6 = hdr->fgp.ar_coeff_shift_minus_6;
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.
grain_scale_shift = hdr->fgp.grain_scale_shift;
priv->picture.av1.picture_parameter.film_grain_info.cb_mult = hdr->fgp.cb_mult;
priv->picture.av1.picture_parameter.film_grain_info.cb_luma_mult = hdr->fgp.cb_luma_mult;
priv->picture.av1.picture_parameter.film_grain_info.cb_offset = hdr->fgp.cb_offset;
priv->picture.av1.picture_parameter.film_grain_info.cr_mult = hdr->fgp.cr_mult;
priv->picture.av1.picture_parameter.film_grain_info.cr_luma_mult = hdr->fgp.cr_luma_mult;
priv->picture.av1.picture_parameter.film_grain_info.cr_offset = hdr->fgp.cr_offset;
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.
overlap_flag = hdr->fgp.overlap_flag;
priv->picture.av1.picture_parameter.film_grain_info.film_grain_info_fields.
clip_to_restricted_range = hdr->fgp.clip_to_restricted_range;
}
static void parse_tile_hdr(vid_dec_PrivateType *priv, struct vl_vlc *vlc,
unsigned start_bits_pos, unsigned total_obu_len)
{
struct tile_info *ti = &(priv->codec_data.av1.uncompressed_header.ti);
unsigned tg_start, tg_end;
unsigned NumTiles, tileBits;
bool tile_start_and_end_present_flag;
unsigned size[AV1_MAX_NUM_TILES] = { 0 };
unsigned offset[AV1_MAX_NUM_TILES] = { 0 };
unsigned frame_header_size, left_size;
unsigned i, j;
NumTiles = ti->TileCols * ti->TileRows;
tile_start_and_end_present_flag = 0;
if (NumTiles > 1)
tile_start_and_end_present_flag = av1_f(vlc, 1);
if (NumTiles == 1 || !tile_start_and_end_present_flag) {
tg_start = 0;
tg_end = NumTiles - 1;
} else {
tileBits = ti->TileColsLog2 + ti->TileRowsLog2;
tg_start = av1_f(vlc, tileBits);
tg_end = av1_f(vlc, tileBits);
}
av1_byte_alignment(vlc);
frame_header_size = (start_bits_pos - vl_vlc_bits_left(vlc)) / 8;
left_size = total_obu_len - frame_header_size;
for (i = tg_start; i <= tg_end; ++i) {
if (i == tg_start) {
offset[i] = priv->codec_data.av1.bs_obu_td_sz +
priv->codec_data.av1.bs_obu_seq_sz + frame_header_size +
ti->TileSizeBytes;
if (tg_start == tg_end) {
size[i] = left_size;
for (j = 0; j < size[i]; ++j) {
vl_vlc_fillbits(vlc);
vl_vlc_eatbits(vlc, 8);
}
break;
}
} else {
offset[i] = offset[i - 1] + ti->TileSizeBytes + size[i - 1];
left_size -= ti->TileSizeBytes + size[i - 1];
}
if (i != tg_end) {
size[i] = av1_le(vlc, ti->TileSizeBytes) + 1;
} else {
offset[i] = offset[i - 1] + size[i - 1];
size[i] = left_size;
}
for (j = 0; j < size[i]; ++j) {
vl_vlc_fillbits(vlc);
vl_vlc_eatbits(vlc, 8);
}
}
for (i = tg_start; i <= tg_end; ++i) {
priv->picture.av1.slice_parameter.slice_data_offset[i] = offset[i];
priv->picture.av1.slice_parameter.slice_data_size[i] = size[i];
}
}
static struct dec_av1_task *dec_av1_NeedTask(vid_dec_PrivateType *priv)
{
struct pipe_video_buffer templat = {};
struct dec_av1_task *task;
struct vl_screen *omx_screen;
struct pipe_screen *pscreen;
omx_screen = priv->screen;
assert(omx_screen);
pscreen = omx_screen->pscreen;
assert(pscreen);
if (!list_is_empty(&priv->codec_data.av1.free_tasks)) {
task = list_entry(priv->codec_data.av1.free_tasks.next,
struct dec_av1_task, list);
task->buf_ref_count = 1;
list_del(&task->list);
return task;
}
task = CALLOC_STRUCT(dec_av1_task);
if (!task)
return NULL;
memset(&templat, 0, sizeof(templat));
templat.width = priv->codec->width;
templat.height = priv->codec->height;
templat.buffer_format = pscreen->get_video_param(
pscreen,
PIPE_VIDEO_PROFILE_UNKNOWN,
PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
PIPE_VIDEO_CAP_PREFERED_FORMAT
);
templat.interlaced = false;
task->buf = priv->pipe->create_video_buffer(priv->pipe, &templat);
if (!task->buf) {
FREE(task);
return NULL;
}
task->buf_ref_count = 1;
task->is_sef_task = false;
return task;
}
static void dec_av1_ReleaseTask(vid_dec_PrivateType *priv,
struct list_head *head)
{
if (!head || !head->next)
return;
list_for_each_entry_safe(struct dec_av1_task, task, head, list) {
task->buf->destroy(task->buf);
FREE(task);
}
}
static void dec_av1_MoveTask(struct list_head *from,
struct list_head *to)
{
to->prev->next = from->next;
from->next->prev = to->prev;
from->prev->next = to;
to->prev = from->prev;
list_inithead(from);
}
static void dec_av1_SortTask(vid_dec_PrivateType *priv)
{
int i;
list_for_each_entry_safe(struct dec_av1_task, t,
&priv->codec_data.av1.finished_tasks, list) {
bool found = false;
for (i = 0; i < 8; ++i) {
if (t->buf == priv->picture.av1.ref[i]) {
found = true;
break;
}
}
if (!found && t->buf_ref_count == 0) {
list_del(&t->list);
list_addtail(&t->list, &priv->codec_data.av1.free_tasks);
}
}
}
static struct dec_av1_task *dec_av1_SearchTask(vid_dec_PrivateType *priv,
struct list_head *tasks)
{
unsigned idx =
priv->codec_data.av1.uncompressed_header.frame_to_show_map_idx;
list_for_each_entry_safe(struct dec_av1_task, t, tasks, list) {
if (t->buf == priv->picture.av1.ref[idx])
return t;
}
return NULL;
}
static bool dec_av1_GetStartedTask(vid_dec_PrivateType *priv,
struct dec_av1_task *task, struct list_head *tasks)
{
struct dec_av1_task *started_task;
++priv->codec_data.av1.que_num;
list_addtail(&task->list, &priv->codec_data.av1.started_tasks);
if (priv->codec_data.av1.que_num <= 16)
return false;
started_task = list_entry(priv->codec_data.av1.started_tasks.next,
struct dec_av1_task, list);
list_del(&started_task->list);
list_addtail(&started_task->list, tasks);
--priv->codec_data.av1.que_num;
return true;
}
static void dec_av1_ShowExistingframe(vid_dec_PrivateType *priv)
{
struct input_buf_private *inp = priv->in_buffers[0]->pInputPortPrivate;
struct dec_av1_task *task, *existing_task;
bool fnd;
task = CALLOC_STRUCT(dec_av1_task);
if (!task)
return;
task->is_sef_task = true;
mtx_lock(&priv->codec_data.av1.mutex);
dec_av1_MoveTask(&inp->tasks, &priv->codec_data.av1.finished_tasks);
dec_av1_SortTask(priv);
existing_task = dec_av1_SearchTask(priv, &priv->codec_data.av1.started_tasks);
if (existing_task) {
++existing_task->buf_ref_count;
task->buf = existing_task->buf;
task->buf_ref = &existing_task->buf;
task->buf_ref_count = 0;
} else {
existing_task = dec_av1_SearchTask(priv, &priv->codec_data.av1.finished_tasks);
if (existing_task) {
struct vl_screen *omx_screen;
struct pipe_screen *pscreen;
struct pipe_video_buffer templat = {};
struct pipe_video_buffer *buf;
struct pipe_box box={};
omx_screen = priv->screen;
assert(omx_screen);
pscreen = omx_screen->pscreen;
assert(pscreen);
memset(&templat, 0, sizeof(templat));
templat.width = priv->codec->width;
templat.height = priv->codec->height;
templat.buffer_format = pscreen->get_video_param(
pscreen,
PIPE_VIDEO_PROFILE_UNKNOWN,
PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
PIPE_VIDEO_CAP_PREFERED_FORMAT
);
templat.interlaced = false;
buf = priv->pipe->create_video_buffer(priv->pipe, &templat);
if (!buf) {
FREE(task);
mtx_unlock(&priv->codec_data.av1.mutex);
return;
}
box.width = priv->codec->width;
box.height = priv->codec->height;
box.depth = 1;
priv->pipe->resource_copy_region(priv->pipe,
((struct vl_video_buffer *)buf)->resources[0],
0, 0, 0, 0,
((struct vl_video_buffer *)(existing_task->buf))->resources[0],
0, &box);
box.width /= 2;
box.height/= 2;
priv->pipe->resource_copy_region(priv->pipe,
((struct vl_video_buffer *)buf)->resources[1],
0, 0, 0, 0,
((struct vl_video_buffer *)(existing_task->buf))->resources[1],
0, &box);
priv->pipe->flush(priv->pipe, NULL, 0);
existing_task->buf_ref_count = 0;
task->buf = buf;
task->buf_ref_count = 1;
} else {
FREE(task);
mtx_unlock(&priv->codec_data.av1.mutex);
return;
}
}
dec_av1_SortTask(priv);
fnd = dec_av1_GetStartedTask(priv, task, &inp->tasks);
mtx_unlock(&priv->codec_data.av1.mutex);
if (fnd)
priv->frame_finished = 1;
}
static struct dec_av1_task *dec_av1_BeginFrame(vid_dec_PrivateType *priv)
{
struct input_buf_private *inp = priv->in_buffers[0]->pInputPortPrivate;
struct dec_av1_task *task;
if (priv->frame_started)
return NULL;
if (!priv->codec) {
struct vl_screen *omx_screen;
struct pipe_screen *pscreen;
struct pipe_video_codec templat = {};
bool supported;
omx_screen = priv->screen;
assert(omx_screen);
pscreen = omx_screen->pscreen;
assert(pscreen);
supported = vl_codec_supported(pscreen, priv->profile, false);
assert(supported && "AV1 is not supported");
templat.profile = priv->profile;
templat.entrypoint = PIPE_VIDEO_ENTRYPOINT_BITSTREAM;
templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
templat.max_references = AV1_NUM_REF_FRAMES;
templat.expect_chunked_decode = true;
omx_base_video_PortType *port;
port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
templat.width = port->sPortParam.format.video.nFrameWidth;
templat.height = port->sPortParam.format.video.nFrameHeight;
priv->codec = priv->pipe->create_video_codec(priv->pipe, &templat);
}
mtx_lock(&priv->codec_data.av1.mutex);
dec_av1_MoveTask(&inp->tasks, &priv->codec_data.av1.finished_tasks);
dec_av1_SortTask(priv);
mtx_unlock(&priv->codec_data.av1.mutex);
task = dec_av1_NeedTask(priv);
if (!task)
return NULL;
priv->codec->begin_frame(priv->codec, task->buf, &priv->picture.base);
priv->frame_started = true;
return task;
}
static void dec_av1_EndFrame(vid_dec_PrivateType *priv, struct dec_av1_task *task)
{
struct input_buf_private *inp = priv->in_buffers[0]->pInputPortPrivate;
unsigned refresh_frame_flags;
bool fnd;
unsigned i;
if (!priv->frame_started || ! task)
return;
priv->codec->end_frame(priv->codec, task->buf, &priv->picture.base);
priv->frame_started = false;
refresh_frame_flags = priv->codec_data.av1.uncompressed_header.refresh_frame_flags;
for (i = 0; i < AV1_NUM_REF_FRAMES; ++i) {
if (refresh_frame_flags & (1 << i)) {
memcpy(&priv->codec_data.av1.refs[i], &priv->codec_data.av1.uncompressed_header,
sizeof(struct av1_uncompressed_header_obu));
priv->picture.av1.ref[i] = task->buf;
priv->codec_data.av1.RefFrames[i].RefFrameType =
priv->codec_data.av1.uncompressed_header.frame_type;
priv->codec_data.av1.RefFrames[i].RefFrameId =
priv->codec_data.av1.uncompressed_header.current_frame_id;
priv->codec_data.av1.RefFrames[i].RefUpscaledWidth =
priv->codec_data.av1.uncompressed_header.UpscaledWidth;
priv->codec_data.av1.RefFrames[i].RefFrameWidth =
priv->codec_data.av1.uncompressed_header.FrameWidth;
priv->codec_data.av1.RefFrames[i].RefFrameHeight =
priv->codec_data.av1.uncompressed_header.FrameHeight;
priv->codec_data.av1.RefFrames[i].RefRenderWidth =
priv->codec_data.av1.uncompressed_header.RenderWidth;
priv->codec_data.av1.RefFrames[i].RefRenderHeight =
priv->codec_data.av1.uncompressed_header.RenderHeight;
}
}
if (!priv->picture.av1.picture_parameter.pic_info_fields.show_frame)
task->no_show_frame = true;
mtx_lock(&priv->codec_data.av1.mutex);
fnd = dec_av1_GetStartedTask(priv, task, &priv->codec_data.av1.decode_tasks);
if (!fnd) {
mtx_unlock(&priv->codec_data.av1.mutex);
return;
}
if (!priv->codec_data.av1.stacked_frame)
dec_av1_MoveTask(&priv->codec_data.av1.decode_tasks, &inp->tasks);
mtx_unlock(&priv->codec_data.av1.mutex);
priv->frame_finished = 1;
}
static void dec_av1_Decode(vid_dec_PrivateType *priv, struct vl_vlc *vlc,
unsigned min_bits_left)
{
unsigned start_bits_pos = vl_vlc_bits_left(vlc);
unsigned start_bits = vl_vlc_valid_bits(vlc);
unsigned start_bytes = start_bits / 8;
const void *obu_data = vlc->data;
uint8_t start_buf[8];
unsigned num_buffers = 0;
void * const * buffers[4];
unsigned sizes[4];
unsigned obu_size = 0;
unsigned total_obu_len;
enum av1_obu_type type;
bool obu_extension_flag;
bool obu_has_size_field;
unsigned i;
for (i = 0; i < start_bytes; ++i)
start_buf[i] =
vl_vlc_peekbits(vlc, start_bits) >> ((start_bytes - i - 1) * 8);
/* obu header */
av1_f(vlc, 1); /* obu_forbidden_bit */
type = av1_f(vlc, 4);
obu_extension_flag = av1_f(vlc, 1);
obu_has_size_field = av1_f(vlc, 1);
av1_f(vlc, 1); /* obu_reserved_1bit */
if (obu_extension_flag) {
priv->codec_data.av1.ext.temporal_id = av1_f(vlc, 3);
priv->codec_data.av1.ext.spatial_id = av1_f(vlc, 2);
av1_f(vlc, 3); /* extension_header_reserved_3bits */
}
obu_size = (obu_has_size_field) ? av1_uleb128(vlc) :
(priv->sizes[0] - (unsigned)obu_extension_flag - 1);
total_obu_len = (start_bits_pos - vl_vlc_bits_left(vlc)) / 8 + obu_size;
switch (type) {
case AV1_OBU_SEQUENCE_HEADER: {
sequence_header_obu(priv, vlc);
av1_byte_alignment(vlc);
priv->codec_data.av1.bs_obu_seq_sz = total_obu_len;
memcpy(priv->codec_data.av1.bs_obu_seq_buf, start_buf, start_bytes);
memcpy(priv->codec_data.av1.bs_obu_seq_buf + start_bytes, obu_data,
total_obu_len - start_bytes);
break;
}
case AV1_OBU_TEMPORAL_DELIMITER:
av1_byte_alignment(vlc);
priv->codec_data.av1.bs_obu_td_sz = total_obu_len;
memcpy(priv->codec_data.av1.bs_obu_td_buf, start_buf, total_obu_len);
break;
case AV1_OBU_FRAME_HEADER:
frame_header_obu(priv, vlc);
if (priv->codec_data.av1.uncompressed_header.show_existing_frame)
dec_av1_ShowExistingframe(priv);
av1_byte_alignment(vlc);
break;
case AV1_OBU_FRAME: {
struct dec_av1_task *task;
frame_header_obu(priv, vlc);
av1_byte_alignment(vlc);
parse_tile_hdr(priv, vlc, start_bits_pos, total_obu_len);
av1_byte_alignment(vlc);
task = dec_av1_BeginFrame(priv);
if (!task)
return;
if (priv->codec_data.av1.bs_obu_td_sz) {
buffers[num_buffers] = (void *)priv->codec_data.av1.bs_obu_td_buf;
sizes[num_buffers++] = priv->codec_data.av1.bs_obu_td_sz;
priv->codec_data.av1.bs_obu_td_sz = 0;
}
if (priv->codec_data.av1.bs_obu_seq_sz) {
buffers[num_buffers] = (void *)priv->codec_data.av1.bs_obu_seq_buf;
sizes[num_buffers++] = priv->codec_data.av1.bs_obu_seq_sz;
priv->codec_data.av1.bs_obu_seq_sz = 0;
}
buffers[num_buffers] = (void *)start_buf;
sizes[num_buffers++] = start_bytes;
buffers[num_buffers] = (void *)obu_data;
sizes[num_buffers++] = total_obu_len - start_bytes;
priv->codec->decode_bitstream(priv->codec, priv->target,
&priv->picture.base, num_buffers, (const void * const*)buffers, sizes);
priv->codec_data.av1.stacked_frame =
(vl_vlc_bits_left(vlc) > min_bits_left) ? true : false;
dec_av1_EndFrame(priv, task);
break;
}
default:
av1_byte_alignment(vlc);
break;
}
return;
}
OMX_ERRORTYPE vid_dec_av1_AllocateInBuffer(omx_base_PortType *port,
OMX_INOUT OMX_BUFFERHEADERTYPE **buf, OMX_IN OMX_U32 idx,
OMX_IN OMX_PTR private, OMX_IN OMX_U32 size)
{
struct input_buf_private *inp;
OMX_ERRORTYPE r;
r = base_port_AllocateBuffer(port, buf, idx, private, size);
if (r)
return r;
inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private);
if (!inp) {
base_port_FreeBuffer(port, idx, *buf);
return OMX_ErrorInsufficientResources;
}
list_inithead(&inp->tasks);
return OMX_ErrorNone;
}
OMX_ERRORTYPE vid_dec_av1_UseInBuffer(omx_base_PortType *port,
OMX_BUFFERHEADERTYPE **buf, OMX_U32 idx,
OMX_PTR private, OMX_U32 size, OMX_U8 *mem)
{
struct input_buf_private *inp;
OMX_ERRORTYPE r;
r = base_port_UseBuffer(port, buf, idx, private, size, mem);
if (r)
return r;
inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private);
if (!inp) {
base_port_FreeBuffer(port, idx, *buf);
return OMX_ErrorInsufficientResources;
}
list_inithead(&inp->tasks);
return OMX_ErrorNone;
}
void vid_dec_av1_FreeInputPortPrivate(vid_dec_PrivateType *priv,
OMX_BUFFERHEADERTYPE *buf)
{
struct input_buf_private *inp = buf->pInputPortPrivate;
if (!inp || !inp->tasks.next)
return;
list_for_each_entry_safe(struct dec_av1_task, task, &inp->tasks, list) {
task->buf->destroy(task->buf);
FREE(task);
}
}
void vid_dec_av1_ReleaseTasks(vid_dec_PrivateType *priv)
{
dec_av1_ReleaseTask(priv, &priv->codec_data.av1.free_tasks);
dec_av1_ReleaseTask(priv, &priv->codec_data.av1.started_tasks);
dec_av1_ReleaseTask(priv, &priv->codec_data.av1.decode_tasks);
dec_av1_ReleaseTask(priv, &priv->codec_data.av1.finished_tasks);
mtx_destroy(&priv->codec_data.av1.mutex);
}
void vid_dec_av1_FrameDecoded(OMX_COMPONENTTYPE *comp,
OMX_BUFFERHEADERTYPE* input,
OMX_BUFFERHEADERTYPE* output)
{
vid_dec_PrivateType *priv = comp->pComponentPrivate;
bool eos = !!(input->nFlags & OMX_BUFFERFLAG_EOS);
struct input_buf_private *inp = input->pInputPortPrivate;
struct dec_av1_task *task;
bool stacked = false;
mtx_lock(&priv->codec_data.av1.mutex);
if (list_length(&inp->tasks) > 1)
stacked = true;
if (list_is_empty(&inp->tasks)) {
task = list_entry(priv->codec_data.av1.started_tasks.next,
struct dec_av1_task, list);
list_del(&task->list);
list_addtail(&task->list, &inp->tasks);
--priv->codec_data.av1.que_num;
}
task = list_entry(inp->tasks.next, struct dec_av1_task, list);
if (!task->no_show_frame) {
vid_dec_FillOutput(priv, task->buf, output);
output->nFilledLen = output->nAllocLen;
output->nTimeStamp = input->nTimeStamp;
} else {
task->no_show_frame = false;
output->nFilledLen = 0;
}
if (task->is_sef_task) {
if (task->buf_ref_count == 0) {
struct dec_av1_task *t = container_of(task->buf_ref, struct dec_av1_task, buf);
list_del(&task->list);
t->buf_ref_count--;
list_del(&t->list);
list_addtail(&t->list, &priv->codec_data.av1.finished_tasks);
} else if (task->buf_ref_count == 1) {
list_del(&task->list);
task->buf->destroy(task->buf);
task->buf_ref_count--;
}
FREE(task);
} else {
if (task->buf_ref_count == 1) {
list_del(&task->list);
list_addtail(&task->list, &priv->codec_data.av1.finished_tasks);
task->buf_ref_count--;
} else if (task->buf_ref_count == 2) {
list_del(&task->list);
task->buf_ref_count--;
list_addtail(&task->list, &priv->codec_data.av1.finished_tasks);
}
}
if (eos && input->pInputPortPrivate) {
if (!priv->codec_data.av1.que_num)
input->nFilledLen = 0;
else
vid_dec_av1_FreeInputPortPrivate(priv, input);
}
else {
if (!stacked)
input->nFilledLen = 0;
}
mtx_unlock(&priv->codec_data.av1.mutex);
}
void vid_dec_av1_Init(vid_dec_PrivateType *priv)
{
priv->picture.base.profile = PIPE_VIDEO_PROFILE_AV1_MAIN;
priv->Decode = dec_av1_Decode;
list_inithead(&priv->codec_data.av1.free_tasks);
list_inithead(&priv->codec_data.av1.started_tasks);
list_inithead(&priv->codec_data.av1.decode_tasks);
list_inithead(&priv->codec_data.av1.finished_tasks);
(void)mtx_init(&priv->codec_data.av1.mutex, mtx_plain);
}
Reference in New Issue View Git Blame Copy Permalink