/*
 *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "modules/video_coding/codecs/test/videoprocessor_integrationtest.h"

#include <algorithm>
#include <utility>

#if defined(WEBRTC_ANDROID)
#include "modules/video_coding/codecs/test/android_test_initializer.h"
#include "sdk/android/src/jni/class_loader.h"
#include "sdk/android/src/jni/videodecoderfactorywrapper.h"
#include "sdk/android/src/jni/videoencoderfactorywrapper.h"
#elif defined(WEBRTC_IOS)
#include "modules/video_coding/codecs/test/objc_codec_h264_test.h"
#endif

#include "common_types.h"  // NOLINT(build/include)
#include "media/base/h264_profile_level_id.h"
#include "media/engine/internaldecoderfactory.h"
#include "media/engine/internalencoderfactory.h"
#include "media/engine/videodecodersoftwarefallbackwrapper.h"
#include "media/engine/videoencodersoftwarefallbackwrapper.h"
#include "modules/video_coding/codecs/vp8/include/vp8_common_types.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "modules/video_coding/include/video_coding.h"
#include "rtc_base/checks.h"
#include "rtc_base/cpu_time.h"
#include "rtc_base/event.h"
#include "rtc_base/file.h"
#include "rtc_base/ptr_util.h"
#include "system_wrappers/include/sleep.h"
#include "test/statistics.h"
#include "test/testsupport/fileutils.h"
#include "test/testsupport/metrics/video_metrics.h"

namespace webrtc {
namespace test {

namespace {

const int kRtpClockRateHz = 90000;

const int kMaxBitrateMismatchPercent = 20;

bool RunEncodeInRealTime(const TestConfig& config) {
  if (config.measure_cpu) {
    return true;
  }
#if defined(WEBRTC_ANDROID)
  // In order to not overwhelm the OpenMAX buffers in the Android MediaCodec.
  return (config.hw_encoder || config.hw_decoder);
#else
  return false;
#endif
}

SdpVideoFormat CreateSdpVideoFormat(const TestConfig& config) {
  switch (config.codec_settings.codecType) {
    case kVideoCodecVP8:
      return SdpVideoFormat(cricket::kVp8CodecName);

    case kVideoCodecVP9:
      return SdpVideoFormat(cricket::kVp9CodecName);

    case kVideoCodecH264: {
      const char* packetization_mode =
          config.h264_codec_settings.packetization_mode ==
                  H264PacketizationMode::NonInterleaved
              ? "1"
              : "0";
      return SdpVideoFormat(
          cricket::kH264CodecName,
          {{cricket::kH264FmtpProfileLevelId,
            *H264::ProfileLevelIdToString(H264::ProfileLevelId(
                config.h264_codec_settings.profile, H264::kLevel3_1))},
           {cricket::kH264FmtpPacketizationMode, packetization_mode}});
    }
    default:
      RTC_NOTREACHED();
      return SdpVideoFormat("");
  }
}

}  // namespace

void VideoProcessorIntegrationTest::H264KeyframeChecker::CheckEncodedFrame(
    webrtc::VideoCodecType codec,
    const EncodedImage& encoded_frame) const {
  EXPECT_EQ(kVideoCodecH264, codec);
  bool contains_sps = false;
  bool contains_pps = false;
  bool contains_idr = false;
  const std::vector<webrtc::H264::NaluIndex> nalu_indices =
      webrtc::H264::FindNaluIndices(encoded_frame._buffer,
                                    encoded_frame._length);
  for (const webrtc::H264::NaluIndex& index : nalu_indices) {
    webrtc::H264::NaluType nalu_type = webrtc::H264::ParseNaluType(
        encoded_frame._buffer[index.payload_start_offset]);
    if (nalu_type == webrtc::H264::NaluType::kSps) {
      contains_sps = true;
    } else if (nalu_type == webrtc::H264::NaluType::kPps) {
      contains_pps = true;
    } else if (nalu_type == webrtc::H264::NaluType::kIdr) {
      contains_idr = true;
    }
  }
  if (encoded_frame._frameType == kVideoFrameKey) {
    EXPECT_TRUE(contains_sps) << "Keyframe should contain SPS.";
    EXPECT_TRUE(contains_pps) << "Keyframe should contain PPS.";
    EXPECT_TRUE(contains_idr) << "Keyframe should contain IDR.";
  } else if (encoded_frame._frameType == kVideoFrameDelta) {
    EXPECT_FALSE(contains_sps) << "Delta frame should not contain SPS.";
    EXPECT_FALSE(contains_pps) << "Delta frame should not contain PPS.";
    EXPECT_FALSE(contains_idr) << "Delta frame should not contain IDR.";
  } else {
    RTC_NOTREACHED();
  }
}

class VideoProcessorIntegrationTest::CpuProcessTime final {
 public:
  explicit CpuProcessTime(const TestConfig& config) : config_(config) {}
  ~CpuProcessTime() {}

  void Start() {
    if (config_.measure_cpu) {
      cpu_time_ -= rtc::GetProcessCpuTimeNanos();
      wallclock_time_ -= rtc::SystemTimeNanos();
    }
  }
  void Stop() {
    if (config_.measure_cpu) {
      cpu_time_ += rtc::GetProcessCpuTimeNanos();
      wallclock_time_ += rtc::SystemTimeNanos();
    }
  }
  void Print() const {
    if (config_.measure_cpu) {
      printf("CPU usage %%: %f\n", GetUsagePercent() / config_.NumberOfCores());
      printf("\n");
    }
  }

 private:
  double GetUsagePercent() const {
    return static_cast<double>(cpu_time_) / wallclock_time_ * 100.0;
  }

  const TestConfig config_;
  int64_t cpu_time_ = 0;
  int64_t wallclock_time_ = 0;
};

VideoProcessorIntegrationTest::VideoProcessorIntegrationTest() {
#if defined(WEBRTC_ANDROID)
  InitializeAndroidObjects();
#endif
}

VideoProcessorIntegrationTest::~VideoProcessorIntegrationTest() = default;

// Processes all frames in the clip and verifies the result.
void VideoProcessorIntegrationTest::ProcessFramesAndMaybeVerify(
    const std::vector<RateProfile>& rate_profiles,
    const std::vector<RateControlThresholds>* rc_thresholds,
    const std::vector<QualityThresholds>* quality_thresholds,
    const BitstreamThresholds* bs_thresholds,
    const VisualizationParams* visualization_params) {
  RTC_DCHECK(!rate_profiles.empty());
  // The Android HW codec needs to be run on a task queue, so we simply always
  // run the test on a task queue.
  rtc::TaskQueue task_queue("VidProc TQ");

  SetUpAndInitObjects(
      &task_queue, static_cast<const int>(rate_profiles[0].target_kbps),
      static_cast<const int>(rate_profiles[0].input_fps), visualization_params);
  PrintSettings();

  ProcessAllFrames(&task_queue, rate_profiles);

  ReleaseAndCloseObjects(&task_queue);

  AnalyzeAllFrames(rate_profiles, rc_thresholds, quality_thresholds,
                   bs_thresholds);
}

void VideoProcessorIntegrationTest::ProcessAllFrames(
    rtc::TaskQueue* task_queue,
    const std::vector<RateProfile>& rate_profiles) {
  // Process all frames.
  size_t rate_update_index = 0;

  // Set initial rates.
  task_queue->PostTask([this, &rate_profiles, rate_update_index] {
    processor_->SetRates(rate_profiles[rate_update_index].target_kbps,
                         rate_profiles[rate_update_index].input_fps);
  });

  cpu_process_time_->Start();

  for (size_t frame_number = 0; frame_number < config_.num_frames;
       ++frame_number) {
    if (frame_number ==
        rate_profiles[rate_update_index].frame_index_rate_update) {
      ++rate_update_index;
      RTC_DCHECK_GT(rate_profiles.size(), rate_update_index);

      task_queue->PostTask([this, &rate_profiles, rate_update_index] {
        processor_->SetRates(rate_profiles[rate_update_index].target_kbps,
                             rate_profiles[rate_update_index].input_fps);
      });
    }

    task_queue->PostTask([this] { processor_->ProcessFrame(); });

    if (RunEncodeInRealTime(config_)) {
      // Roughly pace the frames.
      size_t frame_duration_ms =
          rtc::kNumMillisecsPerSec / rate_profiles[rate_update_index].input_fps;
      SleepMs(static_cast<int>(frame_duration_ms));
    }
  }

  rtc::Event sync_event(false, false);
  task_queue->PostTask([&sync_event] { sync_event.Set(); });
  sync_event.Wait(rtc::Event::kForever);

  // Give the VideoProcessor pipeline some time to process the last frame,
  // and then release the codecs.
  if (config_.hw_encoder || config_.hw_decoder) {
    SleepMs(1 * rtc::kNumMillisecsPerSec);
  }

  cpu_process_time_->Stop();
}

void VideoProcessorIntegrationTest::AnalyzeAllFrames(
    const std::vector<RateProfile>& rate_profiles,
    const std::vector<RateControlThresholds>* rc_thresholds,
    const std::vector<QualityThresholds>* quality_thresholds,
    const BitstreamThresholds* bs_thresholds) {
  const bool is_svc = config_.NumberOfSpatialLayers() > 1;
  const size_t number_of_simulcast_or_spatial_layers =
      std::max(std::size_t{1},
               std::max(config_.NumberOfSpatialLayers(),
                        static_cast<size_t>(
                            config_.codec_settings.numberOfSimulcastStreams)));
  const size_t number_of_temporal_layers = config_.NumberOfTemporalLayers();
  printf("Rate control statistics\n==\n");
  for (size_t rate_update_index = 0; rate_update_index < rate_profiles.size();
       ++rate_update_index) {
    const size_t first_frame_number =
        (rate_update_index == 0)
            ? 0
            : rate_profiles[rate_update_index - 1].frame_index_rate_update;
    const size_t last_frame_number =
        rate_profiles[rate_update_index].frame_index_rate_update - 1;
    RTC_CHECK(last_frame_number >= first_frame_number);
    const size_t number_of_frames = last_frame_number - first_frame_number + 1;
    const float input_duration_sec =
        1.0 * number_of_frames / rate_profiles[rate_update_index].input_fps;

    std::vector<FrameStatistic> overall_stats =
        ExtractLayerStats(number_of_simulcast_or_spatial_layers - 1,
                          number_of_temporal_layers - 1, first_frame_number,
                          last_frame_number, true);

    printf("Rate update #%zu:\n", rate_update_index);

    const RateControlThresholds* rc_threshold =
        rc_thresholds ? &(*rc_thresholds)[rate_update_index] : nullptr;
    const QualityThresholds* quality_threshold =
        quality_thresholds ? &(*quality_thresholds)[rate_update_index]
                           : nullptr;
    AnalyzeAndPrintStats(
        overall_stats, rate_profiles[rate_update_index].target_kbps,
        rate_profiles[rate_update_index].input_fps, input_duration_sec,
        rc_threshold, quality_threshold, bs_thresholds);

    if (config_.print_frame_level_stats) {
      PrintFrameLevelStats(overall_stats);
    }

    for (size_t spatial_layer_number = 0;
         spatial_layer_number < number_of_simulcast_or_spatial_layers;
         ++spatial_layer_number) {
      for (size_t temporal_layer_number = 0;
           temporal_layer_number < number_of_temporal_layers;
           ++temporal_layer_number) {
        std::vector<FrameStatistic> layer_stats =
            ExtractLayerStats(spatial_layer_number, temporal_layer_number,
                              first_frame_number, last_frame_number, is_svc);

        const size_t target_bitrate_kbps = layer_stats[0].target_bitrate_kbps;
        const float target_framerate_fps =
            1.0 * rate_profiles[rate_update_index].input_fps /
            (1 << (number_of_temporal_layers - temporal_layer_number - 1));

        printf("Spatial %zu temporal %zu:\n", spatial_layer_number,
               temporal_layer_number);
        AnalyzeAndPrintStats(layer_stats, target_bitrate_kbps,
                             target_framerate_fps, input_duration_sec, nullptr,
                             nullptr, nullptr);

        if (config_.print_frame_level_stats) {
          PrintFrameLevelStats(layer_stats);
        }
      }
    }
  }

  cpu_process_time_->Print();
}

std::vector<FrameStatistic> VideoProcessorIntegrationTest::ExtractLayerStats(
    size_t target_spatial_layer_number,
    size_t target_temporal_layer_number,
    size_t first_frame_number,
    size_t last_frame_number,
    bool combine_layers_stats) {
  size_t target_bitrate_kbps = 0;
  std::vector<FrameStatistic> layer_stats;

  for (size_t frame_number = first_frame_number;
       frame_number <= last_frame_number; ++frame_number) {
    // TODO(ssilkin): Add layering support
    // FrameStatistic superframe_stat =
    // *stats_[target_spatial_layer_number].GetFrame(frame_number);
    FrameStatistic superframe_stat = *stats_.GetFrame(frame_number);
    const size_t tl_idx = superframe_stat.temporal_layer_idx;
    if (tl_idx <= target_temporal_layer_number) {
      if (combine_layers_stats) {
        for (size_t spatial_layer_number = 0;
             spatial_layer_number < target_spatial_layer_number;
             ++spatial_layer_number) {
          // TODO(ssilkin): Add layering support
          // const FrameStatistic* frame_stat =
          //    stats_[spatial_layer_number].GetFrame(frame_number);
          const FrameStatistic* frame_stat = stats_.GetFrame(frame_number);
          superframe_stat.encoded_frame_size_bytes +=
              frame_stat->encoded_frame_size_bytes;
          superframe_stat.encode_time_us = std::max(
              superframe_stat.encode_time_us, frame_stat->encode_time_us);
          superframe_stat.decode_time_us = std::max(
              superframe_stat.decode_time_us, frame_stat->decode_time_us);
        }
      }

      target_bitrate_kbps =
          std::max(target_bitrate_kbps, superframe_stat.target_bitrate_kbps);

      if (superframe_stat.encoding_successful) {
        RTC_CHECK(superframe_stat.target_bitrate_kbps <= target_bitrate_kbps ||
                  tl_idx == target_temporal_layer_number);
        RTC_CHECK(superframe_stat.target_bitrate_kbps == target_bitrate_kbps ||
                  tl_idx < target_temporal_layer_number);
      }

      layer_stats.push_back(superframe_stat);
    }
  }

  for (auto& frame_stat : layer_stats) {
    frame_stat.target_bitrate_kbps = target_bitrate_kbps;
  }

  return layer_stats;
}

void VideoProcessorIntegrationTest::CreateEncoderAndDecoder() {
  std::unique_ptr<VideoEncoderFactory> encoder_factory;
  if (config_.hw_encoder) {
#if defined(WEBRTC_ANDROID)
    JNIEnv* env = jni::AttachCurrentThreadIfNeeded();
    jni::ScopedJavaLocalRef<jclass> factory_class =
        jni::GetClass(env, "org/webrtc/HardwareVideoEncoderFactory");
    jmethodID factory_constructor = env->GetMethodID(
        factory_class.obj(), "<init>", "(Lorg/webrtc/EglBase$Context;ZZ)V");
    jni::ScopedJavaLocalRef<jobject> factory_object(
        env, env->NewObject(factory_class.obj(), factory_constructor,
                            nullptr /* shared_context */,
                            false /* enable_intel_vp8_encoder */,
                            true /* enable_h264_high_profile */));
    encoder_factory = rtc::MakeUnique<webrtc::jni::VideoEncoderFactoryWrapper>(
        env, factory_object);
