// Copyright 2023 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/h264_rate_controller.h"

#include <array>
#include <memory>

#include "base/logging.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace media {
namespace {
constexpr uint32_t kCommonAvgBitrate = 1000000;   // bits per second
constexpr uint32_t kCommonPeakBitrate = 2000000;  // bits per second
constexpr int kCommonFps = 30;
constexpr int kCommonFpsMax = 30;
constexpr uint32_t kCommonFrameHeight = 600;
constexpr uint32_t kCommonFrameWidth = 800;
constexpr size_t kCommonHRDBufferSize = 40000;  // bytes
constexpr base::TimeDelta kCommonGopMaxDuration = base::Seconds(4);
constexpr uint32_t kCommonQpMax = 51u;
constexpr uint32_t kCommonQpMin = 1u;
constexpr size_t kLayer0Index = 0;
constexpr size_t kLayer1Index = 1;

// Test H264RateControllerTest executes various operations on the H264 Rate
// Controller component. A test sequence of predefined frames is filled into the
// rate controller and the controller state is compared with the expected
// values.
class H264RateControllerTest : public testing::Test {
 public:
  struct RateControllerTestValues {
    bool is_buffer_full;
    size_t buffer_size;
    size_t buffer_bytes;
    size_t buffer_bytes_remaining;
    size_t last_frame_buffer_bytes;
    float frame_rate_mean_min;
    float frame_rate_mean_max;
    size_t last_frame_size_target;
    int buffer_fullness;
  };

  H264RateControllerTest() = default;

  void SetUp() override {
    rate_controller_settings_.content_type =
        VideoEncodeAccelerator::Config::ContentType::kCamera;
    rate_controller_settings_.frame_size.SetSize(kCommonFrameWidth,
                                                 kCommonFrameHeight);
    rate_controller_settings_.num_temporal_layers = 1;
    rate_controller_settings_.gop_max_duration = kCommonGopMaxDuration;
    rate_controller_settings_.frame_rate_max = kCommonFpsMax;
    rate_controller_settings_.layer_settings.emplace_back();
    rate_controller_settings_.layer_settings[0].avg_bitrate = kCommonAvgBitrate;
    rate_controller_settings_.layer_settings[0].hrd_buffer_size =
        kCommonHRDBufferSize;
    rate_controller_settings_.layer_settings[0].min_qp = kCommonQpMin;
    rate_controller_settings_.layer_settings[0].max_qp = kCommonQpMax;
    rate_controller_settings_.layer_settings[0].frame_rate = kCommonFps;

    // Copy operation test
    H264RateControllerSettings rate_controller_settings_copy =
        rate_controller_settings_;
    rate_controller_settings_ = rate_controller_settings_copy;
  }

