1 // Copyright (c) 2012 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 <deque> 6 #include <stdlib.h> 7 8 #include "base/bind.h" 9 #include "base/logging.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "media/base/video_frame.h" 12 #include "remoting/codec/codec_test.h" 13 #include "remoting/codec/video_decoder.h" 14 #include "remoting/codec/video_encoder.h" 15 #include "remoting/base/util.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h" 18 19 using webrtc::BasicDesktopFrame; 20 using webrtc::DesktopFrame; 21 using webrtc::DesktopRect; 22 using webrtc::DesktopRegion; 23 using webrtc::DesktopSize; 24 25 namespace { 26 27 const int kBytesPerPixel = 4; 28 29 // Some sample rects for testing. 30 std::vector<std::vector<DesktopRect> > MakeTestRectLists(DesktopSize size) { 31 std::vector<std::vector<DesktopRect> > rect_lists; 32 std::vector<DesktopRect> rects; 33 rects.push_back(DesktopRect::MakeXYWH(0, 0, size.width(), size.height())); 34 rect_lists.push_back(rects); 35 rects.clear(); 36 rects.push_back(DesktopRect::MakeXYWH( 37 0, 0, size.width() / 2, size.height() / 2)); 38 rect_lists.push_back(rects); 39 rects.clear(); 40 rects.push_back(DesktopRect::MakeXYWH( 41 size.width() / 2, size.height() / 2, 42 size.width() / 2, size.height() / 2)); 43 rect_lists.push_back(rects); 44 rects.clear(); 45 rects.push_back(DesktopRect::MakeXYWH(16, 16, 16, 16)); 46 rects.push_back(DesktopRect::MakeXYWH(128, 64, 32, 32)); 47 rect_lists.push_back(rects); 48 return rect_lists; 49 } 50 51 } // namespace 52 53 namespace remoting { 54 55 class VideoDecoderTester { 56 public: 57 VideoDecoderTester(VideoDecoder* decoder, 58 const DesktopSize& screen_size, 59 const DesktopSize& view_size) 60 : screen_size_(screen_size), 61 view_size_(view_size), 62 strict_(false), 63 decoder_(decoder), 64 frame_(NULL) { 65 image_data_.reset(new uint8[ 66 view_size_.width() * view_size_.height() * kBytesPerPixel]); 67 EXPECT_TRUE(image_data_.get()); 68 decoder_->Initialize( 69 DesktopSize(screen_size_.width(), screen_size_.height())); 70 } 71 72 void Reset() { 73 expected_region_.Clear(); 74 update_region_.Clear(); 75 } 76 77 void ResetRenderedData() { 78 memset(image_data_.get(), 0, 79 view_size_.width() * view_size_.height() * kBytesPerPixel); 80 } 81 82 void ReceivedPacket(VideoPacket* packet) { 83 ASSERT_TRUE(decoder_->DecodePacket(*packet)); 84 85 RenderFrame(); 86 } 87 88 void RenderFrame() { 89 decoder_->RenderFrame( 90 DesktopSize(view_size_.width(), view_size_.height()), 91 DesktopRect::MakeWH(view_size_.width(), view_size_.height()), 92 image_data_.get(), view_size_.width() * kBytesPerPixel, 93 &update_region_); 94 } 95 96 void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) { 97 ReceivedPacket(packet.get()); 98 } 99 100 void set_strict(bool strict) { 101 strict_ = strict; 102 } 103 104 void set_frame(DesktopFrame* frame) { 105 frame_ = frame; 106 } 107 108 void AddRects(const DesktopRect* rects, int count) { 109 for (int i = 0; i < count; ++i) { 110 expected_region_.AddRect(rects[i]); 111 } 112 } 113 114 void AddRegion(const DesktopRegion& region) { 115 expected_region_.AddRegion(region); 116 } 117 118 void VerifyResults() { 119 if (!strict_) 120 return; 121 122 ASSERT_TRUE(frame_); 123 124 // Test the content of the update region. 125 EXPECT_TRUE(expected_region_.Equals(update_region_)); 126 127 for (DesktopRegion::Iterator i(update_region_); !i.IsAtEnd(); 128 i.Advance()) { 129 const int stride = view_size_.width() * kBytesPerPixel; 130 EXPECT_EQ(stride, frame_->stride()); 131 const int offset = stride * i.rect().top() + 132 kBytesPerPixel * i.rect().left(); 133 const uint8* original = frame_->data() + offset; 134 const uint8* decoded = image_data_.get() + offset; 135 const int row_size = kBytesPerPixel * i.rect().width(); 136 for (int y = 0; y < i.rect().height(); ++y) { 137 EXPECT_EQ(0, memcmp(original, decoded, row_size)) 138 << "Row " << y << " is different"; 139 original += stride; 140 decoded += stride; 141 } 142 } 143 } 144 145 // The error at each pixel is the root mean square of the errors in 146 // the R, G, and B components, each normalized to [0, 1]. This routine 147 // checks that the maximum and mean pixel errors do not exceed given limits. 148 void VerifyResultsApprox(const uint8* expected_view_data, 149 double max_error_limit, double mean_error_limit) { 150 double max_error = 0.0; 151 double sum_error = 0.0; 152 int error_num = 0; 153 for (DesktopRegion::Iterator i(update_region_); !i.IsAtEnd(); 154 i.Advance()) { 155 const int stride = view_size_.width() * kBytesPerPixel; 156 const int offset = stride * i.rect().top() + 157 kBytesPerPixel * i.rect().left(); 158 const uint8* expected = expected_view_data + offset; 159 const uint8* actual = image_data_.get() + offset; 160 for (int y = 0; y < i.rect().height(); ++y) { 161 for (int x = 0; x < i.rect().width(); ++x) { 162 double error = CalculateError(expected, actual); 163 max_error = std::max(max_error, error); 164 sum_error += error; 165 ++error_num; 166 expected += 4; 167 actual += 4; 168 } 169 } 170 } 171 EXPECT_LE(max_error, max_error_limit); 172 double mean_error = sum_error / error_num; 173 EXPECT_LE(mean_error, mean_error_limit); 174 VLOG(0) << "Max error: " << max_error; 175 VLOG(0) << "Mean error: " << mean_error; 176 } 177 178 double CalculateError(const uint8* original, const uint8* decoded) { 179 double error_sum_squares = 0.0; 180 for (int i = 0; i < 3; i++) { 181 double error = static_cast<double>(*original++) - 182 static_cast<double>(*decoded++); 183 error /= 255.0; 184 error_sum_squares += error * error; 185 } 186 original++; 187 decoded++; 188 return sqrt(error_sum_squares / 3.0); 189 } 190 191 private: 192 DesktopSize screen_size_; 193 DesktopSize view_size_; 194 bool strict_; 195 DesktopRegion expected_region_; 196 DesktopRegion update_region_; 197 VideoDecoder* decoder_; 198 scoped_ptr<uint8[]> image_data_; 199 DesktopFrame* frame_; 200 201 DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester); 202 }; 203 204 // The VideoEncoderTester provides a hook for retrieving the data, and passing 205 // the message to other subprograms for validaton. 206 class VideoEncoderTester { 207 public: 208 VideoEncoderTester() 209 : decoder_tester_(NULL), 210 data_available_(0) { 211 } 212 213 ~VideoEncoderTester() { 214 EXPECT_GT(data_available_, 0); 215 } 216 217 void DataAvailable(scoped_ptr<VideoPacket> packet) { 218 ++data_available_; 219 // Send the message to the VideoDecoderTester. 220 if (decoder_tester_) { 221 decoder_tester_->ReceivedPacket(packet.get()); 222 } 223 } 224 225 void set_decoder_tester(VideoDecoderTester* decoder_tester) { 226 decoder_tester_ = decoder_tester; 227 } 228 229 private: 230 VideoDecoderTester* decoder_tester_; 231 int data_available_; 232 233 DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester); 234 }; 235 236 scoped_ptr<DesktopFrame> PrepareFrame(const DesktopSize& size) { 237 scoped_ptr<DesktopFrame> frame(new BasicDesktopFrame(size)); 238 239 srand(0); 240 int memory_size = size.width() * size.height() * kBytesPerPixel; 241 for (int i = 0; i < memory_size; ++i) { 242 frame->data()[i] = rand() % 256; 243 } 244 245 return frame.Pass(); 246 } 247 248 static void TestEncodingRects(VideoEncoder* encoder, 249 VideoEncoderTester* tester, 250 webrtc::DesktopFrame* frame, 251 const DesktopRect* rects, 252 int count) { 253 frame->mutable_updated_region()->Clear(); 254 for (int i = 0; i < count; ++i) { 255 frame->mutable_updated_region()->AddRect(rects[i]); 256 } 257 258 scoped_ptr<VideoPacket> packet = encoder->Encode(*frame); 259 tester->DataAvailable(packet.Pass()); 260 } 261 262 void TestVideoEncoder(VideoEncoder* encoder, bool strict) { 263 const int kSizes[] = {320, 319, 317, 150}; 264 265 VideoEncoderTester tester; 266 267 for (size_t xi = 0; xi < arraysize(kSizes); ++xi) { 268 for (size_t yi = 0; yi < arraysize(kSizes); ++yi) { 269 DesktopSize size = DesktopSize(kSizes[xi], kSizes[yi]); 270 scoped_ptr<webrtc::DesktopFrame> frame = PrepareFrame(size); 271 std::vector<std::vector<DesktopRect> > test_rect_lists = 272 MakeTestRectLists(size); 273 for (size_t i = 0; i < test_rect_lists.size(); ++i) { 274 const std::vector<DesktopRect>& test_rects = test_rect_lists[i]; 275 TestEncodingRects(encoder, &tester, frame.get(), 276 &test_rects[0], test_rects.size()); 277 } 278 } 279 } 280 } 281 282 static void TestEncodeDecodeRects(VideoEncoder* encoder, 283 VideoEncoderTester* encoder_tester, 284 VideoDecoderTester* decoder_tester, 285 DesktopFrame* frame, 286 const DesktopRect* rects, int count) { 287 frame->mutable_updated_region()->Clear(); 288 for (int i = 0; i < count; ++i) { 289 frame->mutable_updated_region()->AddRect(rects[i]); 290 } 291 decoder_tester->AddRects(rects, count); 292 293 // Generate random data for the updated region. 294 srand(0); 295 for (int i = 0; i < count; ++i) { 296 const int row_size = 297 DesktopFrame::kBytesPerPixel * rects[i].width(); 298 uint8* memory = frame->data() + 299 frame->stride() * rects[i].top() + 300 DesktopFrame::kBytesPerPixel * rects[i].left(); 301 for (int y = 0; y < rects[i].height(); ++y) { 302 for (int x = 0; x < row_size; ++x) 303 memory[x] = rand() % 256; 304 memory += frame->stride(); 305 } 306 } 307 308 scoped_ptr<VideoPacket> packet = encoder->Encode(*frame); 309 encoder_tester->DataAvailable(packet.Pass()); 310 decoder_tester->VerifyResults(); 311 decoder_tester->Reset(); 312 } 313 314 void TestVideoEncoderDecoder( 315 VideoEncoder* encoder, VideoDecoder* decoder, bool strict) { 316 DesktopSize kSize = DesktopSize(320, 240); 317 318 VideoEncoderTester encoder_tester; 319 320 scoped_ptr<DesktopFrame> frame = PrepareFrame(kSize); 321 322 VideoDecoderTester decoder_tester(decoder, kSize, kSize); 323 decoder_tester.set_strict(strict); 324 decoder_tester.set_frame(frame.get()); 325 encoder_tester.set_decoder_tester(&decoder_tester); 326 327 std::vector<std::vector<DesktopRect> > test_rect_lists = 328 MakeTestRectLists(kSize); 329 for (size_t i = 0; i < test_rect_lists.size(); ++i) { 330 const std::vector<DesktopRect> test_rects = test_rect_lists[i]; 331 TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, 332 frame.get(), &test_rects[0], test_rects.size()); 333 } 334 } 335 336 static void FillWithGradient(DesktopFrame* frame) { 337 for (int j = 0; j < frame->size().height(); ++j) { 338 uint8* p = frame->data() + j * frame->stride(); 339 for (int i = 0; i < frame->size().width(); ++i) { 340 *p++ = (255.0 * i) / frame->size().width(); 341 *p++ = (164.0 * j) / frame->size().height(); 342 *p++ = (82.0 * (i + j)) / 343 (frame->size().width() + frame->size().height()); 344 *p++ = 0; 345 } 346 } 347 } 348 349 void TestVideoEncoderDecoderGradient(VideoEncoder* encoder, 350 VideoDecoder* decoder, 351 const DesktopSize& screen_size, 352 const DesktopSize& view_size, 353 double max_error_limit, 354 double mean_error_limit) { 355 scoped_ptr<BasicDesktopFrame> frame( 356 new BasicDesktopFrame(screen_size)); 357 FillWithGradient(frame.get()); 358 frame->mutable_updated_region()->SetRect(DesktopRect::MakeSize(screen_size)); 359 360 scoped_ptr<BasicDesktopFrame> expected_result( 361 new BasicDesktopFrame(view_size)); 362 FillWithGradient(expected_result.get()); 363 364 VideoDecoderTester decoder_tester(decoder, screen_size, view_size); 365 decoder_tester.set_frame(frame.get()); 366 decoder_tester.AddRegion(frame->updated_region()); 367 368 scoped_ptr<VideoPacket> packet = encoder->Encode(*frame); 369 decoder_tester.ReceivedScopedPacket(packet.Pass()); 370 371 decoder_tester.VerifyResultsApprox(expected_result->data(), 372 max_error_limit, mean_error_limit); 373 374 // Check that the decoder correctly re-renders the frame if its client 375 // invalidates the frame. 376 decoder_tester.ResetRenderedData(); 377 decoder->Invalidate( 378 DesktopSize(view_size.width(), view_size.height()), 379 DesktopRegion( 380 DesktopRect::MakeWH(view_size.width(), view_size.height()))); 381 decoder_tester.RenderFrame(); 382 decoder_tester.VerifyResultsApprox(expected_result->data(), 383 max_error_limit, mean_error_limit); 384 } 385 386 float MeasureVideoEncoderFpsWithSize(VideoEncoder* encoder, 387 const DesktopSize& size) { 388 scoped_ptr<DesktopFrame> frame(PrepareFrame(size)); 389 frame->mutable_updated_region()->SetRect(DesktopRect::MakeSize(size)); 390 std::list<DesktopFrame*> frames; 391 frames.push_back(frame.get()); 392 return MeasureVideoEncoderFpsWithFrames(encoder, frames); 393 } 394 395 float MeasureVideoEncoderFpsWithFrames(VideoEncoder* encoder, 396 const std::list<DesktopFrame*>& frames) { 397 const base::TimeDelta kTestTime = base::TimeDelta::FromSeconds(1); 398 399 // Encode some frames to "warm up" the encoder (i.e. to let it set up initial 400 // structures, establish a stable working set, etc), then encode at least 401 // kMinimumFrameCount frames to measure the encoder's performance. 402 const int kWarmUpFrameCount = 10; 403 const int kMinimumFrameCount = 10; 404 base::TimeTicks start_time; 405 base::TimeDelta elapsed; 406 std::list<DesktopFrame*> test_frames; 407 int frame_count; 408 for (frame_count = 0; 409 (frame_count < kMinimumFrameCount + kWarmUpFrameCount || 410 elapsed < kTestTime); 411 ++frame_count) { 412 if (frame_count == kWarmUpFrameCount) { 413 start_time = base::TimeTicks::Now(); 414 } 415 416 if (test_frames.empty()) { 417 test_frames = frames; 418 } 419 scoped_ptr<VideoPacket> packet = encoder->Encode(*test_frames.front()); 420 test_frames.pop_front(); 421 422 if (frame_count >= kWarmUpFrameCount) { 423 elapsed = base::TimeTicks::Now() - start_time; 424 } 425 } 426 427 return (frame_count * base::TimeDelta::FromSeconds(1)) / elapsed; 428 } 429 430 } // namespace remoting 431
