Verify parsed QP value when frame is encoded instead of storing parsed value and verifying later.

webrtc/modules/video_coding/codecs/test/videoprocessor.cc

 /*
  *  Copyright (c) 2012 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 "webrtc/modules/video_coding/codecs/test/videoprocessor.h"
 
 #include <string.h>
 
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/video/i420_buffer.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h"
 #include "webrtc/modules/video_coding/include/video_codec_initializer.h"
 #include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/timeutils.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
+#include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace test {
 
 namespace {
 
 const int kRtpClockRateHz = 90000;
 
 std::unique_ptr<VideoBitrateAllocator> CreateBitrateAllocator(
     TestConfig* config) {
@@ skipping 45 matching lines @@
            codec_settings.VP9().numberOfSpatialLayers);
     printf("  Flexible mode     : %d\n", codec_settings.VP9().flexibleMode);
   } else if (codec_settings.codecType == kVideoCodecH264) {
     printf("  Frame dropping    : %d\n", codec_settings.H264().frameDroppingOn);
     printf("  Key frame interval: %d\n",
            codec_settings.H264().keyFrameInterval);
     printf("  Profile           : %d\n", codec_settings.H264().profile);
   }
 }
 
+void VerifyQpParser(const EncodedImage& encoded_frame,
+                    const TestConfig& config) {
+  if (config.hw_codec)
+    return;
+
+  int qp;
+  if (config.codec_settings.codecType == kVideoCodecVP8) {
+    ASSERT_TRUE(vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+  } else if (config.codec_settings.codecType == kVideoCodecVP9) {
+    ASSERT_TRUE(vp9::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+  } else {
+    return;
+  }
+  EXPECT_EQ(encoded_frame.qp_, qp) << "Encoder QP != parsed bitstream QP.";
+}
+
 int GetElapsedTimeMicroseconds(int64_t start_ns, int64_t stop_ns) {
   int64_t diff_us = (stop_ns - start_ns) / rtc::kNumNanosecsPerMicrosec;
   RTC_DCHECK_GE(diff_us, std::numeric_limits<int>::min());
   RTC_DCHECK_LE(diff_us, std::numeric_limits<int>::max());
   return static_cast<int>(diff_us);
 }
 
 }  // namespace
 
 const char* ExcludeFrameTypesToStr(ExcludeFrameTypes e) {
@@ skipping 152 matching lines @@
   config_.codec_settings.maxFramerate = framerate_fps;
   int set_rates_result = encoder_->SetRateAllocation(
       bitrate_allocator_->GetAllocation(bitrate_kbps * 1000, framerate_fps),
       framerate_fps);
   RTC_DCHECK_GE(set_rates_result, 0)
       << "Failed to update encoder with new rate " << bitrate_kbps << ".";
   num_dropped_frames_ = 0;
   num_spatial_resizes_ = 0;
 }
 
-int VideoProcessor::GetQpFromEncoder(int frame_number) const {
-  RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
-  RTC_CHECK_LT(frame_number, frame_infos_.size());
-  return frame_infos_[frame_number].qp_encoder;
-}
-
-int VideoProcessor::GetQpFromBitstream(int frame_number) const {
-  RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
-  RTC_CHECK_LT(frame_number, frame_infos_.size());
-  return frame_infos_[frame_number].qp_bitstream;
-}
-
 int VideoProcessor::NumberDroppedFrames() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
   return num_dropped_frames_;
 }
 
 int VideoProcessor::NumberSpatialResizes() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
   return num_spatial_resizes_;
 }
 
@@ skipping 37 matching lines @@
     }
 
     last_frame_missing =
         (frame_infos_[last_encoded_frame_num_].manipulated_length == 0);
   }
   // Ensure strict monotonicity.
   RTC_CHECK_GT(frame_number, last_encoded_frame_num_);
   last_encoded_frame_num_ = frame_number;
 
   // Frame is not dropped, so update frame information and statistics.
+  VerifyQpParser(encoded_image, config_);
   RTC_CHECK_LT(frame_number, frame_infos_.size());
   FrameInfo* frame_info = &frame_infos_[frame_number];
-  frame_info->qp_encoder = encoded_image.qp_;
-  if (codec == kVideoCodecVP8) {
-    vp8::GetQp(encoded_image._buffer, encoded_image._length,
-      &frame_info->qp_bitstream);
-  } else if (codec == kVideoCodecVP9) {
-    vp9::GetQp(encoded_image._buffer, encoded_image._length,
-      &frame_info->qp_bitstream);
-  }
   FrameStatistic* frame_stat = &stats_->stats_[frame_number];
   frame_stat->encode_time_in_us =
       GetElapsedTimeMicroseconds(frame_info->encode_start_ns, encode_stop_ns);
   frame_stat->encoding_successful = true;
   frame_stat->encoded_frame_length_in_bytes = encoded_image._length;
   frame_stat->frame_number = frame_number;
   frame_stat->frame_type = encoded_image._frameType;
   frame_stat->qp = encoded_image.qp_;
   frame_stat->bit_rate_in_kbps = static_cast<int>(
       encoded_image._length * config_.codec_settings.maxFramerate * 8 / 1000);
@@ skipping 143 matching lines @@
 
   RTC_DCHECK_GT(timestamp, 0);
   const int ticks_per_frame =
       kRtpClockRateHz / config_.codec_settings.maxFramerate;
   RTC_DCHECK_EQ(timestamp % ticks_per_frame, 0);
   return (timestamp / ticks_per_frame) - 1;
 }
 
 }  // namespace test
 }  // namespace webrtc