#elif defined(WEBRTC_IOS)
    EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
        << "iOS HW codecs only support H264.";
    encoder_factory = CreateObjCEncoderFactory();
#else
    RTC_NOTREACHED() << "Only support HW encoder on Android and iOS.";
#endif
  } else {
    encoder_factory = rtc::MakeUnique<InternalEncoderFactory>();
  }

  std::unique_ptr<VideoDecoderFactory> decoder_factory;
  if (config_.hw_decoder) {
#if defined(WEBRTC_ANDROID)
    JNIEnv* env = jni::AttachCurrentThreadIfNeeded();
    jni::ScopedJavaLocalRef<jclass> factory_class =
        jni::GetClass(env, "org/webrtc/HardwareVideoDecoderFactory");
    jmethodID factory_constructor = env->GetMethodID(
        factory_class.obj(), "<init>", "(Lorg/webrtc/EglBase$Context;)V");
    jni::ScopedJavaLocalRef<jobject> factory_object(
        env, env->NewObject(factory_class.obj(), factory_constructor,
                            nullptr /* shared_context */));
    decoder_factory = rtc::MakeUnique<webrtc::jni::VideoDecoderFactoryWrapper>(
        env, factory_object);
#elif defined(WEBRTC_IOS)
    EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
        << "iOS HW codecs only support H264.";
    decoder_factory = CreateObjCDecoderFactory();
#else
    RTC_NOTREACHED() << "Only support HW decoder on Android and iOS.";
#endif
  } else {
    decoder_factory = rtc::MakeUnique<InternalDecoderFactory>();
  }

  const SdpVideoFormat format = CreateSdpVideoFormat(config_);
  encoder_ = encoder_factory->CreateVideoEncoder(format);
  decoder_ = decoder_factory->CreateVideoDecoder(format);

  if (config_.sw_fallback_encoder) {
    encoder_ = rtc::MakeUnique<VideoEncoderSoftwareFallbackWrapper>(
        InternalEncoderFactory().CreateVideoEncoder(format),
        std::move(encoder_));
  }
  if (config_.sw_fallback_decoder) {
    decoder_ = rtc::MakeUnique<VideoDecoderSoftwareFallbackWrapper>(
        InternalDecoderFactory().CreateVideoDecoder(format),
        std::move(decoder_));
  }

  EXPECT_TRUE(encoder_) << "Encoder not successfully created.";
  EXPECT_TRUE(decoder_) << "Decoder not successfully created.";
}

