Make video encoder/decoder test faster

remoting/codec/codec_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <deque>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
 #include "remoting/codec/codec_test.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/base/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using webrtc::BasicDesktopFrame;
 using webrtc::DesktopFrame;
 using webrtc::DesktopRect;
 using webrtc::DesktopRegion;
 using webrtc::DesktopSize;
 
 namespace {
 
 const int kBytesPerPixel = 4;
 
 // Some sample rects for testing.
-std::vector<std::vector<DesktopRect> > MakeTestRectLists(DesktopSize size) {
-  std::vector<std::vector<DesktopRect> > rect_lists;
-  std::vector<DesktopRect> rects;
-  rects.push_back(DesktopRect::MakeXYWH(0, 0, size.width(), size.height()));
-  rect_lists.push_back(rects);
-  rects.clear();
-  rects.push_back(DesktopRect::MakeXYWH(
-      0, 0, size.width() / 2, size.height() / 2));
-  rect_lists.push_back(rects);
-  rects.clear();
-  rects.push_back(DesktopRect::MakeXYWH(
-      size.width() / 2, size.height() / 2,
-      size.width() / 2, size.height() / 2));
-  rect_lists.push_back(rects);
-  rects.clear();
-  rects.push_back(DesktopRect::MakeXYWH(16, 16, 16, 16));
-  rects.push_back(DesktopRect::MakeXYWH(128, 64, 32, 32));
-  rect_lists.push_back(rects);
-  return rect_lists;
+std::vector<DesktopRegion> MakeTestRegionLists(DesktopSize size) {
+  std::vector<DesktopRegion> region_lists;
+  DesktopRegion region;
+  region.AddRect(DesktopRect::MakeXYWH(0, 0, size.width(), size.height()));
+  region_lists.push_back(region);
+  region.Clear();
+  region.AddRect(
+      DesktopRect::MakeXYWH(0, 0, size.width() / 2, size.height() / 2));
+  region_lists.push_back(region);
+  region.Clear();
+  region.AddRect(DesktopRect::MakeXYWH(size.width() / 2, size.height() / 2,
+                                       size.width() / 2, size.height() / 2));
+  region_lists.push_back(region);
+  region.Clear();
+  region.AddRect(DesktopRect::MakeXYWH(16, 16, 16, 16));
+  region.AddRect(DesktopRect::MakeXYWH(32, 32, 32, 32));
+  region.IntersectWith(DesktopRect::MakeSize(size));
+  region_lists.push_back(region);
+  return region_lists;
 }
 
 }  // namespace
 
 namespace remoting {
 
 class VideoDecoderTester {
  public:
   VideoDecoderTester(VideoDecoder* decoder,
                      const DesktopSize& screen_size,
@@ skipping 39 matching lines @@
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
   void set_frame(DesktopFrame* frame) {
     frame_ = frame;
   }
 
-  void AddRects(const DesktopRect* rects, int count) {
-    for (int i = 0; i < count; ++i) {
-      expected_region_.AddRect(rects[i]);
-    }
-  }
-
   void AddRegion(const DesktopRegion& region) {
     expected_region_.AddRegion(region);
   }
 
   void VerifyResults() {
     if (!strict_)
       return;
 
     ASSERT_TRUE(frame_);
 
@@ skipping 114 matching lines @@
   for (int i = 0; i < memory_size; ++i) {
     frame->data()[i] = rand() % 256;
   }
 
   return frame.Pass();
 }
 
 static void TestEncodingRects(VideoEncoder* encoder,
                               VideoEncoderTester* tester,
                               DesktopFrame* frame,
-                              const DesktopRect* rects,
-                              int count) {
-  frame->mutable_updated_region()->Clear();
-  for (int i = 0; i < count; ++i) {
-    frame->mutable_updated_region()->AddRect(rects[i]);
-  }
-
+                              const DesktopRegion& region) {
+  *frame->mutable_updated_region() = region;
   scoped_ptr<VideoPacket> packet = encoder->Encode(*frame);
   tester->DataAvailable(packet.Pass());
 }
 
 void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
-  const int kSizes[] = {320, 319, 317, 150};
+  const int kSizes[] = {80, 79, 77, 54};
 
   VideoEncoderTester tester;
 
   for (size_t xi = 0; xi < arraysize(kSizes); ++xi) {
     for (size_t yi = 0; yi < arraysize(kSizes); ++yi) {
-      DesktopSize size = DesktopSize(kSizes[xi], kSizes[yi]);
+      DesktopSize size(kSizes[xi], kSizes[yi]);
       scoped_ptr<DesktopFrame> frame = PrepareFrame(size);
-      std::vector<std::vector<DesktopRect> > test_rect_lists =
-          MakeTestRectLists(size);
-      for (size_t i = 0; i < test_rect_lists.size(); ++i) {
-        const std::vector<DesktopRect>& test_rects = test_rect_lists[i];
-        TestEncodingRects(encoder, &tester, frame.get(),
-                          &test_rects[0], test_rects.size());
+      for (const DesktopRegion& region : MakeTestRegionLists(size)) {
+        TestEncodingRects(encoder, &tester, frame.get(), region);
       }
 
       // Pass some empty frames through the encoder.
-      for (int i = 0; i < 10; ++i) {
-        TestEncodingRects(encoder, &tester, frame.get(), nullptr, 0);
+      for (int i = 0; i < 5; ++i) {
+        TestEncodingRects(encoder, &tester, frame.get(), DesktopRegion());
       }
     }
   }
 }
 
 void TestVideoEncoderEmptyFrames(VideoEncoder* encoder,
                                  int max_topoff_frames) {
-  const DesktopSize kSize(640, 480);
+  const DesktopSize kSize(100, 100);
   scoped_ptr<DesktopFrame> frame(PrepareFrame(kSize));
 
   frame->mutable_updated_region()->SetRect(
       webrtc::DesktopRect::MakeSize(kSize));
   EXPECT_TRUE(encoder->Encode(*frame));
 
   int topoff_frames = 0;
   frame->mutable_updated_region()->Clear();
   for (int i = 0; i < max_topoff_frames + 1; ++i) {
     if (!encoder->Encode(*frame))
       break;
     topoff_frames++;
   }
 
   // If top-off is enabled then our random frame contents should always
   // trigger it, so expect at least one top-off frame - strictly, though,
   // an encoder may not always need to top-off.
   EXPECT_GE(topoff_frames, max_topoff_frames ? 1 : 0);
   EXPECT_LE(topoff_frames, max_topoff_frames);
 }
 
 static void TestEncodeDecodeRects(VideoEncoder* encoder,
                                   VideoEncoderTester* encoder_tester,
                                   VideoDecoderTester* decoder_tester,
                                   DesktopFrame* frame,
-                                  const DesktopRect* rects, int count) {
-  frame->mutable_updated_region()->Clear();
-  for (int i = 0; i < count; ++i) {
-    frame->mutable_updated_region()->AddRect(rects[i]);
-  }
-  decoder_tester->AddRects(rects, count);
+                                  const DesktopRegion& region) {
+  *frame->mutable_updated_region() = region;
+  decoder_tester->AddRegion(region);
 
   // Generate random data for the updated region.
   srand(0);
-  for (int i = 0; i < count; ++i) {
-    const int row_size =
-        DesktopFrame::kBytesPerPixel * rects[i].width();
-    uint8* memory = frame->data() +
-      frame->stride() * rects[i].top() +
-      DesktopFrame::kBytesPerPixel * rects[i].left();
-    for (int y = 0; y < rects[i].height(); ++y) {
+  for (DesktopRegion::Iterator i(region); !i.IsAtEnd(); i.Advance()) {
+    const int row_size = DesktopFrame::kBytesPerPixel * i.rect().width();
+    uint8* memory = frame->data() + frame->stride() * i.rect().top() +
+                    DesktopFrame::kBytesPerPixel * i.rect().left();
+    for (int y = 0; y < i.rect().height(); ++y) {
       for (int x = 0; x < row_size; ++x)
         memory[x] = rand() % 256;
       memory += frame->stride();
     }
   }
 
   scoped_ptr<VideoPacket> packet = encoder->Encode(*frame);
   encoder_tester->DataAvailable(packet.Pass());
   decoder_tester->VerifyResults();
   decoder_tester->Reset();
 }
 
-void TestVideoEncoderDecoder(
-    VideoEncoder* encoder, VideoDecoder* decoder, bool strict) {
-  DesktopSize kSize = DesktopSize(320, 240);
+void TestVideoEncoderDecoder(VideoEncoder* encoder,
+                             VideoDecoder* decoder,
+                             bool strict) {
+  DesktopSize kSize = DesktopSize(160, 120);
 
   VideoEncoderTester encoder_tester;
 
   scoped_ptr<DesktopFrame> frame = PrepareFrame(kSize);
 
   VideoDecoderTester decoder_tester(decoder, kSize, kSize);
   decoder_tester.set_strict(strict);
   decoder_tester.set_frame(frame.get());
   encoder_tester.set_decoder_tester(&decoder_tester);
 
-  std::vector<std::vector<DesktopRect> > test_rect_lists =
-      MakeTestRectLists(kSize);
-  for (size_t i = 0; i < test_rect_lists.size(); ++i) {
-    const std::vector<DesktopRect> test_rects = test_rect_lists[i];
+  for (const DesktopRegion& region : MakeTestRegionLists(kSize)) {
     TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester,
-                          frame.get(), &test_rects[0], test_rects.size());
+                          frame.get(), region);
   }
 }
 
 static void FillWithGradient(DesktopFrame* frame) {
   for (int j = 0; j < frame->size().height(); ++j) {
     uint8* p = frame->data() + j * frame->stride();
     for (int i = 0; i < frame->size().width(); ++i) {
       *p++ = (255.0 * i) / frame->size().width();
       *p++ = (164.0 * j) / frame->size().height();
       *p++ = (82.0 * (i + j)) /
@@ skipping 78 matching lines @@
 
     if (frame_count >= kWarmUpFrameCount) {
       elapsed = base::TimeTicks::Now() - start_time;
     }
   }
 
   return (frame_count * base::TimeDelta::FromSeconds(1)) / elapsed;
 }
 
 }  // namespace remoting