// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/gpu/v4l2/test/av1_decoder.h"

#include <linux/v4l2-controls.h>
#include <linux/videodev2.h>

#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/notreached.h"
#include "media/base/video_types.h"
#include "media/gpu/macros.h"
#include "media/gpu/v4l2/test/upstream_pix_fmt.h"
#include "media/parsers/ivf_parser.h"
#include "third_party/libgav1/src/src/utils/common.h"
#include "third_party/libgav1/src/src/warp_prediction.h"

namespace media {

namespace v4l2_test {

namespace {
constexpr uint32_t kDriverCodecFourcc = V4L2_PIX_FMT_AV1_FRAME;

constexpr uint32_t kNumberOfBuffersInCaptureQueue = 10;

static_assert(kNumberOfBuffersInCaptureQueue <= 16,
              "Too many CAPTURE buffers are used. The number of CAPTURE "
              "buffers is currently assumed to be no larger than 16.");

// TODO(stevecho): Remove this provision when av1-ctrls.h includes linux/bits.h.
#ifndef BIT
#define BIT(nr) (1U << (nr))
#endif

inline void conditionally_set_flags(__u8* flags,
                                    const bool condition,
                                    const __u8 mask) {
  *flags |= (condition ? mask : 0);
}

inline void conditionally_set_u32_flags(__u32* flags,
                                        const bool condition,
                                        const __u32 mask) {
  *flags |= (condition ? mask : 0);
}

// The resolution encoded in the bitstream is required for queue creation. Note
// that parsing ivf file and parsing the first frame using libgav1 parser happen
// again later in the code. This is intentionally duplicated.
const gfx::Size GetResolutionFromBitstream(
    const base::MemoryMappedFile& stream) {
  media::IvfParser ivf_parser{};
  media::IvfFileHeader ivf_file_header{};

  if (!ivf_parser.Initialize(stream.data(), stream.length(), &ivf_file_header))
    LOG(FATAL) << "Couldn't initialize IVF parser.";

  IvfFrameHeader ivf_frame_header{};
  const uint8_t* ivf_frame_data = nullptr;

  if (!ivf_parser.ParseNextFrame(&ivf_frame_header, &ivf_frame_data))
    LOG(FATAL) << "Failed to parse the first frame with IVF parser.";

  VLOG(2) << "Ivf file header: " << ivf_file_header.width << " x "
          << ivf_file_header.height;

  libgav1::InternalFrameBufferList buffer_list;
  libgav1::BufferPool buffer_pool(libgav1::OnInternalFrameBufferSizeChanged,
                                  libgav1::GetInternalFrameBuffer,
                                  libgav1::ReleaseInternalFrameBuffer,
                                  &buffer_list);
  libgav1::DecoderState decoder_state;
  libgav1::ObuParser av1_parser(ivf_frame_data, ivf_frame_header.frame_size, 0,
                                &buffer_pool, &decoder_state);
  libgav1::RefCountedBufferPtr first_frame;

  if (!av1_parser.HasData())
    LOG(FATAL) << "Libgav1 parser doesn't have any data to parse.";

  if (av1_parser.ParseOneFrame(&first_frame) != libgav1::kStatusOk)
    LOG(FATAL) << "Failed to parse the first frame using libgav1 parser.";

  LOG(INFO) << "Frame header: " << av1_parser.frame_header().width << " x "
            << av1_parser.frame_header().height;

  return gfx::Size(av1_parser.frame_header().width,
                   av1_parser.frame_header().height);
}

// Section 5.5. Sequence header OBU syntax in the AV1 spec.
// https://aomediacodec.github.io/av1-spec/av1-spec.pdf
void FillSequenceParams(
    struct v4l2_ctrl_av1_sequence* v4l2_seq_params,
    const std::optional<libgav1::ObuSequenceHeader>& seq_header) {
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->still_picture,
                              V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->use_128x128_superblock,
                              V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_filter_intra,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_intra_edge_filter,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER);
  conditionally_set_u32_flags(
      &v4l2_seq_params->flags, seq_header->enable_interintra_compound,
      V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_masked_compound,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_warped_motion,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_dual_filter,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_order_hint,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_jnt_comp,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_ref_frame_mvs,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_superres,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES);
  conditionally_set_u32_flags(&v4l2_seq_params->flags, seq_header->enable_cdef,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->enable_restoration,
                              V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->color_config.is_monochrome,
                              V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->color_config.color_range,
                              V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->color_config.subsampling_x,
                              V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->color_config.subsampling_y,
                              V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->film_grain_params_present,
                              V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT);
  conditionally_set_u32_flags(&v4l2_seq_params->flags,
                              seq_header->color_config.separate_uv_delta_q,
                              V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q);