 protected:
  // Runs a loop of predefined encoded frames. The default frame sequence
  // contains two intra frames at the beginning and in the middle of the
  // sequence. There are custom test sequences provided (identified by
  // `test_sequence_number`) which are used to set the Rate Controller into
  // specific state during QP estimation. In each cycle the following methods
  // are executed on the rate controller:
  // 1. ShrinkHRDBuffers()
  // 2. EstimateIntraFrameQP() or EstimateInterFrameQP()
  // 3. FinishIntraFrame() or FinishInterFrame()
  int RunTestSequence(uint32_t avg_bitrate,
                      int fps,
                      int frame_count,
                      size_t num_temporal_layers,
                      int test_sequence_number,
                      int start_frame_index,
                      int& last_intra_frame_qp,
                      int& last_inter_frame_qp) {
    constexpr size_t kFirstIntraFrameIndex = 0;
    const size_t kSecondIntraFrameIndex = frame_count / 2;
    size_t frame_size = avg_bitrate / 8 / fps;
    std::vector<size_t> frames;
    // Two temporal layers test.
    std::vector<size_t> custom_frames_1{12500, 3000,  4000, 3000, 4000,
                                        15000, 13000, 2500, 3700, 3200,
                                        3500,  3000,  3500, 3000, 2000};
    // Two temporal layers test with Fixed Delta QP mode enabled.
    std::vector<size_t> custom_frames_2{12500, 3000, 4000, 3000, 4000, 15000,
                                        13000, 2500, 3700, 3200, 0,    0};
    for (int i = 0; i < frame_count; ++i) {
      if (test_sequence_number == 1) {
        if (i < 14) {
          frames.push_back(custom_frames_1[i]);
        } else {
          frames.push_back(custom_frames_1[14]);
        }
      } else if (test_sequence_number == 2) {
        if (i < 10) {
          frames.push_back(custom_frames_2[i]);
        } else {
          frames.push_back(custom_frames_2[10]);
        }
      } else if (test_sequence_number == 3) {
        frames.push_back(0);
      } else {
        frames.push_back(frame_size);
      }
    }

    if (test_sequence_number <= 0) {
      frames[kFirstIntraFrameIndex] = frames[kFirstIntraFrameIndex] * 3;
      frames[kSecondIntraFrameIndex] = frames[kSecondIntraFrameIndex] * 3;
    }

    base::TimeDelta timestamp = base::Microseconds(
        start_frame_index * base::Time::kMicrosecondsPerSecond / fps);
    size_t layer_index = 0;
    size_t frame_index = 0;
    for (size_t encoded_size : frames) {
      if (num_temporal_layers > 1) {
        if (frame_index == kFirstIntraFrameIndex ||
            (test_sequence_number <= 0 &&
             frame_index == kSecondIntraFrameIndex) ||
            layer_index == 1) {
          layer_index = 0;
        } else {
          layer_index = 1;
        }
      }

      for (size_t i = 0; i < num_temporal_layers; ++i) {
        rate_controller_->temporal_layers(i).ShrinkHRDBuffer(timestamp);
      }

      if (frame_index == kFirstIntraFrameIndex ||
          (test_sequence_number <= 0 &&
           frame_index == kSecondIntraFrameIndex)) {
        rate_controller_->EstimateIntraFrameQP(timestamp);
        last_intra_frame_qp =
            rate_controller_->temporal_layers(layer_index).curr_frame_qp();
        rate_controller_->FinishIntraFrame(encoded_size, timestamp);
      } else {
        rate_controller_->EstimateInterFrameQP(layer_index, timestamp);
        last_inter_frame_qp =
            rate_controller_->temporal_layers(layer_index).curr_frame_qp();
        rate_controller_->FinishInterFrame(layer_index, encoded_size,
                                           timestamp);
      }

      ++frame_index;
      timestamp += base::Microseconds(base::Time::kMicrosecondsPerSecond / fps);
    }

    return start_frame_index + frame_count;
  }

