remoting/codec/codec_test.cc

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