  v4l2_seq_params->seq_profile = seq_header->profile;
  v4l2_seq_params->order_hint_bits = seq_header->order_hint_bits;
  v4l2_seq_params->bit_depth = seq_header->color_config.bitdepth;
  v4l2_seq_params->max_frame_width_minus_1 = seq_header->max_frame_width - 1;
  v4l2_seq_params->max_frame_height_minus_1 = seq_header->max_frame_height - 1;
}

// Section 5.9.11. Loop filter params syntax.
// Note that |update_ref_delta| and |update_mode_delta| flags in the spec
// are not needed for V4L2 AV1 API.
void FillLoopFilterParams(struct v4l2_av1_loop_filter* v4l2_lf,
                          const libgav1::LoopFilter& lf) {
  conditionally_set_flags(&v4l2_lf->flags, lf.delta_enabled,
                          V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED);
  conditionally_set_flags(&v4l2_lf->flags, lf.delta_update,
                          V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE);

  static_assert(std::size(decltype(v4l2_lf->level){}) == libgav1::kFrameLfCount,
                "Invalid size of loop filter level (strength) array");
  for (size_t i = 0; i < libgav1::kFrameLfCount; i++)
    v4l2_lf->level[i] = base::checked_cast<__u8>(lf.level[i]);

  v4l2_lf->sharpness = lf.sharpness;

  static_assert(std::size(decltype(v4l2_lf->ref_deltas){}) ==
                    libgav1::kNumReferenceFrameTypes,
                "Invalid size of ref deltas array");
  for (size_t i = 0; i < libgav1::kNumReferenceFrameTypes; i++)
    v4l2_lf->ref_deltas[i] = lf.ref_deltas[i];

  static_assert(std::size(decltype(v4l2_lf->mode_deltas){}) ==
                    libgav1::kLoopFilterMaxModeDeltas,
                "Invalid size of mode deltas array");
  for (size_t i = 0; i < libgav1::kLoopFilterMaxModeDeltas; i++)
    v4l2_lf->mode_deltas[i] = lf.mode_deltas[i];
}

// Section 5.9.18. Loop filter delta parameters syntax.
// Note that |delta_lf_res| in |v4l2_av1_loop_filter| corresponds to
// |delta_lf.scale| in the frame header defined in libgav1.
void FillLoopFilterDeltaParams(struct v4l2_av1_loop_filter* v4l2_lf,
                               const libgav1::Delta& delta_lf) {
  conditionally_set_flags(&v4l2_lf->flags, delta_lf.present,
                          V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT);
  conditionally_set_flags(&v4l2_lf->flags, delta_lf.multi,
                          V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI);

  v4l2_lf->delta_lf_res = delta_lf.scale;
}

// Section 5.9.12. Quantization params syntax
void FillQuantizationParams(struct v4l2_av1_quantization* v4l2_quant,
                            const libgav1::QuantizerParameters& quant) {
  conditionally_set_flags(&v4l2_quant->flags, quant.use_matrix,
                          V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX);

  v4l2_quant->base_q_idx = quant.base_index;

  // Note that quant.delta_ac[0] is useless as it is always 0 according to
  // libgav1.
  v4l2_quant->delta_q_y_dc = quant.delta_dc[0];

  v4l2_quant->delta_q_u_dc = quant.delta_dc[1];
  v4l2_quant->delta_q_u_ac = quant.delta_ac[1];

  v4l2_quant->delta_q_v_dc = quant.delta_dc[2];
  v4l2_quant->delta_q_v_ac = quant.delta_ac[2];

  if (!quant.use_matrix)
    return;

  v4l2_quant->qm_y = base::checked_cast<uint8_t>(quant.matrix_level[0]);
  v4l2_quant->qm_u = base::checked_cast<uint8_t>(quant.matrix_level[1]);
  v4l2_quant->qm_v = base::checked_cast<uint8_t>(quant.matrix_level[2]);
}

// Section 5.9.17. Quantizer index delta parameters syntax
void FillQuantizerIndexDeltaParams(
    struct v4l2_av1_quantization* v4l2_quant,
    const std::optional<libgav1::ObuSequenceHeader>& seq_header,
    const libgav1::ObuFrameHeader& frm_header) {
  // |diff_uv_delta| in the spec doesn't exist in libgav1,
  // because libgav1 infers it using the following logic.
  const bool diff_uv_delta = (frm_header.quantizer.base_index != 0) &&
                             (!seq_header->color_config.is_monochrome) &&
                             (seq_header->color_config.separate_uv_delta_q);
  conditionally_set_flags(&v4l2_quant->flags, diff_uv_delta,
                          V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA);

  conditionally_set_flags(&v4l2_quant->flags, frm_header.delta_q.present,
                          V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT);

  // |scale| is used to store |delta_q_res| value. This is because libgav1 uses
  // the same struct |Delta| both for quantizer index delta parameters and loop
  // filter delta parameters.
  v4l2_quant->delta_q_res = frm_header.delta_q.scale;
}

// Section 5.9.14. Segmentation params syntax
void FillSegmentationParams(struct v4l2_av1_segmentation* v4l2_seg,
                            const libgav1::Segmentation& seg) {
  conditionally_set_flags(&v4l2_seg->flags, seg.enabled,
                          V4L2_AV1_SEGMENTATION_FLAG_ENABLED);
  conditionally_set_flags(&v4l2_seg->flags, seg.update_map,
                          V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP);
  conditionally_set_flags(&v4l2_seg->flags, seg.temporal_update,
                          V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE);
  conditionally_set_flags(&v4l2_seg->flags, seg.update_data,
                          V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA);
  conditionally_set_flags(&v4l2_seg->flags, seg.segment_id_pre_skip,
                          V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP);

  static_assert(
      std::size(decltype(v4l2_seg->feature_enabled){}) == libgav1::kMaxSegments,
      "Invalid size of |feature_enabled| array in |v4l2_av1_segmentation| "
      "struct");

  static_assert(
      std::size(decltype(v4l2_seg->feature_data){}) == libgav1::kMaxSegments &&
          std::extent<decltype(v4l2_seg->feature_data), 0>::value ==
              libgav1::kSegmentFeatureMax,
      "Invalid size of |feature_data| array in |v4l2_av1_segmentation| struct");

  for (size_t i = 0; i < libgav1::kMaxSegments; ++i) {
    for (size_t j = 0; j < libgav1::kSegmentFeatureMax; ++j) {
      v4l2_seg->feature_enabled[i] |= (seg.feature_enabled[i][j] << j);
      v4l2_seg->feature_data[i][j] = seg.feature_data[i][j];
    }
  }

  v4l2_seg->last_active_seg_id = seg.last_active_segment_id;
}

// Section 5.9.19. CDEF params syntax
void FillCdefParams(struct v4l2_av1_cdef* v4l2_cdef,
                    const libgav1::Cdef& cdef,
                    uint8_t color_bitdepth) {
  // Damping value parsed in libgav1 is from the spec + (|color_bitdepth| - 8).
  CHECK_GE(color_bitdepth, 8u);
  const uint8_t coeff_shift = color_bitdepth - 8u;

  v4l2_cdef->damping_minus_3 =
      base::checked_cast<uint8_t>(cdef.damping - coeff_shift - 3u);

  v4l2_cdef->bits = cdef.bits;

  static_assert(std::size(decltype(v4l2_cdef->y_pri_strength){}) ==
                    libgav1::kMaxCdefStrengths,
                "Invalid size of cdef y_pri_strength strength");

  static_assert(std::size(decltype(v4l2_cdef->y_sec_strength){}) ==
                    libgav1::kMaxCdefStrengths,
                "Invalid size of cdef y_sec_strength strength");

  static_assert(std::size(decltype(v4l2_cdef->uv_pri_strength){}) ==
                    libgav1::kMaxCdefStrengths,
                "Invalid size of cdef uv_pri_strength strength");

  static_assert(std::size(decltype(v4l2_cdef->uv_sec_strength){}) ==
                    libgav1::kMaxCdefStrengths,
                "Invalid size of cdef uv_sec_strength strength");

  SafeArrayMemcpy(v4l2_cdef->y_pri_strength, cdef.y_primary_strength);
  SafeArrayMemcpy(v4l2_cdef->y_sec_strength, cdef.y_secondary_strength);
  SafeArrayMemcpy(v4l2_cdef->uv_pri_strength, cdef.uv_primary_strength);
  SafeArrayMemcpy(v4l2_cdef->uv_sec_strength, cdef.uv_secondary_strength);

  // All the strength values parsed in libgav1 are from the AV1 spec and left
  // shifted by (|color_bitdepth| - 8). So these values need to be right shifted
  // by (|color_bitdepth| - 8) before passing to a driver.
  for (size_t i = 0; i < libgav1::kMaxCdefStrengths; i++) {
    v4l2_cdef->y_pri_strength[i] >>= coeff_shift;
    v4l2_cdef->y_sec_strength[i] >>= coeff_shift;
    v4l2_cdef->uv_pri_strength[i] >>= coeff_shift;
    v4l2_cdef->uv_sec_strength[i] >>= coeff_shift;
  }
}

// 5.9.20. Loop restoration params syntax
void FillLoopRestorationParams(v4l2_av1_loop_restoration* v4l2_lr,
                               const libgav1::LoopRestoration& lr) {
  for (size_t i = 0; i < V4L2_AV1_NUM_PLANES_MAX; i++) {
    switch (lr.type[i]) {
      case libgav1::LoopRestorationType::kLoopRestorationTypeNone:
        v4l2_lr->frame_restoration_type[i] = V4L2_AV1_FRAME_RESTORE_NONE;
        break;
      case libgav1::LoopRestorationType::kLoopRestorationTypeWiener:
        v4l2_lr->frame_restoration_type[i] = V4L2_AV1_FRAME_RESTORE_WIENER;
        break;
      case libgav1::LoopRestorationType::kLoopRestorationTypeSgrProj:
        v4l2_lr->frame_restoration_type[i] = V4L2_AV1_FRAME_RESTORE_SGRPROJ;
        break;
      case libgav1::LoopRestorationType::kLoopRestorationTypeSwitchable:
        v4l2_lr->frame_restoration_type[i] = V4L2_AV1_FRAME_RESTORE_SWITCHABLE;
        break;
      default:
        NOTREACHED() << "Invalid loop restoration type";
    }

    if (v4l2_lr->frame_restoration_type[i] != V4L2_AV1_FRAME_RESTORE_NONE) {
      conditionally_set_flags(&v4l2_lr->flags, true,
                              V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR);

      conditionally_set_flags(&v4l2_lr->flags, i > 0,
                              V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR);
    }
  }

  const bool use_loop_restoration =
      std::find_if(std::begin(lr.type),
                   std::begin(lr.type) + libgav1::kMaxPlanes,
                   [](const auto type) {
                     return type != libgav1::kLoopRestorationTypeNone;
                   }) != (lr.type + libgav1::kMaxPlanes);

  if (!use_loop_restoration)
    return;

  DCHECK_GE(lr.unit_size_log2[0], lr.unit_size_log2[1]);
  DCHECK_LE(lr.unit_size_log2[0] - lr.unit_size_log2[1], 1);
  v4l2_lr->lr_unit_shift = lr.unit_size_log2[0] - 6;
  v4l2_lr->lr_uv_shift = lr.unit_size_log2[0] - lr.unit_size_log2[1];

  constexpr uint32_t kAv1RestorationTileSizeMax = 256;

  // AV1 spec (p.52) uses this formula with hard coded value 2.
  v4l2_lr->loop_restoration_size[0] =
      kAv1RestorationTileSizeMax >> (2 - v4l2_lr->lr_unit_shift);
  v4l2_lr->loop_restoration_size[1] =
      v4l2_lr->loop_restoration_size[0] >> v4l2_lr->lr_uv_shift;
  v4l2_lr->loop_restoration_size[2] =
      v4l2_lr->loop_restoration_size[0] >> v4l2_lr->lr_uv_shift;
}

// Section 5.9.15. Tile info syntax
void FillTileInfo(v4l2_av1_tile_info* v4l2_ti, const libgav1::TileInfo& ti) {
  conditionally_set_flags(&v4l2_ti->flags, ti.uniform_spacing,
                          V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING);
  static_assert(std::size(decltype(v4l2_ti->mi_col_starts){}) ==
                    (libgav1::kMaxTileColumns + 1),
                "Size of |mi_col_starts| array in |v4l2_av1_tile_info| struct "
                "does not match libgav1 expectation");

  for (size_t i = 0; i < libgav1::kMaxTileColumns + 1; i++)
    v4l2_ti->mi_col_starts[i] =
        base::checked_cast<uint32_t>(ti.tile_column_start[i]);

  static_assert(std::size(decltype(v4l2_ti->mi_row_starts){}) ==
                    (libgav1::kMaxTileRows + 1),
                "Size of |mi_row_starts| array in |v4l2_av1_tile_info| struct "
                "does not match libgav1 expectation");
  for (size_t i = 0; i < libgav1::kMaxTileRows + 1; i++)
    v4l2_ti->mi_row_starts[i] =
        base::checked_cast<uint32_t>(ti.tile_row_start[i]);

  if (!ti.uniform_spacing) {
    // Confirmed that |kMaxTileColumns| is enough size for
    // |width_in_sbs_minus_1| and |kMaxTileRows| is enough size for
    // |height_in_sbs_minus_1|
    // https://b.corp.google.com/issues/187828854#comment19
    static_assert(
        std::size(decltype(v4l2_ti->width_in_sbs_minus_1){}) ==
            libgav1::kMaxTileColumns,
        "Size of |width_in_sbs_minus_1| array in |v4l2_av1_tile_info| struct "
        "does not match libgav1 expectation");
    for (size_t i = 0; i < libgav1::kMaxTileColumns; i++) {
      if (ti.tile_column_width_in_superblocks[i] >= 1) {
        v4l2_ti->width_in_sbs_minus_1[i] = base::checked_cast<uint32_t>(
            ti.tile_column_width_in_superblocks[i] - 1);
      }
    }

    static_assert(
        std::size(decltype(v4l2_ti->height_in_sbs_minus_1){}) ==
            libgav1::kMaxTileRows,
        "Size of |height_in_sbs_minus_1| array in |v4l2_av1_tile_info| struct "
        "does not match libgav1 expectation");
    for (size_t i = 0; i < libgav1::kMaxTileRows; i++) {
      if (ti.tile_row_height_in_superblocks[i] >= 1) {
        v4l2_ti->height_in_sbs_minus_1[i] = base::checked_cast<uint32_t>(
            ti.tile_row_height_in_superblocks[i] - 1);
      }
    }
  }

  v4l2_ti->tile_size_bytes = ti.tile_size_bytes;
  v4l2_ti->context_update_tile_id = ti.context_update_id;
  v4l2_ti->tile_cols = ti.tile_columns;
  v4l2_ti->tile_rows = ti.tile_rows;
}

// Section 5.9.24. Global motion params syntax
void FillGlobalMotionParams(
    v4l2_av1_global_motion* v4l2_gm,
    const std::array<libgav1::GlobalMotion, libgav1::kNumReferenceFrameTypes>&
        gm_array) {
  // gm_array[0] (for kReferenceFrameIntra) is not used because global motion is
  // not relevant for intra frames
  for (size_t i = 1; i < libgav1::kNumReferenceFrameTypes; ++i) {
    auto gm = gm_array[i];
    switch (gm.type) {
      case libgav1::kGlobalMotionTransformationTypeIdentity:
        v4l2_gm->type[i] = V4L2_AV1_WARP_MODEL_IDENTITY;
        break;
      case libgav1::kGlobalMotionTransformationTypeTranslation:
        v4l2_gm->type[i] = V4L2_AV1_WARP_MODEL_TRANSLATION;
        conditionally_set_flags(&v4l2_gm->flags[i], true,
                                V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION);
        break;
      case libgav1::kGlobalMotionTransformationTypeRotZoom:
        v4l2_gm->type[i] = V4L2_AV1_WARP_MODEL_ROTZOOM;
        conditionally_set_flags(&v4l2_gm->flags[i], true,
                                V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM);
        break;
      case libgav1::kGlobalMotionTransformationTypeAffine:
        v4l2_gm->type[i] = V4L2_AV1_WARP_MODEL_AFFINE;
        conditionally_set_flags(&v4l2_gm->flags[i], true,
                                V4L2_AV1_WARP_MODEL_AFFINE);
        break;
      default:
        NOTREACHED() << "Invalid global motion transformation type, "
                     << v4l2_gm->type[i];
    }

    conditionally_set_flags(
        &v4l2_gm->flags[i],
        gm.type != libgav1::kGlobalMotionTransformationTypeIdentity,
        V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL);

    constexpr auto kNumGlobalMotionParams = std::size(decltype(gm.params){});

    for (size_t j = 0; j < kNumGlobalMotionParams; ++j) {
      static_assert(
          std::is_same<decltype(v4l2_gm->params[0][0]), int32_t&>::value,
          "|v4l2_av1_global_motion::params|'s data type must be int32_t "
          "starting from AV1 uAPI v4");

      v4l2_gm->params[i][j] = gm.params[j];
    }

    conditionally_set_flags(&v4l2_gm->invalid, !libgav1::SetupShear(&gm),
                            V4L2_AV1_GLOBAL_MOTION_IS_INVALID(i));
  }
}

// Section 5.11. Tile Group OBU syntax
void FillTileGroupParams(
    std::vector<struct v4l2_ctrl_av1_tile_group_entry>*
        tile_group_entry_vectors,
    const base::span<const uint8_t> frame_obu_data,
    const libgav1::TileInfo& tile_info,
    const libgav1::Vector<libgav1::TileBuffer>& tile_buffers) {
  // TODO(stevecho): This could happen in rare cases (for example, if there is a
  // Metadata OBU after the TileGroup OBU). We currently do not have a reason to
  // handle those cases. This is also the case in libgav1 at the moment.
  CHECK(!tile_buffers.empty());
  const size_t tile_columns = tile_info.tile_columns;

  CHECK_GT(tile_columns, 0u);
  const uint16_t num_tiles = base::checked_cast<uint16_t>(tile_buffers.size());

  for (uint16_t tile_index = 0; tile_index < num_tiles; ++tile_index) {
    struct v4l2_ctrl_av1_tile_group_entry tile_group_entry_params = {};

    CHECK(tile_buffers[tile_index].data >= frame_obu_data.data());
    tile_group_entry_params.tile_offset = base::checked_cast<uint32_t>(
        tile_buffers[tile_index].data - frame_obu_data.data());

    tile_group_entry_params.tile_size = tile_buffers[tile_index].size;

    // The tiles are row-major. We use the number of columns |tile_columns|
    // to compute computation of the row and column for a given tile.
    tile_group_entry_params.tile_row =
        tile_index / base::checked_cast<uint16_t>(tile_columns);
    tile_group_entry_params.tile_col =
        tile_index % base::checked_cast<uint16_t>(tile_columns);

    tile_group_entry_vectors->push_back(tile_group_entry_params);
  }
}

}  // namespace

Av1Decoder::Av1Decoder(std::unique_ptr<IvfParser> ivf_parser,
                       std::unique_ptr<V4L2IoctlShim> v4l2_ioctl,
                       gfx::Size display_resolution)
    : VideoDecoder::VideoDecoder(std::move(v4l2_ioctl), display_resolution),
      ivf_parser_(std::move(ivf_parser)),
      buffer_pool_(std::make_unique<libgav1::BufferPool>(
          /*on_frame_buffer_size_changed=*/nullptr,
          /*get_frame_buffer=*/nullptr,
          /*release_frame_buffer=*/nullptr,
          /*callback_private_data=*/nullptr)),
      state_(std::make_unique<libgav1::DecoderState>()) {}

Av1Decoder::~Av1Decoder() {
  // We destroy the state explicitly to ensure it's destroyed before the
  // |buffer_pool_|. The |buffer_pool_| checks that all the allocated frames
  // are released in its destructor.
  state_.reset();
  DCHECK(buffer_pool_);
}

// static
std::unique_ptr<Av1Decoder> Av1Decoder::Create(
    const base::MemoryMappedFile& stream) {
  VLOG(2) << "Attempting to create decoder with codec "
          << media::FourccToString(kDriverCodecFourcc);

  // Set up video parser.
  auto ivf_parser = std::make_unique<media::IvfParser>();
  media::IvfFileHeader file_header{};

  if (!ivf_parser->Initialize(stream.data(), stream.length(), &file_header)) {
    LOG(ERROR) << "Couldn't initialize IVF parser";
    return nullptr;
  }

  const auto driver_codec_fourcc =
      media::v4l2_test::FileFourccToDriverFourcc(file_header.fourcc);

  if (driver_codec_fourcc != kDriverCodecFourcc) {
    VLOG(2) << "File fourcc (" << media::FourccToString(driver_codec_fourcc)
            << ") does not match expected fourcc("
            << media::FourccToString(kDriverCodecFourcc) << ").";
    return nullptr;
  }

  auto v4l2_ioctl = std::make_unique<V4L2IoctlShim>(kDriverCodecFourcc);

  const gfx::Size bitstream_coded_size = GetResolutionFromBitstream(stream);

  return base::WrapUnique(new Av1Decoder(
      std::move(ivf_parser), std::move(v4l2_ioctl), bitstream_coded_size));
}

Av1Decoder::ParsingResult Av1Decoder::ReadNextFrame(
    libgav1::RefCountedBufferPtr& current_frame) {
  if (!obu_parser_ || !obu_parser_->HasData()) {
    if (!ivf_parser_->ParseNextFrame(&ivf_frame_header_, &ivf_frame_data_))
      return ParsingResult::kEOStream;

    // The ObuParser has run out of data or did not exist in the first place. It
    // has no "replace the current buffer with a new buffer of a different size"
    // method; we must make a new parser.
    // (std::nothrow) is required for the base class Allocable of
    // libgav1::ObuParser
    obu_parser_ = base::WrapUnique(new (std::nothrow) libgav1::ObuParser(
        ivf_frame_data_, ivf_frame_header_.frame_size, /*operating_point=*/0,
        buffer_pool_.get(), state_.get()));
    if (current_sequence_header_)
      obu_parser_->set_sequence_header(*current_sequence_header_);
  }

  const libgav1::StatusCode code = obu_parser_->ParseOneFrame(&current_frame);
  if (code != libgav1::kStatusOk) {
    LOG(ERROR) << "Error parsing OBU stream: " << libgav1::GetErrorString(code);
    return ParsingResult::kFailed;
  }
  return ParsingResult::kOk;
}

void Av1Decoder::CopyFrameData(const libgav1::ObuFrameHeader& frame_hdr,
                               std::unique_ptr<V4L2Queue>& queue) {
  CHECK_EQ(queue->num_buffers(), 1u)
      << "Only 1 buffer is expected to be used for OUTPUT queue for now.";

  CHECK_EQ(queue->num_planes(), 1u)
      << "Number of planes is expected to be 1 for OUTPUT queue.";

  scoped_refptr<MmappedBuffer> buffer = queue->GetBuffer(0);

  buffer->mmapped_planes()[0].CopyIn(ivf_frame_data_,
                                     ivf_frame_header_.frame_size);
}

// 5.9.2. Uncompressed header syntax
void Av1Decoder::SetupFrameParams(
    struct v4l2_ctrl_av1_frame* v4l2_frame_params,
    const std::optional<libgav1::ObuSequenceHeader>& seq_header,
    const libgav1::ObuFrameHeader& frm_header) {
  FillLoopFilterParams(&v4l2_frame_params->loop_filter, frm_header.loop_filter);

  FillLoopFilterDeltaParams(&v4l2_frame_params->loop_filter,
                            frm_header.delta_lf);

  FillQuantizationParams(&v4l2_frame_params->quantization,
                         frm_header.quantizer);

  FillQuantizerIndexDeltaParams(&v4l2_frame_params->quantization, seq_header,
                                frm_header);

  FillSegmentationParams(&v4l2_frame_params->segmentation,
                         frm_header.segmentation);

  const auto color_bitdepth = seq_header->color_config.bitdepth;
  FillCdefParams(&v4l2_frame_params->cdef, frm_header.cdef,
                 base::strict_cast<int8_t>(color_bitdepth));

  FillLoopRestorationParams(&v4l2_frame_params->loop_restoration,
                            frm_header.loop_restoration);

  FillTileInfo(&v4l2_frame_params->tile_info, frm_header.tile_info);

  FillGlobalMotionParams(&v4l2_frame_params->global_motion,
                         frm_header.global_motion);

  conditionally_set_u32_flags(&v4l2_frame_params->flags, frm_header.show_frame,
                              V4L2_AV1_FRAME_FLAG_SHOW_FRAME);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.showable_frame,
                              V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.error_resilient_mode,
                              V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE);
  // libgav1 header has |enable_cdf_update| instead of |disable_cdf_update|.
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              !frm_header.enable_cdf_update,
                              V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.allow_screen_content_tools,
                              V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.force_integer_mv,
                              V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.allow_intrabc,
                              V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.use_superres,
                              V4L2_AV1_FRAME_FLAG_USE_SUPERRES);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.allow_high_precision_mv,
                              V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.is_motion_mode_switchable,
                              V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.use_ref_frame_mvs,
                              V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS);
  // libgav1 header has |enable_frame_end_update_cdf| instead.
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              !frm_header.enable_frame_end_update_cdf,
                              V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.allow_warped_motion,
                              V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.reference_mode_select,
                              V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.reduced_tx_set,
                              V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.skip_mode_frame[0] > 0,
                              V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.skip_mode_present,
                              V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.frame_size_override_flag,
                              V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE);
  // libgav1 header doesn't have |buffer_removal_time_present_flag|.
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.buffer_removal_time[0] > 0,
                              V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT);
  conditionally_set_u32_flags(&v4l2_frame_params->flags,
                              frm_header.frame_refs_short_signaling,
                              V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING);

  switch (frm_header.frame_type) {
    case libgav1::kFrameKey:
      v4l2_frame_params->frame_type = V4L2_AV1_KEY_FRAME;
      break;
    case libgav1::kFrameInter:
      v4l2_frame_params->frame_type = V4L2_AV1_INTER_FRAME;
      break;
    case libgav1::kFrameIntraOnly:
      v4l2_frame_params->frame_type = V4L2_AV1_INTRA_ONLY_FRAME;
      break;
    case libgav1::kFrameSwitch:
      v4l2_frame_params->frame_type = V4L2_AV1_SWITCH_FRAME;
      break;
    default:
      NOTREACHED() << "Invalid frame type, " << frm_header.frame_type;
  }

  v4l2_frame_params->order_hint = frm_header.order_hint;
  v4l2_frame_params->superres_denom = frm_header.superres_scale_denominator;
  v4l2_frame_params->upscaled_width = frm_header.upscaled_width;

  switch (frm_header.interpolation_filter) {
    case libgav1::kInterpolationFilterEightTap:
      v4l2_frame_params->interpolation_filter =
          V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP;
      break;
    case libgav1::kInterpolationFilterEightTapSmooth:
      v4l2_frame_params->interpolation_filter =
          V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH;
      break;
    case libgav1::kInterpolationFilterEightTapSharp:
      v4l2_frame_params->interpolation_filter =
          V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP;
      break;
    case libgav1::kInterpolationFilterBilinear:
      v4l2_frame_params->interpolation_filter =
          V4L2_AV1_INTERPOLATION_FILTER_BILINEAR;
      break;
    case libgav1::kInterpolationFilterSwitchable:
      v4l2_frame_params->interpolation_filter =
          V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE;
      break;
    default:
      NOTREACHED() << "Invalid interpolation filter, "
                   << frm_header.interpolation_filter;
  }

  switch (frm_header.tx_mode) {
    case libgav1::kTxModeOnly4x4:
      v4l2_frame_params->tx_mode = V4L2_AV1_TX_MODE_ONLY_4X4;
      break;
    case libgav1::kTxModeLargest:
      v4l2_frame_params->tx_mode = V4L2_AV1_TX_MODE_LARGEST;
      break;
    case libgav1::kTxModeSelect:
      v4l2_frame_params->tx_mode = V4L2_AV1_TX_MODE_SELECT;
      break;
    default:
      NOTREACHED() << "Invalid tx mode, " << frm_header.tx_mode;
  }

  v4l2_frame_params->frame_width_minus_1 = frm_header.width - 1;
  v4l2_frame_params->frame_height_minus_1 = frm_header.height - 1;
  v4l2_frame_params->render_width_minus_1 = frm_header.render_width - 1;
  v4l2_frame_params->render_height_minus_1 = frm_header.render_height - 1;

  v4l2_frame_params->current_frame_id = frm_header.current_frame_id;
  v4l2_frame_params->primary_ref_frame = frm_header.primary_reference_frame;
  SafeArrayMemcpy(v4l2_frame_params->buffer_removal_time,
                  frm_header.buffer_removal_time);
  v4l2_frame_params->refresh_frame_flags = frm_header.refresh_frame_flags;

  if (frm_header.frame_type == libgav1::kFrameKey && frm_header.show_frame) {
    for (size_t i = 0; i < libgav1::kNumReferenceFrameTypes; i++)
      ref_order_hint_[i] = 0;
  }

  // The first slot in |order_hints| is reserved for intra frame, so it is not
  // used and will always be 0.
  static_assert(std::size(decltype(v4l2_frame_params->order_hints){}) ==
                    libgav1::kNumInterReferenceFrameTypes + 1,
                "Invalid size of |order_hints| array");
  if (!libgav1::IsIntraFrame(frm_header.frame_type)) {
    for (size_t i = 0; i < libgav1::kNumInterReferenceFrameTypes; i++) {
      v4l2_frame_params->order_hints[i + 1] =
          ref_order_hint_[frm_header.reference_frame_index[i]];
    }
  }

  // TODO(b/230891887): use uint64_t when v4l2_timeval_to_ns() function is used.
  constexpr uint32_t kInvalidSurface = std::numeric_limits<uint32_t>::max();

  for (size_t i = 0; i < libgav1::kNumReferenceFrameTypes; ++i) {
    constexpr size_t kTimestampToNanoSecs = 1000;

    // |reference_frame_ts| is needed to use previously decoded frames
    // from reference frames list.
    const auto reference_frame_ts =
        ref_frames_[i] ? ref_frames_[i]->frame_number() * kTimestampToNanoSecs
                       : kInvalidSurface;

    v4l2_frame_params->reference_frame_ts[i] = reference_frame_ts;
  }

  static_assert(std::size(decltype(v4l2_frame_params->ref_frame_idx){}) ==
                    libgav1::kNumInterReferenceFrameTypes,
                "Invalid size of |ref_frame_idx| array");
  for (size_t i = 0; i < libgav1::kNumInterReferenceFrameTypes; i++) {
    static_assert(std::is_same<decltype(v4l2_frame_params->ref_frame_idx[0]),
                               int8_t&>::value,
                  "|v4l2_ctrl_av1_frame::ref_frame_idx|'s data type must be "
                  "int8_t starting from AV1 uAPI v4");

    v4l2_frame_params->ref_frame_idx[i] = frm_header.reference_frame_index[i];
  }

  v4l2_frame_params->skip_mode_frame[0] =
      base::checked_cast<__u8>(frm_header.skip_mode_frame[0]);
  v4l2_frame_params->skip_mode_frame[1] =
      base::checked_cast<__u8>(frm_header.skip_mode_frame[1]);
}

