Add QP for libvpx VP8 decoder.

webrtc/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.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.
  */
 
@@ skipping 58 matching lines @@
     encoded_frame_->_buffer = frame_buffer_.get();
     encoded_frame_->_size = encoded_frame._length;
   }
   memcpy(encoded_frame_->_buffer, encoded_frame._buffer, encoded_frame._length);
   encoded_frame_->_length = encoded_frame._length;
   encoded_frame_->_encodedWidth = encoded_frame._encodedWidth;
   encoded_frame_->_encodedHeight = encoded_frame._encodedHeight;
   encoded_frame_->_timeStamp = encoded_frame._timeStamp;
   encoded_frame_->_frameType = encoded_frame._frameType;
   encoded_frame_->_completeFrame = encoded_frame._completeFrame;
+  encoded_frame_->qp_ = encoded_frame.qp_;
   encode_complete_ = true;
   return Result(Result::OK, 0);
 }
 
 bool Vp8UnitTestEncodeCompleteCallback::EncodeComplete() {
   if (encode_complete_) {
     encode_complete_ = false;
     return true;
   }
   return false;
 }
 
 class Vp8UnitTestDecodeCompleteCallback : public webrtc::DecodedImageCallback {
  public:
-  explicit Vp8UnitTestDecodeCompleteCallback(rtc::Optional<VideoFrame>* frame)
-      : decoded_frame_(frame), decode_complete(false) {}
-  int32_t Decoded(VideoFrame& frame) override;
+  explicit Vp8UnitTestDecodeCompleteCallback(rtc::Optional<VideoFrame>* frame,
+                                             rtc::Optional<uint8_t>* qp)
+      : decoded_frame_(frame), decoded_qp_(qp), decode_complete(false) {}
+  int32_t Decoded(VideoFrame& frame) override {
+    RTC_NOTREACHED();
+    return -1;
+  }
   int32_t Decoded(VideoFrame& frame, int64_t decode_time_ms) override {
     RTC_NOTREACHED();
     return -1;
   }
   void Decoded(VideoFrame& frame,
                rtc::Optional<int32_t> decode_time_ms,
-               rtc::Optional<uint8_t> qp) override {
-    RTC_NOTREACHED();
-  }
+               rtc::Optional<uint8_t> qp) override;
   bool DecodeComplete();
 
  private:
   rtc::Optional<VideoFrame>* decoded_frame_;
+  rtc::Optional<uint8_t>* decoded_qp_;
   bool decode_complete;
 };
 
 bool Vp8UnitTestDecodeCompleteCallback::DecodeComplete() {
   if (decode_complete) {
     decode_complete = false;
     return true;
   }
   return false;
 }
 
