| OLD | NEW |
|---|
| (Empty) |
| 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/sender/video_encoder_impl.h" | |
| 14 #include "media/cast/test/fake_single_thread_task_runner.h" | |
| 15 #include "media/cast/test/utility/default_config.h" | |
| 16 #include "media/cast/test/utility/video_utility.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 | |
| 19 namespace media { | |
| 20 namespace cast { | |
| 21 | |
| 22 class VideoEncoderImplTest : public ::testing::TestWithParam<Codec> { | |
| 23 protected: | |
| 24 VideoEncoderImplTest() | |
| 25 : testing_clock_(new base::SimpleTestTickClock()), | |
| 26 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), | |
| 27 cast_environment_(new CastEnvironment( | |
| 28 scoped_ptr<base::TickClock>(testing_clock_).Pass(), | |
| 29 task_runner_, | |
| 30 task_runner_, | |
| 31 task_runner_)), | |
| 32 video_config_(GetDefaultVideoSenderConfig()), | |
| 33 operational_status_(STATUS_UNINITIALIZED), | |
| 34 count_frames_delivered_(0) { | |
| 35 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); | |
| 36 first_frame_time_ = testing_clock_->NowTicks(); | |
| 37 } | |
| 38 | |
| 39 ~VideoEncoderImplTest() override {} | |
| 40 | |
| 41 void SetUp() override { | |
| 42 video_config_.codec = GetParam(); | |
| 43 } | |
| 44 | |
| 45 void TearDown() override { | |
| 46 video_encoder_.reset(); | |
| 47 task_runner_->RunTasks(); | |
| 48 } | |
| 49 | |
| 50 void CreateEncoder(bool three_buffer_mode) { | |
| 51 ASSERT_EQ(STATUS_UNINITIALIZED, operational_status_); | |
| 52 video_config_.max_number_of_video_buffers_used = | |
| 53 (three_buffer_mode ? 3 : 1); | |
| 54 video_encoder_.reset(new VideoEncoderImpl( | |
| 55 cast_environment_, | |
| 56 video_config_, | |
| 57 base::Bind(&VideoEncoderImplTest::OnOperationalStatusChange, | |
| 58 base::Unretained(this)))); | |
| 59 task_runner_->RunTasks(); | |
| 60 ASSERT_EQ(STATUS_INITIALIZED, operational_status_); | |
| 61 } | |
| 62 | |
| 63 VideoEncoder* video_encoder() const { | |
| 64 return video_encoder_.get(); | |
| 65 } | |
| 66 | |
| 67 void AdvanceClock() { | |
| 68 testing_clock_->Advance(base::TimeDelta::FromMilliseconds(33)); | |
| 69 } | |
| 70 | |
| 71 base::TimeTicks Now() const { | |
| 72 return testing_clock_->NowTicks(); | |
| 73 } | |
| 74 | |
| 75 void RunTasks() const { | |
| 76 return task_runner_->RunTasks(); | |
| 77 } | |
| 78 | |
| 79 int count_frames_delivered() const { | |
| 80 return count_frames_delivered_; | |
| 81 } | |
| 82 | |
| 83 // Return a callback that, when run, expects the EncodedFrame to have the | |
| 84 // given properties. | |
| 85 VideoEncoder::FrameEncodedCallback CreateFrameDeliverCallback( | |
| 86 uint32 expected_frame_id, | |
| 87 uint32 expected_last_referenced_frame_id, | |
| 88 uint32 expected_rtp_timestamp, | |
| 89 const base::TimeTicks& expected_reference_time) { | |
| 90 return base::Bind(&VideoEncoderImplTest::DeliverEncodedVideoFrame, | |
| 91 base::Unretained(this), | |
| 92 expected_frame_id, | |
| 93 expected_last_referenced_frame_id, | |
| 94 expected_rtp_timestamp, | |
| 95 expected_reference_time); | |
| 96 } | |
| 97 | |
| 98 // Creates a new VideoFrame of the given |size|, filled with a test pattern. | |
| 99 scoped_refptr<media::VideoFrame> CreateTestVideoFrame( | |
| 100 const gfx::Size& size) const { | |
| 101 const scoped_refptr<media::VideoFrame> frame = | |
| 102 media::VideoFrame::CreateFrame( | |
| 103 VideoFrame::I420, size, gfx::Rect(size), size, | |
| 104 testing_clock_->NowTicks() - first_frame_time_); | |
| 105 PopulateVideoFrame(frame.get(), 123); | |
| 106 return frame; | |
| 107 } | |
| 108 | |
| 109 private: | |
| 110 void OnOperationalStatusChange(OperationalStatus status) { | |
| 111 operational_status_ = status; | |
| 112 } | |
| 113 | |
| 114 // Checks that |encoded_frame| matches expected values. This is the method | |
| 115 // bound in the callback returned from CreateFrameDeliverCallback(). | |
| 116 void DeliverEncodedVideoFrame( | |
| 117 uint32 expected_frame_id, | |
| 118 uint32 expected_last_referenced_frame_id, | |
| 119 uint32 expected_rtp_timestamp, | |
| 120 const base::TimeTicks& expected_reference_time, | |
| 121 scoped_ptr<EncodedFrame> encoded_frame) { | |
| 122 if (expected_frame_id != expected_last_referenced_frame_id) { | |
| 123 EXPECT_EQ(EncodedFrame::DEPENDENT, encoded_frame->dependency); | |
| 124 } else if (video_config_.max_number_of_video_buffers_used == 1) { | |
| 125 EXPECT_EQ(EncodedFrame::KEY, encoded_frame->dependency); | |
| 126 } | |
| 127 EXPECT_EQ(expected_frame_id, encoded_frame->frame_id); | |
| 128 EXPECT_EQ(expected_last_referenced_frame_id, | |
| 129 encoded_frame->referenced_frame_id) | |
| 130 << "frame id: " << expected_frame_id; | |
| 131 EXPECT_EQ(expected_rtp_timestamp, encoded_frame->rtp_timestamp); | |
| 132 EXPECT_EQ(expected_reference_time, encoded_frame->reference_time); | |
| 133 EXPECT_FALSE(encoded_frame->data.empty()); | |
| 134 ++count_frames_delivered_; | |
| 135 } | |
| 136 | |
| 137 base::SimpleTestTickClock* const testing_clock_; // Owned by CastEnvironment. | |
| 138 const scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | |
| 139 const scoped_refptr<CastEnvironment> cast_environment_; | |
| 140 VideoSenderConfig video_config_; | |
| 141 base::TimeTicks first_frame_time_; | |
| 142 OperationalStatus operational_status_; | |
| 143 scoped_ptr<VideoEncoder> video_encoder_; | |
| 144 | |
| 145 int count_frames_delivered_; | |
| 146 | |
| 147 DISALLOW_COPY_AND_ASSIGN(VideoEncoderImplTest); | |
| 148 }; | |
| 149 | |
| 150 // A simple test to encode ten frames of video, expecting to see one key frame | |
| 151 // followed by nine delta frames. | |
| 152 TEST_P(VideoEncoderImplTest, GeneratesKeyFrameThenOnlyDeltaFrames) { | |
| 153 CreateEncoder(false); | |
| 154 | |
| 155 EXPECT_EQ(0, count_frames_delivered()); | |
| 156 | |
| 157 scoped_refptr<media::VideoFrame> video_frame = | |
| 158 CreateTestVideoFrame(gfx::Size(1280, 720)); | |
| 159 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 160 video_frame, | |
| 161 Now(), | |
| 162 CreateFrameDeliverCallback( | |
| 163 0, 0, TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 164 Now()))); | |
| 165 RunTasks(); | |
| 166 | |
| 167 for (uint32 frame_id = 1; frame_id < 10; ++frame_id) { | |
| 168 AdvanceClock(); | |
| 169 video_frame = CreateTestVideoFrame(gfx::Size(1280, 720)); | |
| 170 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 171 video_frame, | |
| 172 Now(), | |
| 173 CreateFrameDeliverCallback( | |
| 174 frame_id, frame_id - 1, | |
| 175 TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 176 Now()))); | |
| 177 RunTasks(); | |
| 178 } | |
| 179 | |
| 180 EXPECT_EQ(10, count_frames_delivered()); | |
| 181 } | |
| 182 | |
| 183 // Tests basic frame dependency rules when using the VP8 encoder in multi-buffer | |
| 184 // mode. | |
| 185 TEST_P(VideoEncoderImplTest, | |
| 186 FramesDoNotDependOnUnackedFramesInMultiBufferMode) { | |
| 187 if (GetParam() != CODEC_VIDEO_VP8) | |
| 188 return; // Only test multibuffer mode for the VP8 encoder. | |
| 189 CreateEncoder(true); | |
| 190 | |
| 191 EXPECT_EQ(0, count_frames_delivered()); | |
| 192 | |
| 193 scoped_refptr<media::VideoFrame> video_frame = | |
| 194 CreateTestVideoFrame(gfx::Size(1280, 720)); | |
| 195 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 196 video_frame, | |
| 197 Now(), | |
| 198 CreateFrameDeliverCallback( | |
| 199 0, 0, TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 200 Now()))); | |
| 201 RunTasks(); | |
| 202 | |
| 203 AdvanceClock(); | |
| 204 video_encoder()->LatestFrameIdToReference(0); | |
| 205 video_frame = CreateTestVideoFrame(gfx::Size(1280, 720)); | |
| 206 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 207 video_frame, | |
| 208 Now(), | |
| 209 CreateFrameDeliverCallback( | |
| 210 1, 0, TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 211 Now()))); | |
| 212 RunTasks(); | |
| 213 | |
| 214 AdvanceClock(); | |
| 215 video_encoder()->LatestFrameIdToReference(1); | |
| 216 video_frame = CreateTestVideoFrame(gfx::Size(1280, 720)); | |
| 217 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 218 video_frame, | |
| 219 Now(), | |
| 220 CreateFrameDeliverCallback( | |
| 221 2, 1, TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 222 Now()))); | |
| 223 RunTasks(); | |
| 224 | |
| 225 video_encoder()->LatestFrameIdToReference(2); | |
| 226 | |
| 227 for (uint32 frame_id = 3; frame_id < 10; ++frame_id) { | |
| 228 AdvanceClock(); | |
| 229 video_frame = CreateTestVideoFrame(gfx::Size(1280, 720)); | |
| 230 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 231 video_frame, | |
| 232 Now(), | |
| 233 CreateFrameDeliverCallback( | |
| 234 frame_id, 2, | |
| 235 TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 236 Now()))); | |
| 237 RunTasks(); | |
| 238 } | |
| 239 | |
| 240 EXPECT_EQ(10, count_frames_delivered()); | |
| 241 } | |
| 242 | |
| 243 // Tests that the encoder continues to output EncodedFrames as the frame size | |
| 244 // changes. See media/cast/receiver/video_decoder_unittest.cc for a complete | |
| 245 // encode/decode cycle of varied frame sizes that actually checks the frame | |
| 246 // content. | |
| 247 TEST_P(VideoEncoderImplTest, EncodesVariedFrameSizes) { | |
| 248 CreateEncoder(false); | |
| 249 ASSERT_TRUE(video_encoder()->CanEncodeVariedFrameSizes()); | |
| 250 | |
| 251 EXPECT_EQ(0, count_frames_delivered()); | |
| 252 | |
| 253 std::vector<gfx::Size> frame_sizes; | |
| 254 frame_sizes.push_back(gfx::Size(1280, 720)); | |
| 255 frame_sizes.push_back(gfx::Size(640, 360)); // Shrink both dimensions. | |
| 256 frame_sizes.push_back(gfx::Size(300, 200)); // Shrink both dimensions again. | |
| 257 frame_sizes.push_back(gfx::Size(200, 300)); // Same area. | |
| 258 frame_sizes.push_back(gfx::Size(600, 400)); // Grow both dimensions. | |
| 259 frame_sizes.push_back(gfx::Size(638, 400)); // Shrink only one dimension. | |
| 260 frame_sizes.push_back(gfx::Size(638, 398)); // Shrink the other dimension. | |
| 261 frame_sizes.push_back(gfx::Size(320, 180)); // Shrink both dimensions again. | |
| 262 frame_sizes.push_back(gfx::Size(322, 180)); // Grow only one dimension. | |
| 263 frame_sizes.push_back(gfx::Size(322, 182)); // Grow the other dimension. | |
| 264 frame_sizes.push_back(gfx::Size(1920, 1080)); // Grow both dimensions again. | |
| 265 | |
| 266 uint32 frame_id = 0; | |
| 267 | |
| 268 // Encode one frame at each size. Expect nothing but key frames to come out. | |
| 269 for (const auto& frame_size : frame_sizes) { | |
| 270 AdvanceClock(); | |
| 271 const scoped_refptr<media::VideoFrame> video_frame = | |
| 272 CreateTestVideoFrame(frame_size); | |
| 273 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 274 video_frame, | |
| 275 Now(), | |
| 276 CreateFrameDeliverCallback( | |
| 277 frame_id, | |
| 278 frame_id, | |
| 279 TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 280 Now()))); | |
| 281 RunTasks(); | |
| 282 ++frame_id; | |
| 283 } | |
| 284 | |
| 285 // Encode 10 frames at each size. Expect one key frame followed by nine delta | |
| 286 // frames for each frame size. | |
| 287 for (const auto& frame_size : frame_sizes) { | |
| 288 for (int i = 0; i < 10; ++i) { | |
| 289 AdvanceClock(); | |
| 290 const scoped_refptr<media::VideoFrame> video_frame = | |
| 291 CreateTestVideoFrame(frame_size); | |
| 292 EXPECT_TRUE(video_encoder()->EncodeVideoFrame( | |
| 293 video_frame, | |
| 294 Now(), | |
| 295 CreateFrameDeliverCallback( | |
| 296 frame_id, | |
| 297 i == 0 ? frame_id : frame_id - 1, | |
| 298 TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency), | |
| 299 Now()))); | |
| 300 RunTasks(); | |
| 301 ++frame_id; | |
| 302 } | |
| 303 } | |
| 304 | |
| 305 EXPECT_EQ(static_cast<int>(frame_id), count_frames_delivered()); | |
| 306 } | |
| 307 | |
| 308 INSTANTIATE_TEST_CASE_P(, | |
| 309 VideoEncoderImplTest, | |
| 310 ::testing::Values(CODEC_VIDEO_FAKE, CODEC_VIDEO_VP8)); | |
| 311 | |
| 312 } // namespace cast | |
| 313 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 906403006:
[Cast] Size-Adaptable platform video encoders. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master