media/cast/video_sender/video_encoder_impl_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/bind.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "media/base/video_frame.h"
  11 #include "media/cast/cast_defines.h"
  12 #include "media/cast/cast_environment.h"
  13 #include "media/cast/test/fake_single_thread_task_runner.h"
  14 #include "media/cast/test/utility/video_utility.h"
  15 #include "media/cast/video_sender/video_encoder_impl.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17
  18 namespace media {
  19 namespace cast {
  20
  21 using testing::_;
  22
  23 namespace {
  24 class TestVideoEncoderCallback
  25     : public base::RefCountedThreadSafe<TestVideoEncoderCallback> {
  26  public:
  27   TestVideoEncoderCallback() {}
  28
  29   void SetExpectedResult(bool expected_key_frame,
  30                          uint8 expected_frame_id,
  31                          uint8 expected_last_referenced_frame_id,
  32                          const base::TimeTicks& expected_capture_time) {
  33     expected_key_frame_ = expected_key_frame;
  34     expected_frame_id_ = expected_frame_id;
  35     expected_last_referenced_frame_id_ = expected_last_referenced_frame_id;
  36     expected_capture_time_ = expected_capture_time;
  37   }
  38
  39   void DeliverEncodedVideoFrame(
  40       scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
  41       const base::TimeTicks& capture_time) {
  42     EXPECT_EQ(expected_key_frame_, encoded_frame->key_frame);
  43     EXPECT_EQ(expected_frame_id_, encoded_frame->frame_id);
  44     EXPECT_EQ(expected_last_referenced_frame_id_,
  45               encoded_frame->last_referenced_frame_id);
  46     EXPECT_EQ(expected_capture_time_, capture_time);
  47   }
  48
  49  protected:
  50   virtual ~TestVideoEncoderCallback() {}
  51
  52  private:
  53   friend class base::RefCountedThreadSafe<TestVideoEncoderCallback>;
  54
  55   bool expected_key_frame_;
  56   uint8 expected_frame_id_;
  57   uint8 expected_last_referenced_frame_id_;
  58   base::TimeTicks expected_capture_time_;
  59
  60   DISALLOW_COPY_AND_ASSIGN(TestVideoEncoderCallback);
  61 };
  62 }  // namespace
  63
  64 class VideoEncoderImplTest : public ::testing::Test {
  65  protected:
  66   VideoEncoderImplTest()
  67       : test_video_encoder_callback_(new TestVideoEncoderCallback()) {
  68     video_config_.rtp_config.ssrc = 1;
  69     video_config_.incoming_feedback_ssrc = 2;
  70     video_config_.rtp_config.payload_type = 127;
  71     video_config_.use_external_encoder = false;
  72     video_config_.width = 320;
  73     video_config_.height = 240;
  74     video_config_.max_bitrate = 5000000;
  75     video_config_.min_bitrate = 1000000;
  76     video_config_.start_bitrate = 2000000;
  77     video_config_.max_qp = 56;
  78     video_config_.min_qp = 0;
  79     video_config_.max_frame_rate = 30;
  80     video_config_.max_number_of_video_buffers_used = 3;
  81     video_config_.codec = transport::kVp8;
  82     gfx::Size size(video_config_.width, video_config_.height);
  83     video_frame_ = media::VideoFrame::CreateFrame(
  84         VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
  85     PopulateVideoFrame(video_frame_, 123);
  86   }
  87
  88   virtual ~VideoEncoderImplTest() {}
  89
  90   virtual void SetUp() OVERRIDE {
  91     testing_clock_ = new base::SimpleTestTickClock();
  92     task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_);
  93     cast_environment_ =
  94         new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(),
  95                             task_runner_,
  96                             task_runner_,
  97                             task_runner_);
  98   }
  99
 100   virtual void TearDown() OVERRIDE {
 101     video_encoder_.reset();
 102     task_runner_->RunTasks();
 103   }
 104
 105   void Configure(uint8 max_unacked_frames) {
 106     video_encoder_.reset(new VideoEncoderImpl(
 107         cast_environment_, video_config_, max_unacked_frames));
 108   }
 109
 110   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
 111   scoped_refptr<TestVideoEncoderCallback> test_video_encoder_callback_;
 112   VideoSenderConfig video_config_;
 113   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
 114   scoped_ptr<VideoEncoder> video_encoder_;
 115   scoped_refptr<media::VideoFrame> video_frame_;
 116
 117   scoped_refptr<CastEnvironment> cast_environment_;
 118
 119   DISALLOW_COPY_AND_ASSIGN(VideoEncoderImplTest);
 120 };
 121
 122 TEST_F(VideoEncoderImplTest, EncodePattern30fpsRunningOutOfAck) {
 123   Configure(3);
 124
 125   VideoEncoder::FrameEncodedCallback frame_encoded_callback =
 126       base::Bind(&TestVideoEncoderCallback::DeliverEncodedVideoFrame,
 127                  test_video_encoder_callback_.get());
 128
 129   base::TimeTicks capture_time;
 130   capture_time += base::TimeDelta::FromMilliseconds(33);
 131   test_video_encoder_callback_->SetExpectedResult(true, 0, 0, capture_time);
 132   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 133       video_frame_, capture_time, frame_encoded_callback));
 134   task_runner_->RunTasks();
 135
 136   capture_time += base::TimeDelta::FromMilliseconds(33);
 137   video_encoder_->LatestFrameIdToReference(0);
 138   test_video_encoder_callback_->SetExpectedResult(false, 1, 0, capture_time);
 139   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 140       video_frame_, capture_time, frame_encoded_callback));
 141   task_runner_->RunTasks();
 142
 143   capture_time += base::TimeDelta::FromMilliseconds(33);
 144   video_encoder_->LatestFrameIdToReference(1);
 145   test_video_encoder_callback_->SetExpectedResult(false, 2, 1, capture_time);
 146   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 147       video_frame_, capture_time, frame_encoded_callback));
 148   task_runner_->RunTasks();
 149
 150   video_encoder_->LatestFrameIdToReference(2);
 151
 152   for (int i = 3; i < 6; ++i) {
 153     capture_time += base::TimeDelta::FromMilliseconds(33);
 154     test_video_encoder_callback_->SetExpectedResult(false, i, 2, capture_time);
 155     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 156         video_frame_, capture_time, frame_encoded_callback));
 157     task_runner_->RunTasks();
 158   }
 159 }
 160
 161 // TODO(pwestin): Re-enabled after redesign the encoder to control number of
 162 // frames in flight.
 163 TEST_F(VideoEncoderImplTest, DISABLED_EncodePattern60fpsRunningOutOfAck) {
 164   video_config_.max_number_of_video_buffers_used = 1;
 165   Configure(6);
 166
 167   base::TimeTicks capture_time;
 168   VideoEncoder::FrameEncodedCallback frame_encoded_callback =
 169       base::Bind(&TestVideoEncoderCallback::DeliverEncodedVideoFrame,
 170                  test_video_encoder_callback_.get());
 171
 172   capture_time += base::TimeDelta::FromMilliseconds(33);
 173   test_video_encoder_callback_->SetExpectedResult(true, 0, 0, capture_time);
 174   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 175       video_frame_, capture_time, frame_encoded_callback));
 176   task_runner_->RunTasks();
 177
 178   video_encoder_->LatestFrameIdToReference(0);
 179   capture_time += base::TimeDelta::FromMilliseconds(33);
 180   test_video_encoder_callback_->SetExpectedResult(false, 1, 0, capture_time);
 181   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 182       video_frame_, capture_time, frame_encoded_callback));
 183   task_runner_->RunTasks();
 184
 185   video_encoder_->LatestFrameIdToReference(1);
 186   capture_time += base::TimeDelta::FromMilliseconds(33);
 187   test_video_encoder_callback_->SetExpectedResult(false, 2, 0, capture_time);
 188   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 189       video_frame_, capture_time, frame_encoded_callback));
 190   task_runner_->RunTasks();
 191
 192   video_encoder_->LatestFrameIdToReference(2);
 193
 194   for (int i = 3; i < 9; ++i) {
 195     capture_time += base::TimeDelta::FromMilliseconds(33);
 196     test_video_encoder_callback_->SetExpectedResult(false, i, 2, capture_time);
 197     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 198         video_frame_, capture_time, frame_encoded_callback));
 199     task_runner_->RunTasks();
 200   }
 201 }
 202
 203 // TODO(pwestin): Re-enabled after redesign the encoder to control number of
 204 // frames in flight.
 205 TEST_F(VideoEncoderImplTest,
 206        DISABLED_EncodePattern60fps200msDelayRunningOutOfAck) {
 207   Configure(12);
 208
 209   base::TimeTicks capture_time;
 210   VideoEncoder::FrameEncodedCallback frame_encoded_callback =
 211       base::Bind(&TestVideoEncoderCallback::DeliverEncodedVideoFrame,
 212                  test_video_encoder_callback_.get());
 213
 214   capture_time += base::TimeDelta::FromMilliseconds(33);
 215   test_video_encoder_callback_->SetExpectedResult(true, 0, 0, capture_time);
 216   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 217       video_frame_, capture_time, frame_encoded_callback));
 218   task_runner_->RunTasks();
 219
 220   video_encoder_->LatestFrameIdToReference(0);
 221   capture_time += base::TimeDelta::FromMilliseconds(33);
 222   test_video_encoder_callback_->SetExpectedResult(false, 1, 0, capture_time);
 223   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 224       video_frame_, capture_time, frame_encoded_callback));
 225   task_runner_->RunTasks();
 226
 227   video_encoder_->LatestFrameIdToReference(1);
 228   capture_time += base::TimeDelta::FromMilliseconds(33);
 229   test_video_encoder_callback_->SetExpectedResult(false, 2, 0, capture_time);
 230   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 231       video_frame_, capture_time, frame_encoded_callback));
 232   task_runner_->RunTasks();
 233
 234   video_encoder_->LatestFrameIdToReference(2);
 235   capture_time += base::TimeDelta::FromMilliseconds(33);
 236   test_video_encoder_callback_->SetExpectedResult(false, 3, 0, capture_time);
 237   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 238       video_frame_, capture_time, frame_encoded_callback));
 239   task_runner_->RunTasks();
 240
 241   video_encoder_->LatestFrameIdToReference(3);
 242   capture_time += base::TimeDelta::FromMilliseconds(33);
 243   test_video_encoder_callback_->SetExpectedResult(false, 4, 0, capture_time);
 244   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 245       video_frame_, capture_time, frame_encoded_callback));
 246   task_runner_->RunTasks();
 247
 248   video_encoder_->LatestFrameIdToReference(4);
 249
 250   for (int i = 5; i < 17; ++i) {
 251     test_video_encoder_callback_->SetExpectedResult(false, i, 4, capture_time);
 252     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
 253         video_frame_, capture_time, frame_encoded_callback));
 254     task_runner_->RunTasks();
 255   }
 256 }
 257
 258 }  // namespace cast
 259 }  // namespace media