-int Vp8UnitTestDecodeCompleteCallback::Decoded(VideoFrame& image) {
-  *decoded_frame_ = rtc::Optional<VideoFrame>(image);
+void Vp8UnitTestDecodeCompleteCallback::Decoded(
+    VideoFrame& frame,
+    rtc::Optional<int32_t> decode_time_ms,
+    rtc::Optional<uint8_t> qp) {
+  *decoded_frame_ = rtc::Optional<VideoFrame>(frame);
+  *decoded_qp_ = qp;
   decode_complete = true;
-  return 0;
 }
 
 class TestVp8Impl : public ::testing::Test {
  protected:
   virtual void SetUp() {
     encoder_.reset(VP8Encoder::Create());
     decoder_.reset(VP8Decoder::Create());
     memset(&codec_inst_, 0, sizeof(codec_inst_));
     encode_complete_callback_.reset(
         new Vp8UnitTestEncodeCompleteCallback(&encoded_frame_, 0, NULL));
     decode_complete_callback_.reset(
-        new Vp8UnitTestDecodeCompleteCallback(&decoded_frame_));
+        new Vp8UnitTestDecodeCompleteCallback(&decoded_frame_, &decoded_qp_));
     encoder_->RegisterEncodeCompleteCallback(encode_complete_callback_.get());
     decoder_->RegisterDecodeCompleteCallback(decode_complete_callback_.get());
     // Using a QCIF image (aligned stride (u,v planes) > width).
     // Processing only one frame.
     source_file_ = fopen(test::ResourcePath("paris_qcif", "yuv").c_str(), "rb");
     ASSERT_TRUE(source_file_ != NULL);
     rtc::scoped_refptr<VideoFrameBuffer> compact_buffer(
         test::ReadI420Buffer(kWidth, kHeight, source_file_));
     ASSERT_TRUE(compact_buffer);
     codec_inst_.width = kWidth;
@@ skipping 57 matching lines @@
 
   std::unique_ptr<Vp8UnitTestEncodeCompleteCallback> encode_complete_callback_;
   std::unique_ptr<Vp8UnitTestDecodeCompleteCallback> decode_complete_callback_;
   std::unique_ptr<uint8_t[]> source_buffer_;
   FILE* source_file_;
   std::unique_ptr<VideoFrame> input_frame_;
   std::unique_ptr<VideoEncoder> encoder_;
   std::unique_ptr<VideoDecoder> decoder_;
   EncodedImage encoded_frame_;
   rtc::Optional<VideoFrame> decoded_frame_;
+  rtc::Optional<uint8_t> decoded_qp_;
   VideoCodec codec_inst_;
   TemporalLayersFactory tl_factory_;
 };
 
 TEST_F(TestVp8Impl, EncoderParameterTest) {
   strncpy(codec_inst_.plName, "VP8", 31);
   codec_inst_.plType = 126;
   codec_inst_.maxBitrate = 0;
   codec_inst_.minBitrate = 0;
   codec_inst_.width = 1440;
@@ skipping 14 matching lines @@
                                         codec_inst_.maxFramerate));
 
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->InitEncode(&codec_inst_, 1, 1440));
 
   // Decoder parameter tests.
   // Calls before InitDecode().
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Release());
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->InitDecode(&codec_inst_, 1));
 }
 
+TEST_F(TestVp8Impl, DecodedQpEqualsEncodedQp) {
+  SetUpEncodeDecode();
+  encoder_->Encode(*input_frame_, nullptr, nullptr);
+  EXPECT_GT(WaitForEncodedFrame(), 0u);
+  // First frame should be a key frame.
+  encoded_frame_._frameType = kVideoFrameKey;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            decoder_->Decode(encoded_frame_, false, nullptr));
+  EXPECT_GT(WaitForDecodedFrame(), 0u);
+  ASSERT_TRUE(decoded_frame_);
+  EXPECT_GT(I420PSNR(input_frame_.get(), &*decoded_frame_), 36);
+  ASSERT_TRUE(decoded_qp_);
+  EXPECT_EQ(encoded_frame_.qp_, *decoded_qp_);
+}
+
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_AlignedStrideEncodeDecode DISABLED_AlignedStrideEncodeDecode
 #else
 #define MAYBE_AlignedStrideEncodeDecode AlignedStrideEncodeDecode
 #endif
 TEST_F(TestVp8Impl, MAYBE_AlignedStrideEncodeDecode) {
   SetUpEncodeDecode();
   encoder_->Encode(*input_frame_, NULL, NULL);
   EXPECT_GT(WaitForEncodedFrame(), 0u);
   // First frame should be a key frame.
@@ skipping 29 matching lines @@
             decoder_->Decode(encoded_frame_, false, NULL));
   // Now setting a key frame.
   encoded_frame_._frameType = kVideoFrameKey;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             decoder_->Decode(encoded_frame_, false, NULL));
   ASSERT_TRUE(decoded_frame_);
   EXPECT_GT(I420PSNR(input_frame_.get(), &*decoded_frame_), 36);
 }
 
 }  // namespace webrtc