void VideoProcessorIntegrationTest::DestroyEncoderAndDecoder() {
  encoder_.reset();
  decoder_.reset();
}

void VideoProcessorIntegrationTest::SetUpAndInitObjects(
    rtc::TaskQueue* task_queue,
    const int initial_bitrate_kbps,
    const int initial_framerate_fps,
    const VisualizationParams* visualization_params) {
  CreateEncoderAndDecoder();

  config_.codec_settings.minBitrate = 0;
  config_.codec_settings.startBitrate = initial_bitrate_kbps;
  config_.codec_settings.maxFramerate = initial_framerate_fps;

  // Create file objects for quality analysis.
  analysis_frame_reader_.reset(new YuvFrameReaderImpl(
      config_.input_filename, config_.codec_settings.width,
      config_.codec_settings.height));
  analysis_frame_writer_.reset(new YuvFrameWriterImpl(
      config_.output_filename, config_.codec_settings.width,
      config_.codec_settings.height));
  EXPECT_TRUE(analysis_frame_reader_->Init());
  EXPECT_TRUE(analysis_frame_writer_->Init());

  if (visualization_params) {
    const std::string output_filename_base =
        OutputPath() + config_.FilenameWithParams();
    if (visualization_params->save_encoded_ivf) {
      rtc::File post_encode_file =
          rtc::File::Create(output_filename_base + ".ivf");
      encoded_frame_writer_ =
          IvfFileWriter::Wrap(std::move(post_encode_file), 0);
    }
    if (visualization_params->save_decoded_y4m) {
      decoded_frame_writer_.reset(new Y4mFrameWriterImpl(
          output_filename_base + ".y4m", config_.codec_settings.width,
          config_.codec_settings.height, initial_framerate_fps));
      EXPECT_TRUE(decoded_frame_writer_->Init());
    }
  }

  cpu_process_time_.reset(new CpuProcessTime(config_));

  rtc::Event sync_event(false, false);
  task_queue->PostTask([this, &sync_event]() {
    processor_ = rtc::MakeUnique<VideoProcessor>(
        encoder_.get(), decoder_.get(), analysis_frame_reader_.get(), config_,
        &stats_, encoded_frame_writer_.get(), decoded_frame_writer_.get());
    sync_event.Set();
  });
  sync_event.Wait(rtc::Event::kForever);
}

