Extract TL config to VP8 libvpx flag conversion.

webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc

 /*
  *  Copyright (c) 2013 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 <memory>
 #include <vector>
 
 #include "vpx/vp8cx.h"
 #include "vpx/vpx_encoder.h"
 #include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
+#include "webrtc/modules/video_coding/codecs/vp8/vp8_impl.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/mock/mock_frame_dropper.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #include "webrtc/test/gtest.h"
 
 using ::testing::_;
 using ::testing::ElementsAre;
 using ::testing::NiceMock;
@@ skipping 23 matching lines @@
   ScreenshareLayerTest()
       : min_qp_(2), max_qp_(kDefaultQp), frame_size_(-1), clock_(1) {}
   virtual ~ScreenshareLayerTest() {}
 
   void SetUp() override { layers_.reset(new ScreenshareLayers(2, 0, &clock_)); }
 
   void EncodeFrame(uint32_t timestamp,
                    bool base_sync,
                    CodecSpecificInfoVP8* vp8_info,
                    int* flags) {
-    *flags = layers_->EncodeFlags(timestamp);
-    if (*flags == -1)
+    TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+    if (tl_config.drop_frame) {
+      *flags = -1;
       return;
+    }
+    *flags = VP8EncoderImpl::EncodeFlags(tl_config);
     layers_->PopulateCodecSpecific(base_sync, vp8_info, timestamp);
     ASSERT_NE(-1, frame_size_);
     layers_->FrameEncoded(frame_size_, kDefaultQp);
   }
 
   void ConfigureBitrates() {
     vpx_codec_enc_cfg_t vpx_cfg;
     memset(&vpx_cfg, 0, sizeof(vpx_codec_enc_cfg_t));
     vpx_cfg.rc_min_quantizer = min_qp_;
     vpx_cfg.rc_max_quantizer = max_qp_;
@@ skipping 27 matching lines @@
       if (got_tl0 && got_tl1)
         return timestamp;
     }
     ADD_FAILURE() << "Frames from both layers not received in time.";
     return 0;
   }
 
   int SkipUntilTl(int layer, int timestamp) {
     CodecSpecificInfoVP8 vp8_info;
     for (int i = 0; i < 5; ++i) {
-      layers_->EncodeFlags(timestamp);
+      TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+      VP8EncoderImpl::EncodeFlags(tl_config);
       timestamp += kTimestampDelta5Fps;
       layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
       if (vp8_info.temporalIdx != layer) {
         layers_->FrameEncoded(frame_size_, kDefaultQp);
       } else {
         return timestamp;
       }
     }
     ADD_FAILURE() << "Did not get a frame of TL" << layer << " in time.";
     return 0;
@@ skipping 16 matching lines @@
 
 TEST_F(ScreenshareLayerTest, 1Layer) {
   layers_.reset(new ScreenshareLayers(1, 0, &clock_));
   ConfigureBitrates();
   int flags = 0;
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
   // One layer screenshare should not use the frame dropper as all frames will
   // belong to the base layer.
   const int kSingleLayerFlags = 0;
-  flags = layers_->EncodeFlags(timestamp);
+  flags = VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp));
   EXPECT_EQ(kSingleLayerFlags, flags);
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   EXPECT_EQ(static_cast<uint8_t>(kNoTemporalIdx), vp8_info.temporalIdx);
   EXPECT_FALSE(vp8_info.layerSync);
   EXPECT_EQ(kNoTl0PicIdx, vp8_info.tl0PicIdx);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
-  flags = layers_->EncodeFlags(timestamp);
+  flags = VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp));
   EXPECT_EQ(kSingleLayerFlags, flags);
   timestamp += kTimestampDelta5Fps;
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   EXPECT_EQ(static_cast<uint8_t>(kNoTemporalIdx), vp8_info.temporalIdx);
   EXPECT_FALSE(vp8_info.layerSync);
   EXPECT_EQ(kNoTl0PicIdx, vp8_info.tl0PicIdx);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 }
 
 TEST_F(ScreenshareLayerTest, 2Layer) {
@@ skipping 67 matching lines @@
 
 TEST_F(ScreenshareLayerTest, 2LayersSyncAfterTimeout) {
   ConfigureBitrates();
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
   std::vector<int> sync_times;
 
   const int kNumFrames = kMaxSyncPeriodSeconds * kFrameRate * 2 - 1;
   for (int i = 0; i < kNumFrames; ++i) {
     timestamp += kTimestampDelta5Fps;
-    layers_->EncodeFlags(timestamp);
+    layers_->UpdateLayerConfig(timestamp);
     layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
 
     // Simulate TL1 being at least 8 qp steps better.
     if (vp8_info.temporalIdx == 0) {
       layers_->FrameEncoded(frame_size_, kDefaultQp);
     } else {
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
     }
 
     if (vp8_info.temporalIdx == 1 && vp8_info.layerSync)
       sync_times.push_back(timestamp);
   }
 
   ASSERT_EQ(2u, sync_times.size());
   EXPECT_GE(sync_times[1] - sync_times[0], 90000 * kMaxSyncPeriodSeconds);
 }
 
 TEST_F(ScreenshareLayerTest, 2LayersSyncAfterSimilarQP) {
   ConfigureBitrates();
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
   std::vector<int> sync_times;
 
   const int kNumFrames = (kSyncPeriodSeconds +
                           ((kMaxSyncPeriodSeconds - kSyncPeriodSeconds) / 2)) *
                          kFrameRate;
   for (int i = 0; i < kNumFrames; ++i) {
     timestamp += kTimestampDelta5Fps;
-    layers_->EncodeFlags(timestamp);
+    layers_->UpdateLayerConfig(timestamp);
     layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
 
     // Simulate TL1 being at least 8 qp steps better.
     if (vp8_info.temporalIdx == 0) {
       layers_->FrameEncoded(frame_size_, kDefaultQp);
     } else {
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
     }
 
     if (vp8_info.temporalIdx == 1 && vp8_info.layerSync)
       sync_times.push_back(timestamp);
   }
 
   ASSERT_EQ(1u, sync_times.size());
 
   bool bumped_tl0_quality = false;
   for (int i = 0; i < 3; ++i) {
     timestamp += kTimestampDelta5Fps;
-    int flags = layers_->EncodeFlags(timestamp);
+    TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+    int flags = VP8EncoderImpl::EncodeFlags(tl_config);
     layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
 
     if (vp8_info.temporalIdx == 0) {
       // Bump TL0 to same quality as TL1.
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
       bumped_tl0_quality = true;
     } else {
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
       if (bumped_tl0_quality) {
         EXPECT_TRUE(vp8_info.layerSync);
@@ skipping 128 matching lines @@
   // Updates cfg with current target bitrate.
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
 
   uint32_t timestamp = RunGracePeriod();
   timestamp = SkipUntilTl(0, timestamp);
 
   // Size 0 indicates dropped frame.
   layers_->FrameEncoded(0, kDefaultQp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_FALSE(layers_->UpdateConfiguration(&cfg));
-  EXPECT_EQ(kTl0Flags, layers_->EncodeFlags(timestamp));
+  EXPECT_EQ(kTl0Flags,
+            VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp)));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   timestamp = SkipUntilTl(0, timestamp);
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   EXPECT_LT(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
-  layers_->EncodeFlags(timestamp);
+  layers_->UpdateLayerConfig(timestamp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   // Next drop in TL1.
 
   timestamp = SkipUntilTl(1, timestamp);
   layers_->FrameEncoded(0, kDefaultQp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_FALSE(layers_->UpdateConfiguration(&cfg));
-  EXPECT_EQ(kTl1Flags, layers_->EncodeFlags(timestamp));
+  EXPECT_EQ(kTl1Flags,
+            VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp)));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   timestamp = SkipUntilTl(1, timestamp);
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   EXPECT_LT(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
-  layers_->EncodeFlags(timestamp);
+  layers_->UpdateLayerConfig(timestamp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 }
 
 TEST_F(ScreenshareLayerTest, RespectsMaxIntervalBetweenFrames) {
   const int kLowBitrateKbps = 50;
   const int kLargeFrameSizeBytes = 100000;
   const uint32_t kStartTimestamp = 1234;
 
   vpx_codec_enc_cfg_t cfg = GetConfig();
   layers_->OnRatesUpdated(kLowBitrateKbps, kLowBitrateKbps, 5);
   layers_->UpdateConfiguration(&cfg);
 
-  EXPECT_EQ(kTl0Flags, layers_->EncodeFlags(kStartTimestamp));
+  EXPECT_EQ(kTl0Flags, VP8EncoderImpl::EncodeFlags(
+                           layers_->UpdateLayerConfig(kStartTimestamp)));
   layers_->FrameEncoded(kLargeFrameSizeBytes, kDefaultQp);
 
   const uint32_t kTwoSecondsLater =
       kStartTimestamp + (ScreenshareLayers::kMaxFrameIntervalMs * 90);
 
   // Sanity check, repayment time should exceed kMaxFrameIntervalMs.
   ASSERT_GT(kStartTimestamp + 90 * (kLargeFrameSizeBytes * 8) / kLowBitrateKbps,
             kStartTimestamp + (ScreenshareLayers::kMaxFrameIntervalMs * 90));
 
-  EXPECT_EQ(-1, layers_->EncodeFlags(kTwoSecondsLater));
+  EXPECT_TRUE(layers_->UpdateLayerConfig(kTwoSecondsLater).drop_frame);
   // More than two seconds has passed since last frame, one should be emitted
   // even if bitrate target is then exceeded.
-  EXPECT_EQ(kTl0Flags, layers_->EncodeFlags(kTwoSecondsLater + 90));
+  EXPECT_EQ(kTl0Flags, VP8EncoderImpl::EncodeFlags(
+                           layers_->UpdateLayerConfig(kTwoSecondsLater + 90)));
 }
 
 TEST_F(ScreenshareLayerTest, UpdatesHistograms) {
   metrics::Reset();
   ConfigureBitrates();
   vpx_codec_enc_cfg_t cfg = GetConfig();
   bool trigger_drop = false;
   bool dropped_frame = false;
   bool overshoot = false;
   const int kTl0Qp = 35;
   const int kTl1Qp = 30;
   for (int64_t timestamp = 0;
        timestamp < kTimestampDelta5Fps * 5 * metrics::kMinRunTimeInSeconds;
        timestamp += kTimestampDelta5Fps) {
-    int flags = layers_->EncodeFlags(timestamp);
+    TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+    if (tl_config.drop_frame) {
+      dropped_frame = true;
+      continue;
+    }
+    int flags = VP8EncoderImpl::EncodeFlags(tl_config);
     if (flags != -1)
       layers_->UpdateConfiguration(&cfg);
 
     if (timestamp >= kTimestampDelta5Fps * 5 && !overshoot && flags != -1) {
       // Simulate one overshoot.
       layers_->FrameEncoded(0, 0);
       overshoot = true;
-      flags = layers_->EncodeFlags(timestamp);
+      flags =
+          VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp));
     }
 
     if (flags == kTl0Flags) {
       if (timestamp >= kTimestampDelta5Fps * 20 && !trigger_drop) {
         // Simulate a too large frame, to cause frame drop.
         layers_->FrameEncoded(frame_size_ * 5, kTl0Qp);
         trigger_drop = true;
       } else {
         layers_->FrameEncoded(frame_size_, kTl0Qp);
       }
@@ skipping 53 matching lines @@
 
   int64_t kTestSpanMs = 2000;
   int64_t kFrameIntervalsMs = 1000 / kFrameRate;
 
   uint32_t timestamp = 1234;
   int num_input_frames = 0;
   int num_discarded_frames = 0;
 
   // Send at regular rate - no drops expected.
   for (int64_t i = 0; i < kTestSpanMs; i += kFrameIntervalsMs) {
-    if (layers_->EncodeFlags(timestamp) == -1) {
+    if (layers_->UpdateLayerConfig(timestamp).drop_frame) {
       ++num_discarded_frames;
     } else {
       size_t frame_size_bytes = kDefaultTl0BitrateKbps * kFrameIntervalsMs / 8;
       layers_->FrameEncoded(frame_size_bytes, kDefaultQp);
     }
     timestamp += kFrameIntervalsMs * 90;
     clock_.AdvanceTimeMilliseconds(kFrameIntervalsMs);
     ++num_input_frames;
   }
   EXPECT_EQ(0, num_discarded_frames);
 
   // Send at twice the configured rate - drop every other frame.
   num_input_frames = 0;
   num_discarded_frames = 0;
   for (int64_t i = 0; i < kTestSpanMs; i += kFrameIntervalsMs / 2) {
-    if (layers_->EncodeFlags(timestamp) == -1) {
+    if (layers_->UpdateLayerConfig(timestamp).drop_frame) {
       ++num_discarded_frames;
     } else {
       size_t frame_size_bytes = kDefaultTl0BitrateKbps * kFrameIntervalsMs / 8;
       layers_->FrameEncoded(frame_size_bytes, kDefaultQp);
     }
     timestamp += kFrameIntervalsMs * 90 / 2;
     clock_.AdvanceTimeMilliseconds(kFrameIntervalsMs / 2);
     ++num_input_frames;
   }
 
   // Allow for some rounding errors in the measurements.
   EXPECT_NEAR(num_discarded_frames, num_input_frames / 2, 2);
 }
 }  // namespace webrtc