std::set<int> Av1Decoder::RefreshReferenceSlots(
    const libgav1::ObuFrameHeader& frame_hdr,
    const libgav1::RefCountedBufferPtr current_frame,
    const scoped_refptr<MmappedBuffer> buffer,
    const uint32_t last_queued_buffer_id) {
  state_->UpdateReferenceFrames(
      current_frame, base::strict_cast<int>(frame_hdr.refresh_frame_flags));

  static_assert(
      kAv1NumRefFrames == sizeof(frame_hdr.refresh_frame_flags) * CHAR_BIT,
      "|refresh_frame_flags| size must be equal to |kAv1NumRefFrames|");

  const std::bitset<kAv1NumRefFrames> refresh_frame_slots(
      frame_hdr.refresh_frame_flags);

  std::set<int> reusable_buffer_ids;

  constexpr uint8_t kRefreshFrameFlagsAll = 0xFF;
  // If |show_existing_frame| = 1 and the frame to show is a key frame, the
  // reference frame loading process as specified in section 7.21 of the AV1
  // spec is invoked.
  const bool is_show_existing_key_frame =
      (frame_hdr.show_existing_frame &&
       (state_->reference_frame[frame_hdr.frame_to_show]->frame_type() ==
        libgav1::kFrameKey));
  if (frame_hdr.refresh_frame_flags == kRefreshFrameFlagsAll ||
      is_show_existing_key_frame) {
    // After decoding a key frame, all CAPTURE buffers can be reused except the
    // CAPTURE buffer corresponding to the key frame.
    for (size_t i = 0; i < kNumberOfBuffersInCaptureQueue; i++)
      reusable_buffer_ids.insert(i);

    reusable_buffer_ids.erase(buffer->buffer_id());

    // Note that the CAPTURE buffer for previous frame can be used as well,
    // but it is already queued again at this point.
    reusable_buffer_ids.erase(last_queued_buffer_id);

    // Updates to assign current key frame as a reference frame for all
    // reference frame slots in the reference frames list.
    ref_frames_.fill(buffer);

    if (is_show_existing_key_frame) {
      for (size_t i = 0; i < libgav1::kNumReferenceFrameTypes; i++)
        ref_order_hint_[i] = ref_order_hint_[frame_hdr.frame_to_show];
    }

    return reusable_buffer_ids;
  }

  constexpr uint8_t kRefreshFrameFlagsNone = 0;
  if (frame_hdr.refresh_frame_flags == kRefreshFrameFlagsNone) {
    // Indicates to reuse currently decoded CAPTURE buffer.
    reusable_buffer_ids.insert(buffer->buffer_id());

    return reusable_buffer_ids;
  }

  // More than one slot in |refresh_frame_flags| can be set.
  for (size_t i = 0; i < kAv1NumRefFrames; i++) {
    if (!refresh_frame_slots[i])
      continue;

    // It is not required to check whether existing reference frame slot is
    // already pointing to a reference frame. This is because reference
    // frame slots are empty only after the first key frame decoding.
    const uint16_t reusable_candidate_buffer_id = ref_frames_[i]->buffer_id();
    reusable_buffer_ids.insert(reusable_candidate_buffer_id);

    // Checks to make sure |reusable_candidate_buffer_id| is not used in
    // different reference frame slots in the reference frames list. If
    // |reusable_candidate_buffer_id| is already being used, then it is no
    // longer qualified as a reusable buffer. Thus, it is removed from
    // |reusable_buffer_ids|.
    for (size_t j = 0; j < kAv1NumRefFrames; j++) {
      const bool is_refresh_slot_not_used = (refresh_frame_slots[j] == false);
      const bool is_candidate_used =
          (ref_frames_[j]->buffer_id() == reusable_candidate_buffer_id);

      if (is_refresh_slot_not_used && is_candidate_used) {
        reusable_buffer_ids.erase(reusable_candidate_buffer_id);
        break;
      }
    }
    ref_frames_[i] = buffer;
    ref_order_hint_[i] = frame_hdr.order_hint;
  }

  return reusable_buffer_ids;
}