void VideoProcessorIntegrationTest::ReleaseAndCloseObjects(
    rtc::TaskQueue* task_queue) {
  rtc::Event sync_event(false, false);
  task_queue->PostTask([this, &sync_event]() {
    processor_.reset();
    sync_event.Set();
  });
  sync_event.Wait(rtc::Event::kForever);

  // The VideoProcessor must be destroyed before the codecs.
  DestroyEncoderAndDecoder();

  analysis_frame_reader_->Close();

  // Close visualization files.
  if (encoded_frame_writer_) {
    EXPECT_TRUE(encoded_frame_writer_->Close());
  }
  if (decoded_frame_writer_) {
    decoded_frame_writer_->Close();
  }
}

void VideoProcessorIntegrationTest::PrintSettings() const {
  printf("VideoProcessor settings\n==\n");
  printf(" Total # of frames      : %d",
         analysis_frame_reader_->NumberOfFrames());
  printf("%s\n", config_.ToString().c_str());

  printf("VideoProcessorIntegrationTest settings\n==\n");
  const char* encoder_name = encoder_->ImplementationName();
  printf(" Encoder implementation name: %s\n", encoder_name);
  const char* decoder_name = decoder_->ImplementationName();
  printf(" Decoder implementation name: %s\n", decoder_name);
  if (strcmp(encoder_name, decoder_name) == 0) {
    printf(" Codec implementation name  : %s_%s\n", config_.CodecName().c_str(),
           encoder_name);
  }
  printf("\n");
}

