codec_test.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d 
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
18namespace {
19
20const int kBytesPerPixel = 4;
21
22// Some sample rects for testing.
23std::vector<std::vector<SkIRect> > MakeTestRectLists(const SkISize& size) {
24  std::vector<std::vector<SkIRect> > rect_lists;
25  std::vector<SkIRect> rects;
26  rects.push_back(SkIRect::MakeXYWH(0, 0, size.width(), size.height()));
27  rect_lists.push_back(rects);
28  rects.clear();
29  rects.push_back(SkIRect::MakeXYWH(0, 0, size.width() / 2, size.height() / 2));
30  rect_lists.push_back(rects);
31  rects.clear();
32  rects.push_back(SkIRect::MakeXYWH(size.width() / 2, size.height() / 2,
33                                    size.width() / 2, size.height() / 2));
34  rect_lists.push_back(rects);
35  rects.clear();
36  rects.push_back(SkIRect::MakeXYWH(16, 16, 16, 16));
37  rects.push_back(SkIRect::MakeXYWH(128, 64, 32, 32));
38  rect_lists.push_back(rects);
39  return rect_lists;
40}
41
42}  // namespace
43
44namespace remoting {
45
46// A class to test the message output of the encoder.
47class VideoEncoderMessageTester {
48 public:
49  VideoEncoderMessageTester()
50      : begin_rect_(0),
51        rect_data_(0),
52        end_rect_(0),
53        added_rects_(0),
54        state_(kWaitingForBeginRect),
55        strict_(false) {
56  }
57
58  ~VideoEncoderMessageTester() {
59    EXPECT_EQ(begin_rect_, end_rect_);
60    EXPECT_GT(begin_rect_, 0);
61    EXPECT_EQ(kWaitingForBeginRect, state_);
62    if (strict_) {
63      EXPECT_EQ(added_rects_, begin_rect_);
64    }
65  }
66
67  // Test that we received the correct packet.
68  void ReceivedPacket(VideoPacket* packet) {
69    if (state_ == kWaitingForBeginRect) {
70      EXPECT_TRUE((packet->flags() & VideoPacket::FIRST_PACKET) != 0);
71      state_ = kWaitingForRectData;
72      ++begin_rect_;
73
74      if (strict_) {
75        SkIRect rect = rects_.front();
76        rects_.pop_front();
77        EXPECT_EQ(rect.fLeft, packet->format().x());
78        EXPECT_EQ(rect.fTop, packet->format().y());
79        EXPECT_EQ(rect.width(), packet->format().width());
80        EXPECT_EQ(rect.height(), packet->format().height());
81      }
82    } else {
83      EXPECT_FALSE((packet->flags() & VideoPacket::FIRST_PACKET) != 0);
84    }
85
86    if (state_ == kWaitingForRectData) {
87      if (packet->has_data()) {
88        ++rect_data_;
89      }
90
91      if ((packet->flags() & VideoPacket::LAST_PACKET) != 0) {
92        // Expect that we have received some data.
93        EXPECT_GT(rect_data_, 0);
94        rect_data_ = 0;
95        state_ = kWaitingForBeginRect;
96        ++end_rect_;
97      }
98
99      if ((packet->flags() & VideoPacket::LAST_PARTITION) != 0) {
100        // LAST_PARTITION must always be marked with LAST_PACKET.
101        EXPECT_TRUE((packet->flags() & VideoPacket::LAST_PACKET) != 0);
102      }
103    }
104  }
105
106  void set_strict(bool strict) {
107    strict_ = strict;
108  }
109
110  void AddRects(const SkIRect* rects, int count) {
111    rects_.insert(rects_.begin() + rects_.size(), rects, rects + count);
112    added_rects_ += count;
113  }
114
115 private:
116  enum State {
117    kWaitingForBeginRect,
118    kWaitingForRectData,
119  };
120
121  int begin_rect_;
122  int rect_data_;
123  int end_rect_;
124  int added_rects_;
125  State state_;
126  bool strict_;
127
128  std::deque<SkIRect> rects_;
129
130  DISALLOW_COPY_AND_ASSIGN(VideoEncoderMessageTester);
131};
132
133class VideoDecoderTester {
134 public:
135  VideoDecoderTester(VideoDecoder* decoder, const SkISize& screen_size,
136                     const SkISize& view_size)
137      : screen_size_(screen_size),
138        view_size_(view_size),
139        strict_(false),
140        decoder_(decoder) {
141    image_data_.reset(new uint8[
142        view_size_.width() * view_size_.height() * kBytesPerPixel]);
143    EXPECT_TRUE(image_data_.get());
144    decoder_->Initialize(screen_size_);
145  }
146
147  void Reset() {
148    expected_region_.setEmpty();
149    update_region_.setEmpty();
150  }
151
152  void ResetRenderedData() {
153    memset(image_data_.get(), 0,
154           view_size_.width() * view_size_.height() * kBytesPerPixel);
155  }
156
157  void ReceivedPacket(VideoPacket* packet) {
158    VideoDecoder::DecodeResult result = decoder_->DecodePacket(packet);
159
160    ASSERT_NE(VideoDecoder::DECODE_ERROR, result);
161
162    if (result == VideoDecoder::DECODE_DONE) {
163      RenderFrame();
164    }
165  }
166
167  void RenderFrame() {
168    decoder_->RenderFrame(view_size_,
169                          SkIRect::MakeSize(view_size_),
170                          image_data_.get(),
171                          view_size_.width() * kBytesPerPixel,
172                          &update_region_);
173  }
174
175  void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) {
176    ReceivedPacket(packet.get());
177  }
178
179  void set_strict(bool strict) {
180    strict_ = strict;
181  }
182
183  void set_capture_data(scoped_refptr<media::ScreenCaptureData> data) {
184    capture_data_ = data;
185  }
186
187  void AddRects(const SkIRect* rects, int count) {
188    SkRegion new_rects;
189    new_rects.setRects(rects, count);
190    AddRegion(new_rects);
191  }
192
193  void AddRegion(const SkRegion& region) {
194    expected_region_.op(region, SkRegion::kUnion_Op);
195  }
196
197  void VerifyResults() {
198    if (!strict_)
199      return;
200
201    ASSERT_TRUE(capture_data_.get());
202
203    // Test the content of the update region.
204    EXPECT_EQ(expected_region_, update_region_);
205    for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
206      const int stride = view_size_.width() * kBytesPerPixel;
207      EXPECT_EQ(stride, capture_data_->stride());
208      const int offset =  stride * i.rect().top() +
209          kBytesPerPixel * i.rect().left();
210      const uint8* original = capture_data_->data() + offset;
211      const uint8* decoded = image_data_.get() + offset;
212      const int row_size = kBytesPerPixel * i.rect().width();
213      for (int y = 0; y < i.rect().height(); ++y) {
214        EXPECT_EQ(0, memcmp(original, decoded, row_size))
215            << "Row " << y << " is different";
216        original += stride;
217        decoded += stride;
218      }
219    }
220  }
221
222  // The error at each pixel is the root mean square of the errors in
223  // the R, G, and B components, each normalized to [0, 1]. This routine
224  // checks that the maximum and mean pixel errors do not exceed given limits.
225  void VerifyResultsApprox(const uint8* expected_view_data,
226                           double max_error_limit, double mean_error_limit) {
227    double max_error = 0.0;
228    double sum_error = 0.0;
229    int error_num = 0;
230    for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
231      const int stride = view_size_.width() * kBytesPerPixel;
232      const int offset =  stride * i.rect().top() +
233          kBytesPerPixel * i.rect().left();
234      const uint8* expected = expected_view_data + offset;
235      const uint8* actual = image_data_.get() + offset;
236      for (int y = 0; y < i.rect().height(); ++y) {
237        for (int x = 0; x < i.rect().width(); ++x) {
238          double error = CalculateError(expected, actual);
239          max_error = std::max(max_error, error);
240          sum_error += error;
241          ++error_num;
242          expected += 4;
243          actual += 4;
244        }
245      }
246    }
247    EXPECT_LE(max_error, max_error_limit);
248    double mean_error = sum_error / error_num;
249    EXPECT_LE(mean_error, mean_error_limit);
250    LOG(INFO) << "Max error: " << max_error;
251    LOG(INFO) << "Mean error: " << mean_error;
252  }
253
254  double CalculateError(const uint8* original, const uint8* decoded) {
255    double error_sum_squares = 0.0;
256    for (int i = 0; i < 3; i++) {
257      double error = static_cast<double>(*original++) -
258                     static_cast<double>(*decoded++);
259      error /= 255.0;
260      error_sum_squares += error * error;
261    }
262    original++;
263    decoded++;
264    return sqrt(error_sum_squares / 3.0);
265  }
266
267 private:
268  SkISize screen_size_;
269  SkISize view_size_;
270  bool strict_;
271  SkRegion expected_region_;
272  SkRegion update_region_;
273  VideoDecoder* decoder_;
274  scoped_ptr<uint8[]> image_data_;
275  scoped_refptr<media::ScreenCaptureData> capture_data_;
276
277  DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester);
278};
279
280// The VideoEncoderTester provides a hook for retrieving the data, and passing
281// the message to other subprograms for validaton.
282class VideoEncoderTester {
283 public:
284  VideoEncoderTester(VideoEncoderMessageTester* message_tester)
285      : message_tester_(message_tester),
286        decoder_tester_(NULL),
287        data_available_(0) {
288  }
289
290  ~VideoEncoderTester() {
291    EXPECT_GT(data_available_, 0);
292  }
293
294  void DataAvailable(scoped_ptr<VideoPacket> packet) {
295    ++data_available_;
296    message_tester_->ReceivedPacket(packet.get());
297
298    // Send the message to the VideoDecoderTester.
299    if (decoder_tester_) {
300      decoder_tester_->ReceivedPacket(packet.get());
301    }
302  }
303
304  void AddRects(const SkIRect* rects, int count) {
305    message_tester_->AddRects(rects, count);
306  }
307
308  void set_decoder_tester(VideoDecoderTester* decoder_tester) {
309    decoder_tester_ = decoder_tester;
310  }
311
312 private:
313  VideoEncoderMessageTester* message_tester_;
314  VideoDecoderTester* decoder_tester_;
315  int data_available_;
316
317  DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester);
318};
319
320scoped_refptr<media::ScreenCaptureData> PrepareEncodeData(
321    const SkISize& size,
322    scoped_ptr<uint8[]>* memory) {
323  int memory_size = size.width() * size.height() * kBytesPerPixel;
324
325  memory->reset(new uint8[memory_size]);
326
327  srand(0);
328  for (int i = 0; i < memory_size; ++i) {
329    (*memory)[i] = rand() % 256;
330  }
331
332  scoped_refptr<media::ScreenCaptureData> data = new media::ScreenCaptureData(
333      memory->get(), size.width() * kBytesPerPixel, size);
334  return data;
335}
336
337static void TestEncodingRects(VideoEncoder* encoder,
338                              VideoEncoderTester* tester,
339                              scoped_refptr<media::ScreenCaptureData> data,
340                              const SkIRect* rects, int count) {
341  data->mutable_dirty_region().setEmpty();
342  for (int i = 0; i < count; ++i) {
343    data->mutable_dirty_region().op(rects[i], SkRegion::kUnion_Op);
344  }
345  tester->AddRects(rects, count);
346
347  encoder->Encode(data, true, base::Bind(
348      &VideoEncoderTester::DataAvailable, base::Unretained(tester)));
349}
350
351void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
352  const int kSizes[] = {320, 319, 317, 150};
353
354  VideoEncoderMessageTester message_tester;
355  message_tester.set_strict(strict);
356
357  VideoEncoderTester tester(&message_tester);
358
359  scoped_ptr<uint8[]> memory;
360
361  for (size_t xi = 0; xi < arraysize(kSizes); ++xi) {
362    for (size_t yi = 0; yi < arraysize(kSizes); ++yi) {
363      SkISize size = SkISize::Make(kSizes[xi], kSizes[yi]);
364      scoped_refptr<media::ScreenCaptureData> data =
365          PrepareEncodeData(size, &memory);
366      std::vector<std::vector<SkIRect> > test_rect_lists =
367          MakeTestRectLists(size);
368      for (size_t i = 0; i < test_rect_lists.size(); ++i) {
369        const std::vector<SkIRect>& test_rects = test_rect_lists[i];
370        TestEncodingRects(encoder, &tester, data,
371                          &test_rects[0], test_rects.size());
372      }
373    }
374  }
375}
376
377static void TestEncodeDecodeRects(VideoEncoder* encoder,
378                                  VideoEncoderTester* encoder_tester,
379                                  VideoDecoderTester* decoder_tester,
380                                  scoped_refptr<media::ScreenCaptureData> data,
381                                  const SkIRect* rects, int count) {
382  data->mutable_dirty_region().setRects(rects, count);
383  encoder_tester->AddRects(rects, count);
384  decoder_tester->AddRects(rects, count);
385
386  // Generate random data for the updated region.
387  srand(0);
388  for (int i = 0; i < count; ++i) {
389    const int bytes_per_pixel = 4;  // Because of RGB32 on previous line.
390    const int row_size = bytes_per_pixel * rects[i].width();
391    uint8* memory = data->data() +
392      data->stride() * rects[i].top() +
393      bytes_per_pixel * rects[i].left();
394    for (int y = 0; y < rects[i].height(); ++y) {
395      for (int x = 0; x < row_size; ++x)
396        memory[x] = rand() % 256;
397      memory += data->stride();
398    }
399  }
400
401  encoder->Encode(data, true, base::Bind(&VideoEncoderTester::DataAvailable,
402                                         base::Unretained(encoder_tester)));
403  decoder_tester->VerifyResults();
404  decoder_tester->Reset();
405}
406
407void TestVideoEncoderDecoder(
408    VideoEncoder* encoder, VideoDecoder* decoder, bool strict) {
409  SkISize kSize = SkISize::Make(320, 240);
410
411  VideoEncoderMessageTester message_tester;
412  message_tester.set_strict(strict);
413
414  VideoEncoderTester encoder_tester(&message_tester);
415
416  scoped_ptr<uint8[]> memory;
417  scoped_refptr<media::ScreenCaptureData> data =
418      PrepareEncodeData(kSize, &memory);
419
420  VideoDecoderTester decoder_tester(decoder, kSize, kSize);
421  decoder_tester.set_strict(strict);
422  decoder_tester.set_capture_data(data);
423  encoder_tester.set_decoder_tester(&decoder_tester);
424
425  std::vector<std::vector<SkIRect> > test_rect_lists = MakeTestRectLists(kSize);
426  for (size_t i = 0; i < test_rect_lists.size(); ++i) {
427    const std::vector<SkIRect> test_rects = test_rect_lists[i];
428    TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
429                          &test_rects[0], test_rects.size());
430  }
431}
432
433static void FillWithGradient(uint8* memory, const SkISize& frame_size,
434                             const SkIRect& rect) {
435  for (int j = rect.top(); j < rect.bottom(); ++j) {
436    uint8* p = memory + ((j * frame_size.width()) + rect.left()) * 4;
437    for (int i = rect.left(); i < rect.right(); ++i) {
438      *p++ = static_cast<uint8>((255.0 * i) / frame_size.width());
439      *p++ = static_cast<uint8>((164.0 * j) / frame_size.height());
440      *p++ = static_cast<uint8>((82.0 * (i + j)) /
441                                   (frame_size.width() + frame_size.height()));
442      *p++ = 0;
443    }
444  }
445}
446
447void TestVideoEncoderDecoderGradient(VideoEncoder* encoder,
448                                     VideoDecoder* decoder,
449                                     const SkISize& screen_size,
450                                     const SkISize& view_size,
451                                     double max_error_limit,
452                                     double mean_error_limit) {
453  SkIRect screen_rect = SkIRect::MakeSize(screen_size);
454  scoped_ptr<uint8[]> screen_data(new uint8[
455      screen_size.width() * screen_size.height() * kBytesPerPixel]);
456  FillWithGradient(screen_data.get(), screen_size, screen_rect);
457
458  SkIRect view_rect = SkIRect::MakeSize(view_size);
459  scoped_ptr<uint8[]> expected_view_data(new uint8[
460      view_size.width() * view_size.height() * kBytesPerPixel]);
461  FillWithGradient(expected_view_data.get(), view_size, view_rect);
462
463  scoped_refptr<media::ScreenCaptureData> capture_data =
464      new media::ScreenCaptureData(
465          screen_data.get(), screen_size.width() * kBytesPerPixel, screen_size);
466  capture_data->mutable_dirty_region().op(screen_rect, SkRegion::kUnion_Op);
467
468  VideoDecoderTester decoder_tester(decoder, screen_size, view_size);
469  decoder_tester.set_capture_data(capture_data);
470  decoder_tester.AddRegion(capture_data->dirty_region());
471
472  encoder->Encode(capture_data, true,
473                  base::Bind(&VideoDecoderTester::ReceivedScopedPacket,
474                             base::Unretained(&decoder_tester)));
475
476  decoder_tester.VerifyResultsApprox(expected_view_data.get(),
477                                     max_error_limit, mean_error_limit);
478
479  // Check that the decoder correctly re-renders the frame if its client
480  // invalidates the frame.
481  decoder_tester.ResetRenderedData();
482  decoder->Invalidate(view_size, SkRegion(view_rect));
483  decoder_tester.RenderFrame();
484  decoder_tester.VerifyResultsApprox(expected_view_data.get(),
485                                     max_error_limit, mean_error_limit);
486}
487
488}  // namespace remoting
489