  std::unique_ptr<H264RateController> rate_controller_;
  H264RateControllerSettings rate_controller_settings_;
};

// Test Cases

// The test runs a predefined sequence of frame sizes and checks the Rate
// Controller status after running the sequence.
TEST_F(H264RateControllerTest, RunH264RateController1TemporalLayerTest) {
  constexpr size_t kTestSequenceFrameCount = 30;
  constexpr RateControllerTestValues kExpectedValues1 = {
      false, 40000, 0, 40000, 0, 29.9f, 30.1f, 0, 0};
  constexpr RateControllerTestValues kExpectedValues2 = {
      false, 40000, 16633, 23367, 20801, 29.9f, 30.1f, 4104, 41};
  constexpr int kExpectedIntraFrameQP2 = 34;
  constexpr int kExpectedInterFrameQP2 = 36;

  rate_controller_ =
      std::make_unique<H264RateController>(rate_controller_settings_);

  rate_controller_->reset_frame_number();

  std::array<int, 1> buffer_fullness_array = {0};
  base::span<int> buffer_fullness_values(buffer_fullness_array);

  EXPECT_EQ(kExpectedValues1.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(base::TimeDelta()));
  EXPECT_EQ(kExpectedValues1.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(base::TimeDelta()));
  EXPECT_LT(kExpectedValues1.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValues1.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValues1.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValues1.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValues1.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValues1.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values,
                                         base::TimeDelta());
  EXPECT_EQ(kExpectedValues1.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);

  int start_frame_index = 0;
  int last_intra_frame_qp;
  int last_inter_frame_qp;
  int last_frame_index = RunTestSequence(
      kCommonAvgBitrate, kCommonFps, kTestSequenceFrameCount,
      rate_controller_settings_.num_temporal_layers, 0, start_frame_index,
      last_intra_frame_qp, last_inter_frame_qp);
  base::TimeDelta timestamp = base::Microseconds(
      last_frame_index * base::Time::kMicrosecondsPerSecond / kCommonFps);

  EXPECT_EQ(kExpectedIntraFrameQP2, last_intra_frame_qp);
  EXPECT_EQ(kExpectedInterFrameQP2, last_inter_frame_qp);

  EXPECT_EQ(kExpectedValues2.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValues2.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValues2.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValues2.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValues2.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValues2.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValues2.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValues2.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValues2.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);
}

TEST_F(H264RateControllerTest, RunH264RateController2TemporalLayersTest) {
  constexpr size_t kTestSequenceFrameCount = 30;
  constexpr RateControllerTestValues kExpectedValuesLayer01 = {
      false, 26666, 0, 26666, 0, 29.9f, 30.1f, 0, 0};
  constexpr RateControllerTestValues kExpectedValuesLayer11 = {
      false, 40000, 0, 40000, 0, 29.9f, 30.1f, 0, 0};
  constexpr RateControllerTestValues kExpectedValuesLayer02 = {
      false, 26666, 1387, 25279, 4166, 15.0f, 15.1f, 6344, 5};
  constexpr RateControllerTestValues kExpectedValuesLayer12 = {
      false, 40000, 16633, 23367, 20801, 15.0f, 15.1f, 3214, 41};
  constexpr int kExpectedIntraFrameQP2 = 34;
  constexpr int kExpectedInterFrameQP2 = 29;
  constexpr RateControllerTestValues kExpectedValuesLayer03 = {
      false, 26666, 0, 26666, 2000, 15.0f, 15.1f, 8011, 0};
  constexpr RateControllerTestValues kExpectedValuesLayer13 = {
      false, 40000, 522, 39478, 4690, 15.0f, 15.1f, 4821, 1};
  constexpr int kExpectedIntraFrameQP3 = 34;
  constexpr int kExpectedInterFrameQP3 = 44;

  rate_controller_settings_.num_temporal_layers = 2;
  rate_controller_settings_.layer_settings[0].avg_bitrate =
      kCommonAvgBitrate * 2 / 3;
  rate_controller_settings_.layer_settings[0].hrd_buffer_size =
      kCommonHRDBufferSize * 2 / 3;
  rate_controller_settings_.layer_settings[0].frame_rate = kCommonFps / 2;
  rate_controller_settings_.layer_settings.emplace_back();
  rate_controller_settings_.layer_settings[1].avg_bitrate = kCommonAvgBitrate;
  rate_controller_settings_.layer_settings[1].hrd_buffer_size =
      kCommonHRDBufferSize;
  rate_controller_settings_.layer_settings[1].min_qp = kCommonQpMin;
  rate_controller_settings_.layer_settings[1].max_qp = kCommonQpMax;
  rate_controller_settings_.layer_settings[1].frame_rate = kCommonFps;

  rate_controller_ =
      std::make_unique<H264RateController>(rate_controller_settings_);

  std::array<int, 2> buffer_fullness_array = {0, 0};
  base::span<int> buffer_fullness_values(buffer_fullness_array);

  EXPECT_EQ(kExpectedValuesLayer01.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(base::TimeDelta()));
  EXPECT_EQ(kExpectedValuesLayer01.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(base::TimeDelta()));
  EXPECT_LT(kExpectedValuesLayer01.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer01.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer01.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer01.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer01.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer01.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values,
                                         base::TimeDelta());
  EXPECT_EQ(kExpectedValuesLayer01.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);
  EXPECT_EQ(kExpectedValuesLayer11.buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesAtTime(base::TimeDelta()));
  EXPECT_EQ(kExpectedValuesLayer11.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesRemainingAtTime(base::TimeDelta()));
  EXPECT_LT(kExpectedValuesLayer11.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer11.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer11.is_buffer_full,
            rate_controller_->temporal_layers(kLayer1Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer11.buffer_size,
            rate_controller_->temporal_layers(kLayer1Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer11.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer11.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values,
                                         base::TimeDelta());
  EXPECT_EQ(kExpectedValuesLayer11.buffer_fullness,
            buffer_fullness_values[kLayer1Index]);

  int start_frame_index = 0;
  int last_intra_frame_qp;
  int last_inter_frame_qp;
  int last_frame_index = RunTestSequence(
      kCommonAvgBitrate, kCommonFps, kTestSequenceFrameCount,
      rate_controller_settings_.num_temporal_layers, 0, start_frame_index,
      last_intra_frame_qp, last_inter_frame_qp);
  base::TimeDelta timestamp = base::Microseconds(
      last_frame_index * base::Time::kMicrosecondsPerSecond / kCommonFps);

  EXPECT_EQ(kExpectedIntraFrameQP2, last_intra_frame_qp);
  EXPECT_EQ(kExpectedInterFrameQP2, last_inter_frame_qp);

  EXPECT_EQ(kExpectedValuesLayer02.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer02.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer02.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer02.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer02.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer02.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer02.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer02.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer02.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);
  EXPECT_EQ(kExpectedValuesLayer12.buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer12.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer12.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer12.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer12.is_buffer_full,
            rate_controller_->temporal_layers(kLayer1Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer12.buffer_size,
            rate_controller_->temporal_layers(kLayer1Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer12.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer12.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer12.buffer_fullness,
            buffer_fullness_values[kLayer1Index]);

  // Run test sequence 1
  // The following use cases are tested:
  //   1. Start Limit Base QP procedure in ClipInterFrameQP(). The buffer size
  //      gradually decreases and the Limit Base QP is turned off when the
  //      buffer fullness of the enhanced layer reaches 35%.
  //   2. Adjusting the min_qp value in ClipInterFrameQP() method when the
  //      buffer reaches full capacity.
  //   3. Setting the overshooting timestamp and increasing min_qp and max_qp in
  //      ClipInterFrameQP().
  //   4. The QP is set to maximum value when the buffer is full in
  //      EstimateInterFrameQP() method.
  start_frame_index = last_frame_index;
  last_frame_index = RunTestSequence(
      kCommonAvgBitrate, kCommonFps, kTestSequenceFrameCount,
      rate_controller_settings_.num_temporal_layers, 1, start_frame_index,
      last_intra_frame_qp, last_inter_frame_qp);
  timestamp = base::Microseconds(
      last_frame_index * base::Time::kMicrosecondsPerSecond / kCommonFps);

  EXPECT_EQ(kExpectedIntraFrameQP3, last_intra_frame_qp);
  EXPECT_EQ(kExpectedInterFrameQP3, last_inter_frame_qp);

  EXPECT_EQ(kExpectedValuesLayer03.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer03.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer03.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer03.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer03.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer03.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer03.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer03.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer03.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);
  EXPECT_EQ(kExpectedValuesLayer13.buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer13.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer13.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer13.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer13.is_buffer_full,
            rate_controller_->temporal_layers(kLayer1Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer13.buffer_size,
            rate_controller_->temporal_layers(kLayer1Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer13.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer13.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer13.buffer_fullness,
            buffer_fullness_values[kLayer1Index]);
}

TEST_F(H264RateControllerTest,
       RunH264RateController2TemporalLayersFixedDeltaQPTest) {
  constexpr size_t kTestSequenceFrameCount = 30;
  constexpr uint32_t kQpMin = 25;
  constexpr RateControllerTestValues kExpectedValuesLayer01 = {
      false, 26666, 0, 26666, 0, 29.9f, 30.1f, 0, 0};
  constexpr RateControllerTestValues kExpectedValuesLayer11 = {
      false, 40000, 0, 40000, 0, 29.9f, 30.1f, 0, 0};
  constexpr int kExpectedIntraFrameQP2 = 28;
  constexpr int kExpectedInterFrameQP2 = 30;
  constexpr RateControllerTestValues kExpectedValuesLayer02 = {
      false, 26666, 1387, 25279, 4166, 15.0f, 15.1f, 3790, 5};
  constexpr RateControllerTestValues kExpectedValuesLayer12 = {
      false, 40000, 16633, 23367, 20801, 15.0f, 15.1f, 0, 41};
  constexpr int kExpectedIntraFrameQP3 = 39;
  constexpr int kExpectedInterFrameQP3 = 25;
  constexpr RateControllerTestValues kExpectedValuesLayer03 = {
      false, 26666, 0, 26666, 0, 15.0f, 15.1f, 8007, 0};
  constexpr RateControllerTestValues kExpectedValuesLayer13 = {
      false, 40000, 0, 40000, 0, 15.0f, 15.1f, 1333, 0};

  rate_controller_settings_.content_type =
      VideoEncodeAccelerator::Config::ContentType::kDisplay;
  rate_controller_settings_.fixed_delta_qp = 0;
  rate_controller_settings_.num_temporal_layers = 2;
  rate_controller_settings_.layer_settings[0].avg_bitrate =
      kCommonAvgBitrate * 2 / 3;
  rate_controller_settings_.layer_settings[0].hrd_buffer_size =
      kCommonHRDBufferSize * 2 / 3;
  rate_controller_settings_.layer_settings[0].min_qp = kQpMin;
  rate_controller_settings_.layer_settings[0].frame_rate = kCommonFps / 2;
  rate_controller_settings_.layer_settings.emplace_back();
  rate_controller_settings_.layer_settings[1].avg_bitrate = kCommonAvgBitrate;
  rate_controller_settings_.layer_settings[1].hrd_buffer_size =
      kCommonHRDBufferSize;
  rate_controller_settings_.layer_settings[1].min_qp = kQpMin;
  rate_controller_settings_.layer_settings[1].max_qp = kCommonQpMax;
  rate_controller_settings_.layer_settings[1].frame_rate = kCommonFps;

  rate_controller_ =
      std::make_unique<H264RateController>(rate_controller_settings_);

  std::array<int, 2> buffer_fullness_array = {0, 0};
  base::span<int> buffer_fullness_values(buffer_fullness_array);

  EXPECT_EQ(kExpectedValuesLayer01.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(base::TimeDelta()));
  EXPECT_EQ(kExpectedValuesLayer01.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(base::TimeDelta()));
  EXPECT_LT(kExpectedValuesLayer01.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer01.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer01.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer01.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer01.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer01.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values,
                                         base::TimeDelta());
  EXPECT_EQ(kExpectedValuesLayer01.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);
  EXPECT_EQ(kExpectedValuesLayer11.buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesAtTime(base::TimeDelta()));
  EXPECT_EQ(kExpectedValuesLayer11.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesRemainingAtTime(base::TimeDelta()));
  EXPECT_LT(kExpectedValuesLayer11.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer11.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer11.is_buffer_full,
            rate_controller_->temporal_layers(kLayer1Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer11.buffer_size,
            rate_controller_->temporal_layers(kLayer1Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer11.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer11.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values,
                                         base::TimeDelta());
  EXPECT_EQ(kExpectedValuesLayer11.buffer_fullness,
            buffer_fullness_values[kLayer1Index]);

  int start_frame_index = 0;
  int last_intra_frame_qp;
  int last_inter_frame_qp;
  int last_frame_index = RunTestSequence(
      kCommonAvgBitrate, kCommonFps, kTestSequenceFrameCount,
      rate_controller_settings_.num_temporal_layers, 0, start_frame_index,
      last_intra_frame_qp, last_inter_frame_qp);
  base::TimeDelta timestamp = base::Microseconds(
      last_frame_index * base::Time::kMicrosecondsPerSecond / kCommonFps);

  EXPECT_EQ(kExpectedIntraFrameQP2, last_intra_frame_qp);
  EXPECT_EQ(kExpectedInterFrameQP2, last_inter_frame_qp);

  EXPECT_EQ(kExpectedValuesLayer02.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer02.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer02.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer02.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer02.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer02.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer02.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer02.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer02.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);
  EXPECT_EQ(kExpectedValuesLayer12.buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer12.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer12.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer12.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer12.is_buffer_full,
            rate_controller_->temporal_layers(kLayer1Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer12.buffer_size,
            rate_controller_->temporal_layers(kLayer1Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer12.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer12.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer12.buffer_fullness,
            buffer_fullness_values[kLayer1Index]);

  // Run test sequences 2 and 3
  // The following use cases are tested:
  //   1. The QP difference between enhanced and base layers is more than 4.
  //      This indicates the HRD overflow and the min_qp is increased. The
  //      ClipInterFrameQP() method handles this scenario.
  //   2. The test sequence triggers the setting of undershoot_delta_qp. Under
  //      this condition, the QP for the enhanced layer is reduced by the
  //      undershoot value within the EstimateInterFrameQP() method.
  start_frame_index = last_frame_index;
  last_frame_index = RunTestSequence(
      kCommonAvgBitrate, kCommonFps, kTestSequenceFrameCount,
      rate_controller_settings_.num_temporal_layers, 2, start_frame_index,
      last_intra_frame_qp, last_inter_frame_qp);
  timestamp = base::Microseconds(
      last_frame_index * base::Time::kMicrosecondsPerSecond / kCommonFps);

  start_frame_index = last_frame_index;
  last_frame_index = RunTestSequence(
      kCommonAvgBitrate, kCommonFps, kTestSequenceFrameCount,
      rate_controller_settings_.num_temporal_layers, 3, start_frame_index,
      last_intra_frame_qp, last_inter_frame_qp);
  timestamp = base::Microseconds(
      last_frame_index * base::Time::kMicrosecondsPerSecond / kCommonFps);

  EXPECT_EQ(kExpectedIntraFrameQP3, last_intra_frame_qp);
  EXPECT_EQ(kExpectedInterFrameQP3, last_inter_frame_qp);

  EXPECT_EQ(kExpectedValuesLayer03.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer03.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer03.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer03.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer03.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer03.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer03.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer03.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer03.buffer_fullness,
            buffer_fullness_values[kLayer0Index]);
  EXPECT_EQ(kExpectedValuesLayer13.buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValuesLayer13.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer1Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_LT(kExpectedValuesLayer13.frame_rate_mean_min,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_GT(kExpectedValuesLayer13.frame_rate_mean_max,
            rate_controller_->temporal_layers(kLayer1Index).GetFrameRateMean());
  EXPECT_EQ(kExpectedValuesLayer13.is_buffer_full,
            rate_controller_->temporal_layers(kLayer1Index).is_buffer_full());
  EXPECT_EQ(kExpectedValuesLayer13.buffer_size,
            rate_controller_->temporal_layers(kLayer1Index).buffer_size());
  EXPECT_EQ(kExpectedValuesLayer13.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_buffer_bytes());
  EXPECT_EQ(kExpectedValuesLayer13.last_frame_size_target,
            rate_controller_->temporal_layers(kLayer1Index)
                .last_frame_size_target_for_testing());
  rate_controller_->GetHRDBufferFullness(buffer_fullness_values, timestamp);
  EXPECT_EQ(kExpectedValuesLayer13.buffer_fullness,
            buffer_fullness_values[kLayer1Index]);
}

TEST_F(H264RateControllerTest, RunH264RateControllerFramerateMeanTest) {
  constexpr auto kFrameRateExpectedValues =
      std::to_array<float>({29.9f, 30.1f});

  rate_controller_ =
      std::make_unique<H264RateController>(rate_controller_settings_);

  size_t frame_size = kCommonAvgBitrate / 8 / kCommonFps;
  base::TimeDelta timestamp;

  rate_controller_->temporal_layers(kLayer0Index).AddFrameTimestamp(timestamp);
  rate_controller_->temporal_layers(kLayer0Index)
      .AddFrameBytes(frame_size, timestamp);

  timestamp +=
      base::Microseconds(base::Time::kMicrosecondsPerSecond / kCommonFps);

  rate_controller_->temporal_layers(kLayer0Index).AddFrameTimestamp(timestamp);
  rate_controller_->temporal_layers(kLayer0Index)
      .AddFrameBytes(frame_size, timestamp);

  EXPECT_LT(kFrameRateExpectedValues[0],
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kFrameRateExpectedValues[1],
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());

  timestamp += base::Microseconds(100);

  rate_controller_->temporal_layers(kLayer0Index).AddFrameTimestamp(timestamp);
  rate_controller_->temporal_layers(kLayer0Index)
      .AddFrameBytes(frame_size, timestamp);

  timestamp += base::Microseconds(100);

  rate_controller_->temporal_layers(kLayer0Index).AddFrameTimestamp(timestamp);
  rate_controller_->temporal_layers(kLayer0Index)
      .AddFrameBytes(frame_size, timestamp);

  EXPECT_LT(kFrameRateExpectedValues[0],
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
  EXPECT_GT(kFrameRateExpectedValues[1],
            rate_controller_->temporal_layers(kLayer0Index).GetFrameRateMean());
}

TEST_F(H264RateControllerTest, RunH264RateControllerSetBufferParametersTest) {
  constexpr RateControllerTestValues kExpectedValues = {
      false, 80000, 4166, 75834, 4166, 0.0f, 0.0f, 0, 0};

  rate_controller_ =
      std::make_unique<H264RateController>(rate_controller_settings_);

  size_t frame_size = kCommonAvgBitrate / 8 / kCommonFps;
  base::TimeDelta timestamp;

  rate_controller_->temporal_layers(kLayer0Index).AddFrameTimestamp(timestamp);
  rate_controller_->temporal_layers(kLayer0Index)
      .AddFrameBytes(frame_size, timestamp);

  timestamp +=
      base::Microseconds(base::Time::kMicrosecondsPerSecond / kCommonFps);

  rate_controller_->temporal_layers(kLayer0Index)
      .SetBufferParameters(kCommonHRDBufferSize * 2, kCommonAvgBitrate * 2,
                           kCommonPeakBitrate * 2, false);

  rate_controller_->temporal_layers(0).AddFrameTimestamp(timestamp);
  rate_controller_->temporal_layers(0).AddFrameBytes(frame_size, timestamp);

  EXPECT_EQ(kExpectedValues.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValues.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_EQ(kExpectedValues.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValues.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValues.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
}

// The test verifies the following conditions:
// 1. The first intra encoded frame fills up the buffer more than 50%. This is
//    handled in FinishIntraFrame() method.
// 2. QP adjustment in EstimateIntraFrameQP() method when the previous encoded
//    frame is an intra frame.
// 3. Modifying QP value in EstimateIntraFrameQP() method when the buffer is
//    full.
TEST_F(H264RateControllerTest, RunH264RateControllerIntraEncodedFrameTest) {
  constexpr RateControllerTestValues kExpectedValues = {
      true, 40000, 53499, 0, 53499, 0.0f, 0.0f, 0, 0};
  constexpr float kExpectedTargetFpsMin = 4.9f;
  constexpr float kExpectedTargetFpsMax = 5.1f;

  rate_controller_ =
      std::make_unique<H264RateController>(rate_controller_settings_);

  size_t kFrameSize1 = 21000;
  size_t kFrameSize2 = 25000;
  size_t kFrameSize3 = 10000;
  size_t kFrameSize4 = 10000;
  base::TimeDelta timestamp;

  rate_controller_->UpdateFrameSize(gfx::Size(1920, 1080));

  rate_controller_->EstimateIntraFrameQP(timestamp);

  rate_controller_->FinishIntraFrame(kFrameSize1, timestamp);

  timestamp +=
      base::Microseconds(base::Time::kMicrosecondsPerSecond / kCommonFps);

  rate_controller_->UpdateFrameSize(gfx::Size(1280, 720));

  rate_controller_->EstimateIntraFrameQP(timestamp);

  rate_controller_->FinishIntraFrame(kFrameSize2, timestamp);

  timestamp +=
      base::Microseconds(base::Time::kMicrosecondsPerSecond / kCommonFps);

  rate_controller_->UpdateFrameSize(gfx::Size(1920, 1080));

  rate_controller_->EstimateIntraFrameQP(timestamp);

  rate_controller_->FinishIntraFrame(kFrameSize3, timestamp);

  timestamp +=
      base::Microseconds(base::Time::kMicrosecondsPerSecond / kCommonFps);

  rate_controller_->EstimateIntraFrameQP(timestamp);

  rate_controller_->FinishIntraFrame(kFrameSize4, timestamp);

  EXPECT_EQ(kExpectedValues.buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesAtTime(timestamp));
  EXPECT_EQ(kExpectedValues.buffer_bytes_remaining,
            rate_controller_->temporal_layers(kLayer0Index)
                .GetBufferBytesRemainingAtTime(timestamp));
  EXPECT_EQ(kExpectedValues.is_buffer_full,
            rate_controller_->temporal_layers(kLayer0Index).is_buffer_full());
  EXPECT_EQ(kExpectedValues.buffer_size,
            rate_controller_->temporal_layers(kLayer0Index).buffer_size());
  EXPECT_EQ(kExpectedValues.last_frame_buffer_bytes,
            rate_controller_->temporal_layers(kLayer0Index)
                .last_frame_buffer_bytes());
  EXPECT_LT(kExpectedTargetFpsMin, rate_controller_->target_fps_for_testing());
  EXPECT_GT(kExpectedTargetFpsMax, rate_controller_->target_fps_for_testing());
}
}  // namespace

}  // namespace media