void VideoProcessorIntegrationTest::AnalyzeAndPrintStats(
    const std::vector<FrameStatistic>& stats,
    const float target_bitrate_kbps,
    const float target_framerate_fps,
    const float input_duration_sec,
    const RateControlThresholds* rc_thresholds,
    const QualityThresholds* quality_thresholds,
    const BitstreamThresholds* bs_thresholds) {
  const size_t num_input_frames = stats.size();
  size_t num_dropped_frames = 0;
  size_t num_decoded_frames = 0;
  size_t num_spatial_resizes = 0;
  size_t num_key_frames = 0;
  size_t max_nalu_size_bytes = 0;

  size_t encoded_bytes = 0;
  float buffer_level_kbits = 0.0;
  float time_to_reach_target_bitrate_sec = -1.0;

  Statistics buffer_level_sec;
  Statistics key_frame_size_bytes;
  Statistics delta_frame_size_bytes;

  Statistics encoding_time_us;
  Statistics decoding_time_us;
  Statistics psnr;
  Statistics ssim;

  Statistics qp;

  FrameStatistic last_successfully_decoded_frame(0, 0);
  for (size_t frame_idx = 0; frame_idx < stats.size(); ++frame_idx) {
    const FrameStatistic& frame_stat = stats[frame_idx];

    const float time_since_first_input_sec =
        frame_idx == 0
            ? 0.0
            : 1.0 * (frame_stat.rtp_timestamp - stats[0].rtp_timestamp) /
                  kRtpClockRateHz;
    const float time_since_last_input_sec =
        frame_idx == 0 ? 0.0
                       : 1.0 *
                             (frame_stat.rtp_timestamp -
                              stats[frame_idx - 1].rtp_timestamp) /
                             kRtpClockRateHz;

    // Testing framework uses constant input framerate. This guarantees even
    // sampling, which is important, of buffer level.
    buffer_level_kbits -= time_since_last_input_sec * target_bitrate_kbps;
    buffer_level_kbits = std::max(0.0f, buffer_level_kbits);
    buffer_level_kbits += 8.0 * frame_stat.encoded_frame_size_bytes / 1000;
    buffer_level_sec.AddSample(buffer_level_kbits / target_bitrate_kbps);

    encoded_bytes += frame_stat.encoded_frame_size_bytes;
    if (frame_stat.encoded_frame_size_bytes == 0) {
      ++num_dropped_frames;
    } else {
      if (frame_stat.frame_type == kVideoFrameKey) {
        key_frame_size_bytes.AddSample(frame_stat.encoded_frame_size_bytes);
        ++num_key_frames;
      } else {
        delta_frame_size_bytes.AddSample(frame_stat.encoded_frame_size_bytes);
      }

      encoding_time_us.AddSample(frame_stat.encode_time_us);
      qp.AddSample(frame_stat.qp);

      max_nalu_size_bytes =
          std::max(max_nalu_size_bytes, frame_stat.max_nalu_size_bytes);
    }

    if (frame_stat.decoding_successful) {
      psnr.AddSample(frame_stat.psnr);
      ssim.AddSample(frame_stat.ssim);
      if (num_decoded_frames > 0) {
        if (last_successfully_decoded_frame.decoded_width !=
                frame_stat.decoded_width ||
            last_successfully_decoded_frame.decoded_height !=
                frame_stat.decoded_height) {
          ++num_spatial_resizes;
        }
      }
      decoding_time_us.AddSample(frame_stat.decode_time_us);
      last_successfully_decoded_frame = frame_stat;
      ++num_decoded_frames;
    }

    if (time_to_reach_target_bitrate_sec < 0 && frame_idx > 0) {
      const float curr_bitrate_kbps =
          (8.0 * encoded_bytes / 1000) / time_since_first_input_sec;
      const float bitrate_mismatch_percent =
          100 * std::fabs(curr_bitrate_kbps - target_bitrate_kbps) /
          target_bitrate_kbps;
      if (bitrate_mismatch_percent < kMaxBitrateMismatchPercent) {
        time_to_reach_target_bitrate_sec = time_since_first_input_sec;
      }
    }
  }

  const float encoded_bitrate_kbps =
      8 * encoded_bytes / input_duration_sec / 1000;
  const float bitrate_mismatch_percent =
      100 * std::fabs(encoded_bitrate_kbps - target_bitrate_kbps) /
      target_bitrate_kbps;
  const size_t num_encoded_frames = num_input_frames - num_dropped_frames;
  const float encoded_framerate_fps = num_encoded_frames / input_duration_sec;
  const float decoded_framerate_fps = num_decoded_frames / input_duration_sec;
  const float framerate_mismatch_percent =
      100 * std::fabs(decoded_framerate_fps - target_framerate_fps) /
      target_framerate_fps;
  const float max_key_frame_delay_sec =
      8 * key_frame_size_bytes.Max() / 1000 / target_bitrate_kbps;
  const float max_delta_frame_delay_sec =
      8 * delta_frame_size_bytes.Max() / 1000 / target_bitrate_kbps;

  printf("Target bitrate                 : %f kbps\n", target_bitrate_kbps);
  printf("Encoded bitrate                : %f kbps\n", encoded_bitrate_kbps);
  printf("Bitrate mismatch               : %f %%\n", bitrate_mismatch_percent);
  printf("Time to reach target bitrate   : %f sec\n",
         time_to_reach_target_bitrate_sec);
  printf("Target framerate               : %f fps\n", target_framerate_fps);
  printf("Encoding framerate             : %f fps\n", encoded_framerate_fps);
  printf("Decoding framerate             : %f fps\n", decoded_framerate_fps);
  printf("Frame encoding time            : %f us\n", encoding_time_us.Mean());
  printf("Frame decoding time            : %f us\n", decoding_time_us.Mean());
  printf("Framerate mismatch percent     : %f %%\n",
         framerate_mismatch_percent);
  printf("Avg buffer level               : %f sec\n", buffer_level_sec.Mean());
  printf("Max key frame delay            : %f sec\n", max_key_frame_delay_sec);
  printf("Max delta frame delay          : %f sec\n",
         max_delta_frame_delay_sec);
  printf("Avg key frame size             : %f bytes\n",
         key_frame_size_bytes.Mean());
  printf("Avg delta frame size           : %f bytes\n",
         delta_frame_size_bytes.Mean());
  printf("Avg QP                         : %f\n", qp.Mean());
  printf("Avg PSNR                       : %f dB\n", psnr.Mean());
  printf("Min PSNR                       : %f dB\n", psnr.Min());
  printf("Avg SSIM                       : %f\n", ssim.Mean());
  printf("Min SSIM                       : %f\n", ssim.Min());
  printf("# input frames                 : %zu\n", num_input_frames);
  printf("# encoded frames               : %zu\n", num_encoded_frames);
  printf("# decoded frames               : %zu\n", num_decoded_frames);
  printf("# dropped frames               : %zu\n", num_dropped_frames);
  printf("# key frames                   : %zu\n", num_key_frames);
  printf("# encoded bytes                : %zu\n", encoded_bytes);
  printf("# spatial resizes              : %zu\n", num_spatial_resizes);

  if (rc_thresholds) {
    EXPECT_LE(bitrate_mismatch_percent,
              rc_thresholds->max_avg_bitrate_mismatch_percent);
    EXPECT_LE(time_to_reach_target_bitrate_sec,
              rc_thresholds->max_time_to_reach_target_bitrate_sec);
    EXPECT_LE(framerate_mismatch_percent,
              rc_thresholds->max_avg_framerate_mismatch_percent);
    EXPECT_LE(buffer_level_sec.Mean(), rc_thresholds->max_avg_buffer_level_sec);
    EXPECT_LE(max_key_frame_delay_sec,
              rc_thresholds->max_max_key_frame_delay_sec);
    EXPECT_LE(max_delta_frame_delay_sec,
              rc_thresholds->max_max_delta_frame_delay_sec);
    EXPECT_LE(num_spatial_resizes, rc_thresholds->max_num_spatial_resizes);
    EXPECT_LE(num_key_frames, rc_thresholds->max_num_key_frames);
  }

  if (quality_thresholds) {
    EXPECT_GT(psnr.Mean(), quality_thresholds->min_avg_psnr);
    EXPECT_GT(psnr.Min(), quality_thresholds->min_min_psnr);
    EXPECT_GT(ssim.Mean(), quality_thresholds->min_avg_ssim);
    EXPECT_GT(ssim.Min(), quality_thresholds->min_min_ssim);
  }

  if (bs_thresholds) {
    EXPECT_LE(max_nalu_size_bytes, bs_thresholds->max_max_nalu_size_bytes);
  }
}

void VideoProcessorIntegrationTest::PrintFrameLevelStats(
    const std::vector<FrameStatistic>& stats) const {
  for (auto& frame_stat : stats) {
    printf("%s\n", frame_stat.ToString().c_str());
  }
}

}  // namespace test
}  // namespace webrtc