Index: remoting/codec/codec_test.cc |
diff --git a/remoting/codec/codec_test.cc b/remoting/codec/codec_test.cc |
index af8b11bb362fcf09ad31dbe77e0e341e393c31e1..efcc872ab61f39c9a724bb28b068865f1c9f1a8b 100644 |
--- a/remoting/codec/codec_test.cc |
+++ b/remoting/codec/codec_test.cc |
@@ -14,27 +14,33 @@ |
#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::DesktopRect; |
+using webrtc::DesktopSize; |
namespace { |
const int kBytesPerPixel = 4; |
// Some sample rects for testing. |
-std::vector<std::vector<SkIRect> > MakeTestRectLists(const SkISize& size) { |
- std::vector<std::vector<SkIRect> > rect_lists; |
- std::vector<SkIRect> rects; |
- rects.push_back(SkIRect::MakeXYWH(0, 0, size.width(), size.height())); |
+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(SkIRect::MakeXYWH(0, 0, size.width() / 2, size.height() / 2)); |
+ rects.push_back(DesktopRect::MakeXYWH( |
+ 0, 0, size.width() / 2, size.height() / 2)); |
rect_lists.push_back(rects); |
rects.clear(); |
- rects.push_back(SkIRect::MakeXYWH(size.width() / 2, size.height() / 2, |
- size.width() / 2, size.height() / 2)); |
+ 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(SkIRect::MakeXYWH(16, 16, 16, 16)); |
- rects.push_back(SkIRect::MakeXYWH(128, 64, 32, 32)); |
+ 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; |
} |
@@ -72,10 +78,10 @@ class VideoEncoderMessageTester { |
++begin_rect_; |
if (strict_) { |
- SkIRect rect = rects_.front(); |
+ DesktopRect rect = rects_.front(); |
rects_.pop_front(); |
- EXPECT_EQ(rect.fLeft, packet->format().x()); |
- EXPECT_EQ(rect.fTop, packet->format().y()); |
+ EXPECT_EQ(rect.left(), packet->format().x()); |
+ EXPECT_EQ(rect.top(), packet->format().y()); |
EXPECT_EQ(rect.width(), packet->format().width()); |
EXPECT_EQ(rect.height(), packet->format().height()); |
} |
@@ -107,7 +113,7 @@ class VideoEncoderMessageTester { |
strict_ = strict; |
} |
- void AddRects(const SkIRect* rects, int count) { |
+ void AddRects(const DesktopRect* rects, int count) { |
rects_.insert(rects_.begin() + rects_.size(), rects, rects + count); |
added_rects_ += count; |
} |
@@ -125,15 +131,16 @@ class VideoEncoderMessageTester { |
State state_; |
bool strict_; |
- std::deque<SkIRect> rects_; |
+ std::deque<DesktopRect> rects_; |
DISALLOW_COPY_AND_ASSIGN(VideoEncoderMessageTester); |
}; |
class VideoDecoderTester { |
public: |
- VideoDecoderTester(VideoDecoder* decoder, const SkISize& screen_size, |
- const SkISize& view_size) |
+ VideoDecoderTester(VideoDecoder* decoder, |
+ const DesktopSize& screen_size, |
+ const DesktopSize& view_size) |
: screen_size_(screen_size), |
view_size_(view_size), |
strict_(false), |
@@ -141,11 +148,12 @@ class VideoDecoderTester { |
image_data_.reset(new uint8[ |
view_size_.width() * view_size_.height() * kBytesPerPixel]); |
EXPECT_TRUE(image_data_.get()); |
- decoder_->Initialize(screen_size_); |
+ decoder_->Initialize( |
+ SkISize::Make(screen_size_.width(), screen_size_.height())); |
} |
void Reset() { |
- expected_region_.setEmpty(); |
+ expected_region_.Clear(); |
update_region_.setEmpty(); |
} |
@@ -165,11 +173,12 @@ class VideoDecoderTester { |
} |
void RenderFrame() { |
- decoder_->RenderFrame(view_size_, |
- SkIRect::MakeSize(view_size_), |
- image_data_.get(), |
- view_size_.width() * kBytesPerPixel, |
- &update_region_); |
+ decoder_->RenderFrame( |
+ SkISize::Make(view_size_.width(), view_size_.height()), |
+ SkIRect::MakeWH(view_size_.width(), view_size_.height()), |
+ image_data_.get(), |
+ view_size_.width() * kBytesPerPixel, |
+ &update_region_); |
} |
void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) { |
@@ -180,34 +189,46 @@ class VideoDecoderTester { |
strict_ = strict; |
} |
- void set_capture_data(scoped_refptr<media::ScreenCaptureData> data) { |
- capture_data_ = data; |
+ void set_frame(webrtc::DesktopFrame* frame) { |
+ frame_ = frame; |
} |
- void AddRects(const SkIRect* rects, int count) { |
- SkRegion new_rects; |
- new_rects.setRects(rects, count); |
- AddRegion(new_rects); |
+ void AddRects(const DesktopRect* rects, int count) { |
+ for (int i = 0; i < count; ++i) { |
+ expected_region_.AddRect(rects[i]); |
+ } |
} |
- void AddRegion(const SkRegion& region) { |
- expected_region_.op(region, SkRegion::kUnion_Op); |
+ void AddRegion(const webrtc::DesktopRegion& region) { |
+ expected_region_.AddRegion(region); |
} |
void VerifyResults() { |
if (!strict_) |
return; |
- ASSERT_TRUE(capture_data_.get()); |
+ ASSERT_TRUE(frame_); |
// Test the content of the update region. |
- EXPECT_EQ(expected_region_, update_region_); |
+ // |
+ // TODO(sergeyu): Change this to use DesktopRegion when it's capable of |
+ // merging the rectangles. |
+ SkRegion expected_region; |
+ for (webrtc::DesktopRegion::Iterator it(expected_region_); |
+ !it.IsAtEnd(); it.Advance()) { |
+ expected_region.op( |
+ SkIRect::MakeXYWH(it.rect().top(), it.rect().left(), |
+ it.rect().width(), it.rect().height()), |
+ SkRegion::kUnion_Op); |
+ } |
+ EXPECT_EQ(expected_region, update_region_); |
+ |
for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) { |
const int stride = view_size_.width() * kBytesPerPixel; |
- EXPECT_EQ(stride, capture_data_->stride()); |
+ EXPECT_EQ(stride, frame_->stride()); |
const int offset = stride * i.rect().top() + |
kBytesPerPixel * i.rect().left(); |
- const uint8* original = capture_data_->data() + offset; |
+ const uint8* original = frame_->data() + offset; |
const uint8* decoded = image_data_.get() + offset; |
const int row_size = kBytesPerPixel * i.rect().width(); |
for (int y = 0; y < i.rect().height(); ++y) { |
@@ -265,14 +286,14 @@ class VideoDecoderTester { |
} |
private: |
- SkISize screen_size_; |
- SkISize view_size_; |
+ DesktopSize screen_size_; |
+ DesktopSize view_size_; |
bool strict_; |
- SkRegion expected_region_; |
+ webrtc::DesktopRegion expected_region_; |
SkRegion update_region_; |
VideoDecoder* decoder_; |
scoped_ptr<uint8[]> image_data_; |
- scoped_refptr<media::ScreenCaptureData> capture_data_; |
+ webrtc::DesktopFrame* frame_; |
DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester); |
}; |
@@ -301,7 +322,7 @@ class VideoEncoderTester { |
} |
} |
- void AddRects(const SkIRect* rects, int count) { |
+ void AddRects(const DesktopRect* rects, int count) { |
message_tester_->AddRects(rects, count); |
} |
@@ -317,34 +338,30 @@ class VideoEncoderTester { |
DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester); |
}; |
-scoped_refptr<media::ScreenCaptureData> PrepareEncodeData( |
- const SkISize& size, |
- scoped_ptr<uint8[]>* memory) { |
- int memory_size = size.width() * size.height() * kBytesPerPixel; |
- |
- memory->reset(new uint8[memory_size]); |
+scoped_ptr<webrtc::DesktopFrame> PrepareFrame(const DesktopSize& size) { |
+ scoped_ptr<webrtc::DesktopFrame> frame(new webrtc::BasicDesktopFrame(size)); |
srand(0); |
+ int memory_size = size.width() * size.height() * kBytesPerPixel; |
for (int i = 0; i < memory_size; ++i) { |
- (*memory)[i] = rand() % 256; |
+ frame->data()[i] = rand() % 256; |
} |
- scoped_refptr<media::ScreenCaptureData> data = new media::ScreenCaptureData( |
- memory->get(), size.width() * kBytesPerPixel, size); |
- return data; |
+ return frame.Pass(); |
} |
static void TestEncodingRects(VideoEncoder* encoder, |
VideoEncoderTester* tester, |
- scoped_refptr<media::ScreenCaptureData> data, |
- const SkIRect* rects, int count) { |
- data->mutable_dirty_region().setEmpty(); |
+ webrtc::DesktopFrame* frame, |
+ const DesktopRect* rects, |
+ int count) { |
+ frame->mutable_updated_region()->Clear(); |
for (int i = 0; i < count; ++i) { |
- data->mutable_dirty_region().op(rects[i], SkRegion::kUnion_Op); |
+ frame->mutable_updated_region()->AddRect(rects[i]); |
} |
tester->AddRects(rects, count); |
- encoder->Encode(data, true, base::Bind( |
+ encoder->Encode(frame, base::Bind( |
&VideoEncoderTester::DataAvailable, base::Unretained(tester))); |
} |
@@ -356,18 +373,15 @@ void TestVideoEncoder(VideoEncoder* encoder, bool strict) { |
VideoEncoderTester tester(&message_tester); |
- scoped_ptr<uint8[]> memory; |
- |
for (size_t xi = 0; xi < arraysize(kSizes); ++xi) { |
for (size_t yi = 0; yi < arraysize(kSizes); ++yi) { |
- SkISize size = SkISize::Make(kSizes[xi], kSizes[yi]); |
- scoped_refptr<media::ScreenCaptureData> data = |
- PrepareEncodeData(size, &memory); |
- std::vector<std::vector<SkIRect> > test_rect_lists = |
+ DesktopSize size = DesktopSize(kSizes[xi], kSizes[yi]); |
+ scoped_ptr<webrtc::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<SkIRect>& test_rects = test_rect_lists[i]; |
- TestEncodingRects(encoder, &tester, data, |
+ const std::vector<DesktopRect>& test_rects = test_rect_lists[i]; |
+ TestEncodingRects(encoder, &tester, frame.get(), |
&test_rects[0], test_rects.size()); |
} |
} |
@@ -377,68 +391,69 @@ void TestVideoEncoder(VideoEncoder* encoder, bool strict) { |
static void TestEncodeDecodeRects(VideoEncoder* encoder, |
VideoEncoderTester* encoder_tester, |
VideoDecoderTester* decoder_tester, |
- scoped_refptr<media::ScreenCaptureData> data, |
- const SkIRect* rects, int count) { |
- data->mutable_dirty_region().setRects(rects, count); |
+ webrtc::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]); |
+ } |
encoder_tester->AddRects(rects, count); |
decoder_tester->AddRects(rects, count); |
// Generate random data for the updated region. |
srand(0); |
for (int i = 0; i < count; ++i) { |
- const int bytes_per_pixel = 4; // Because of RGB32 on previous line. |
- const int row_size = bytes_per_pixel * rects[i].width(); |
- uint8* memory = data->data() + |
- data->stride() * rects[i].top() + |
- bytes_per_pixel * rects[i].left(); |
+ const int row_size = |
+ webrtc::DesktopFrame::kBytesPerPixel * rects[i].width(); |
+ uint8* memory = frame->data() + |
+ frame->stride() * rects[i].top() + |
+ webrtc::DesktopFrame::kBytesPerPixel * rects[i].left(); |
for (int y = 0; y < rects[i].height(); ++y) { |
for (int x = 0; x < row_size; ++x) |
memory[x] = rand() % 256; |
- memory += data->stride(); |
+ memory += frame->stride(); |
} |
} |
- encoder->Encode(data, true, base::Bind(&VideoEncoderTester::DataAvailable, |
- base::Unretained(encoder_tester))); |
+ encoder->Encode(frame, base::Bind(&VideoEncoderTester::DataAvailable, |
+ base::Unretained(encoder_tester))); |
decoder_tester->VerifyResults(); |
decoder_tester->Reset(); |
} |
void TestVideoEncoderDecoder( |
VideoEncoder* encoder, VideoDecoder* decoder, bool strict) { |
- SkISize kSize = SkISize::Make(320, 240); |
+ DesktopSize kSize = DesktopSize(320, 240); |
VideoEncoderMessageTester message_tester; |
message_tester.set_strict(strict); |
VideoEncoderTester encoder_tester(&message_tester); |
- scoped_ptr<uint8[]> memory; |
- scoped_refptr<media::ScreenCaptureData> data = |
- PrepareEncodeData(kSize, &memory); |
+ scoped_ptr<webrtc::DesktopFrame> frame = PrepareFrame(kSize); |
VideoDecoderTester decoder_tester(decoder, kSize, kSize); |
decoder_tester.set_strict(strict); |
- decoder_tester.set_capture_data(data); |
+ decoder_tester.set_frame(frame.get()); |
encoder_tester.set_decoder_tester(&decoder_tester); |
- std::vector<std::vector<SkIRect> > test_rect_lists = MakeTestRectLists(kSize); |
+ std::vector<std::vector<DesktopRect> > test_rect_lists = |
+ MakeTestRectLists(kSize); |
for (size_t i = 0; i < test_rect_lists.size(); ++i) { |
- const std::vector<SkIRect> test_rects = test_rect_lists[i]; |
- TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data, |
- &test_rects[0], test_rects.size()); |
+ const std::vector<DesktopRect> test_rects = test_rect_lists[i]; |
+ TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, |
+ frame.get(), &test_rects[0], test_rects.size()); |
} |
} |
-static void FillWithGradient(uint8* memory, const SkISize& frame_size, |
- const SkIRect& rect) { |
- for (int j = rect.top(); j < rect.bottom(); ++j) { |
- uint8* p = memory + ((j * frame_size.width()) + rect.left()) * 4; |
- for (int i = rect.left(); i < rect.right(); ++i) { |
- *p++ = static_cast<uint8>((255.0 * i) / frame_size.width()); |
- *p++ = static_cast<uint8>((164.0 * j) / frame_size.height()); |
- *p++ = static_cast<uint8>((82.0 * (i + j)) / |
- (frame_size.width() + frame_size.height())); |
+static void FillWithGradient(webrtc::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)) / |
+ (frame->size().width() + frame->size().height()); |
*p++ = 0; |
} |
} |
@@ -446,42 +461,38 @@ static void FillWithGradient(uint8* memory, const SkISize& frame_size, |
void TestVideoEncoderDecoderGradient(VideoEncoder* encoder, |
VideoDecoder* decoder, |
- const SkISize& screen_size, |
- const SkISize& view_size, |
+ const DesktopSize& screen_size, |
+ const DesktopSize& view_size, |
double max_error_limit, |
double mean_error_limit) { |
- SkIRect screen_rect = SkIRect::MakeSize(screen_size); |
- scoped_ptr<uint8[]> screen_data(new uint8[ |
- screen_size.width() * screen_size.height() * kBytesPerPixel]); |
- FillWithGradient(screen_data.get(), screen_size, screen_rect); |
- |
- SkIRect view_rect = SkIRect::MakeSize(view_size); |
- scoped_ptr<uint8[]> expected_view_data(new uint8[ |
- view_size.width() * view_size.height() * kBytesPerPixel]); |
- FillWithGradient(expected_view_data.get(), view_size, view_rect); |
+ scoped_ptr<webrtc::BasicDesktopFrame> frame( |
+ new webrtc::BasicDesktopFrame(screen_size)); |
+ FillWithGradient(frame.get()); |
+ frame->mutable_updated_region()->SetRect(DesktopRect::MakeSize(screen_size)); |
- scoped_refptr<media::ScreenCaptureData> capture_data = |
- new media::ScreenCaptureData( |
- screen_data.get(), screen_size.width() * kBytesPerPixel, screen_size); |
- capture_data->mutable_dirty_region().op(screen_rect, SkRegion::kUnion_Op); |
+ scoped_ptr<webrtc::BasicDesktopFrame> expected_result( |
+ new webrtc::BasicDesktopFrame(view_size)); |
+ FillWithGradient(expected_result.get()); |
VideoDecoderTester decoder_tester(decoder, screen_size, view_size); |
- decoder_tester.set_capture_data(capture_data); |
- decoder_tester.AddRegion(capture_data->dirty_region()); |
+ decoder_tester.set_frame(frame.get()); |
+ decoder_tester.AddRegion(frame->updated_region()); |
- encoder->Encode(capture_data, true, |
+ encoder->Encode(frame.get(), |
base::Bind(&VideoDecoderTester::ReceivedScopedPacket, |
base::Unretained(&decoder_tester))); |
- decoder_tester.VerifyResultsApprox(expected_view_data.get(), |
+ decoder_tester.VerifyResultsApprox(expected_result->data(), |
max_error_limit, mean_error_limit); |
// Check that the decoder correctly re-renders the frame if its client |
// invalidates the frame. |
decoder_tester.ResetRenderedData(); |
- decoder->Invalidate(view_size, SkRegion(view_rect)); |
+ decoder->Invalidate( |
+ SkISize::Make(view_size.width(), view_size.height()), |
+ SkRegion(SkIRect::MakeWH(view_size.width(), view_size.height()))); |
decoder_tester.RenderFrame(); |
- decoder_tester.VerifyResultsApprox(expected_view_data.get(), |
+ decoder_tester.VerifyResultsApprox(expected_result->data(), |
max_error_limit, mean_error_limit); |
} |