void Av1Decoder::QueueReusableBuffersInCaptureQueue(
    const std::set<int> reusable_buffer_ids,
    const bool is_inter_frame) {
  for (const auto reusable_buffer_id : reusable_buffer_ids) {
    if (!v4l2_ioctl_->QBuf(CAPTURE_queue_, reusable_buffer_id))
      LOG(ERROR) << "VIDIOC_QBUF failed for CAPTURE queue.";

    if (is_inter_frame)
      CAPTURE_queue_->set_last_queued_buffer_id(reusable_buffer_id);
  }
}

VideoDecoder::Result Av1Decoder::DecodeNextFrame(const int frame_number,
                                                 std::vector<uint8_t>& y_plane,
                                                 std::vector<uint8_t>& u_plane,
                                                 std::vector<uint8_t>& v_plane,
                                                 gfx::Size& size,
                                                 BitDepth& bit_depth) {
  libgav1::RefCountedBufferPtr current_frame;
  const ParsingResult parser_res = ReadNextFrame(current_frame);

  if (parser_res != ParsingResult::kOk) {
    LOG_ASSERT(parser_res == ParsingResult::kEOStream)
        << "Failed to parse next frame.";
    return VideoDecoder::kEOStream;
  }

  const bool is_OUTPUT_queue_new = !OUTPUT_queue_;
  if (!OUTPUT_queue_) {
    CreateOUTPUTQueue(kDriverCodecFourcc);
  }

  libgav1::ObuFrameHeader current_frame_header = obu_parser_->frame_header();

  if (obu_parser_->sequence_header_changed())
    current_sequence_header_.emplace(obu_parser_->sequence_header());

  LOG_ASSERT(current_sequence_header_)
      << "Sequence header missing for decoding.";

  if (current_frame_header.show_existing_frame) {
    last_decoded_frame_visible_ = true;
  } else {
    last_decoded_frame_visible_ = current_frame_header.show_frame;
  }
  VLOG_IF(2, !last_decoded_frame_visible_) << "not displayed frame";

  for (size_t i = 0; i < kAv1NumRefFrames; ++i) {
    if (state_->reference_frame[i] != nullptr && ref_frames_[i] == nullptr) {
      LOG(FATAL) << "The state of the reference frames are different "
                    "between |ref_frames_| and |state_|";
    }
    if (state_->reference_frame[i] == nullptr && ref_frames_[i] != nullptr)
      ref_frames_[i].reset();
  }

  if (current_frame_header.show_existing_frame) {
    scoped_refptr<MmappedBuffer> repeated_frame_buffer =
        ref_frames_[current_frame_header.frame_to_show];

    bit_depth =
        ConvertToYUV(y_plane, u_plane, v_plane, OUTPUT_queue_->resolution(),
                     repeated_frame_buffer->mmapped_planes(),
                     CAPTURE_queue_->resolution(), CAPTURE_queue_->fourcc());

    // Repeated frames normally don't need to update reference frames. But in
    // this special case when the repeated frame is pointing to a key frame, all
    // the reference frames have to be updated to the key frame pointed by the
    // repeated frame.
    if (state_->reference_frame[current_frame_header.frame_to_show]
            ->frame_type() == libgav1::kFrameKey) {
      const std::set<int> reusable_buffer_ids =
          RefreshReferenceSlots(current_frame_header, current_frame,
                                ref_frames_[current_frame_header.frame_to_show],
                                CAPTURE_queue_->last_queued_buffer_id());

      QueueReusableBuffersInCaptureQueue(
          reusable_buffer_ids,
          !libgav1::IsIntraFrame(current_frame_header.frame_type));
    }

    return VideoDecoder::kOk;
  }

  CopyFrameData(current_frame_header, OUTPUT_queue_);

  LOG_ASSERT(OUTPUT_queue_->num_buffers() == 1)
      << "Too many buffers in OUTPUT queue. It is currently designed to "
         "support only 1 request at a time.";

  OUTPUT_queue_->GetBuffer(0)->set_frame_number(frame_number);

  if (!v4l2_ioctl_->QBuf(OUTPUT_queue_, 0))
    LOG(FATAL) << "VIDIOC_QBUF failed for OUTPUT queue.";

  std::vector<struct v4l2_ext_control> ext_ctrl_vectors;

  struct v4l2_ctrl_av1_sequence v4l2_seq_params = {};

  FillSequenceParams(&v4l2_seq_params, current_sequence_header_);

  ext_ctrl_vectors.push_back({.id = V4L2_CID_STATELESS_AV1_SEQUENCE,
                              .size = sizeof(v4l2_seq_params),
                              .ptr = &v4l2_seq_params});

  struct v4l2_ctrl_av1_frame v4l2_frame_params = {};

  SetupFrameParams(&v4l2_frame_params, current_sequence_header_,
                   current_frame_header);

  ext_ctrl_vectors.push_back({.id = V4L2_CID_STATELESS_AV1_FRAME,
                              .size = sizeof(v4l2_frame_params),
                              .ptr = &v4l2_frame_params});

  std::vector<struct v4l2_ctrl_av1_tile_group_entry> tile_group_entry_vectors;

  FillTileGroupParams(&tile_group_entry_vectors,
                      base::span(ivf_frame_data_, ivf_frame_header_.frame_size),
                      current_frame_header.tile_info,
                      obu_parser_->tile_buffers());

  ext_ctrl_vectors.push_back({.id = V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY,
                              .size = base::checked_cast<__u32>(
                                  tile_group_entry_vectors.size() *
                                  sizeof(v4l2_ctrl_av1_tile_group_entry)),
                              .ptr = &tile_group_entry_vectors[0]});

  struct v4l2_ext_controls ext_ctrls = {.count = base::checked_cast<__u32>(ext_ctrl_vectors.size()),
                                        .controls = &ext_ctrl_vectors[0]};

  // Before the CAPTURE queue is set up the first frame must be parsed by the
  // driver. This is done so that when VIDIOC_G_FMT is called the frame
  // dimensions and format will be ready. Specifying V4L2_CTRL_WHICH_CUR_VAL
  // when VIDIOC_S_EXT_CTRLS processes the request immediately so that the frame
  // is parsed by the driver and the state is readied.
  v4l2_ioctl_->SetExtCtrls(OUTPUT_queue_, &ext_ctrls, is_OUTPUT_queue_new);
  v4l2_ioctl_->MediaRequestIocQueue(OUTPUT_queue_);

  if (!CAPTURE_queue_) {
    CreateCAPTUREQueue(kNumberOfBuffersInCaptureQueue);
  }

  v4l2_ioctl_->WaitForRequestCompletion(OUTPUT_queue_);

  uint32_t buffer_id;
  v4l2_ioctl_->DQBuf(CAPTURE_queue_, &buffer_id);

  scoped_refptr<MmappedBuffer> buffer = CAPTURE_queue_->GetBuffer(buffer_id);
  bit_depth =
      ConvertToYUV(y_plane, u_plane, v_plane, OUTPUT_queue_->resolution(),
                   buffer->mmapped_planes(), CAPTURE_queue_->resolution(),
                   CAPTURE_queue_->fourcc());

  const std::set<int> reusable_buffer_ids = RefreshReferenceSlots(
      current_frame_header, current_frame, CAPTURE_queue_->GetBuffer(buffer_id),
      CAPTURE_queue_->last_queued_buffer_id());

  QueueReusableBuffersInCaptureQueue(
      reusable_buffer_ids,
      !libgav1::IsIntraFrame(current_frame_header.frame_type));

  v4l2_ioctl_->DQBuf(OUTPUT_queue_, &buffer_id);

  v4l2_ioctl_->MediaRequestIocReinit(OUTPUT_queue_);

  return VideoDecoder::kOk;
}

}  // namespace v4l2_test
}  // namespace media