OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <deque> | 5 #include <deque> |
6 #include <stdlib.h> | 6 #include <stdlib.h> |
7 | 7 |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
(...skipping 162 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
173 } | 173 } |
174 | 174 |
175 void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) { | 175 void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) { |
176 ReceivedPacket(packet.get()); | 176 ReceivedPacket(packet.get()); |
177 } | 177 } |
178 | 178 |
179 void set_strict(bool strict) { | 179 void set_strict(bool strict) { |
180 strict_ = strict; | 180 strict_ = strict; |
181 } | 181 } |
182 | 182 |
183 void set_capture_data(scoped_refptr<CaptureData> data) { | 183 void set_capture_data(scoped_refptr<media::ScreenCaptureData> data) { |
184 capture_data_ = data; | 184 capture_data_ = data; |
185 } | 185 } |
186 | 186 |
187 void AddRects(const SkIRect* rects, int count) { | 187 void AddRects(const SkIRect* rects, int count) { |
188 SkRegion new_rects; | 188 SkRegion new_rects; |
189 new_rects.setRects(rects, count); | 189 new_rects.setRects(rects, count); |
190 AddRegion(new_rects); | 190 AddRegion(new_rects); |
191 } | 191 } |
192 | 192 |
193 void AddRegion(const SkRegion& region) { | 193 void AddRegion(const SkRegion& region) { |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
265 } | 265 } |
266 | 266 |
267 private: | 267 private: |
268 SkISize screen_size_; | 268 SkISize screen_size_; |
269 SkISize view_size_; | 269 SkISize view_size_; |
270 bool strict_; | 270 bool strict_; |
271 SkRegion expected_region_; | 271 SkRegion expected_region_; |
272 SkRegion update_region_; | 272 SkRegion update_region_; |
273 VideoDecoder* decoder_; | 273 VideoDecoder* decoder_; |
274 scoped_array<uint8> image_data_; | 274 scoped_array<uint8> image_data_; |
275 scoped_refptr<CaptureData> capture_data_; | 275 scoped_refptr<media::ScreenCaptureData> capture_data_; |
276 | 276 |
277 DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester); | 277 DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester); |
278 }; | 278 }; |
279 | 279 |
280 // The VideoEncoderTester provides a hook for retrieving the data, and passing | 280 // The VideoEncoderTester provides a hook for retrieving the data, and passing |
281 // the message to other subprograms for validaton. | 281 // the message to other subprograms for validaton. |
282 class VideoEncoderTester { | 282 class VideoEncoderTester { |
283 public: | 283 public: |
284 VideoEncoderTester(VideoEncoderMessageTester* message_tester) | 284 VideoEncoderTester(VideoEncoderMessageTester* message_tester) |
285 : message_tester_(message_tester), | 285 : message_tester_(message_tester), |
(...skipping 24 matching lines...) Expand all Loading... |
310 } | 310 } |
311 | 311 |
312 private: | 312 private: |
313 VideoEncoderMessageTester* message_tester_; | 313 VideoEncoderMessageTester* message_tester_; |
314 VideoDecoderTester* decoder_tester_; | 314 VideoDecoderTester* decoder_tester_; |
315 int data_available_; | 315 int data_available_; |
316 | 316 |
317 DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester); | 317 DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester); |
318 }; | 318 }; |
319 | 319 |
320 scoped_refptr<CaptureData> PrepareEncodeData(const SkISize& size, | 320 scoped_refptr<media::ScreenCaptureData> PrepareEncodeData( |
321 scoped_array<uint8>* memory) { | 321 const SkISize& size, |
| 322 scoped_array<uint8>* memory) { |
322 int memory_size = size.width() * size.height() * kBytesPerPixel; | 323 int memory_size = size.width() * size.height() * kBytesPerPixel; |
323 | 324 |
324 memory->reset(new uint8[memory_size]); | 325 memory->reset(new uint8[memory_size]); |
325 | 326 |
326 srand(0); | 327 srand(0); |
327 for (int i = 0; i < memory_size; ++i) { | 328 for (int i = 0; i < memory_size; ++i) { |
328 (*memory)[i] = rand() % 256; | 329 (*memory)[i] = rand() % 256; |
329 } | 330 } |
330 | 331 |
331 scoped_refptr<CaptureData> data = | 332 scoped_refptr<media::ScreenCaptureData> data = new media::ScreenCaptureData( |
332 new CaptureData(memory->get(), size.width() * kBytesPerPixel, size); | 333 memory->get(), size.width() * kBytesPerPixel, size); |
333 return data; | 334 return data; |
334 } | 335 } |
335 | 336 |
336 static void TestEncodingRects(VideoEncoder* encoder, | 337 static void TestEncodingRects(VideoEncoder* encoder, |
337 VideoEncoderTester* tester, | 338 VideoEncoderTester* tester, |
338 scoped_refptr<CaptureData> data, | 339 scoped_refptr<media::ScreenCaptureData> data, |
339 const SkIRect* rects, int count) { | 340 const SkIRect* rects, int count) { |
340 data->mutable_dirty_region().setEmpty(); | 341 data->mutable_dirty_region().setEmpty(); |
341 for (int i = 0; i < count; ++i) { | 342 for (int i = 0; i < count; ++i) { |
342 data->mutable_dirty_region().op(rects[i], SkRegion::kUnion_Op); | 343 data->mutable_dirty_region().op(rects[i], SkRegion::kUnion_Op); |
343 } | 344 } |
344 tester->AddRects(rects, count); | 345 tester->AddRects(rects, count); |
345 | 346 |
346 encoder->Encode(data, true, base::Bind( | 347 encoder->Encode(data, true, base::Bind( |
347 &VideoEncoderTester::DataAvailable, base::Unretained(tester))); | 348 &VideoEncoderTester::DataAvailable, base::Unretained(tester))); |
348 } | 349 } |
349 | 350 |
350 void TestVideoEncoder(VideoEncoder* encoder, bool strict) { | 351 void TestVideoEncoder(VideoEncoder* encoder, bool strict) { |
351 const int kSizes[] = {320, 319, 317, 150}; | 352 const int kSizes[] = {320, 319, 317, 150}; |
352 | 353 |
353 VideoEncoderMessageTester message_tester; | 354 VideoEncoderMessageTester message_tester; |
354 message_tester.set_strict(strict); | 355 message_tester.set_strict(strict); |
355 | 356 |
356 VideoEncoderTester tester(&message_tester); | 357 VideoEncoderTester tester(&message_tester); |
357 | 358 |
358 scoped_array<uint8> memory; | 359 scoped_array<uint8> memory; |
359 | 360 |
360 for (size_t xi = 0; xi < arraysize(kSizes); ++xi) { | 361 for (size_t xi = 0; xi < arraysize(kSizes); ++xi) { |
361 for (size_t yi = 0; yi < arraysize(kSizes); ++yi) { | 362 for (size_t yi = 0; yi < arraysize(kSizes); ++yi) { |
362 SkISize size = SkISize::Make(kSizes[xi], kSizes[yi]); | 363 SkISize size = SkISize::Make(kSizes[xi], kSizes[yi]); |
363 scoped_refptr<CaptureData> data = | 364 scoped_refptr<media::ScreenCaptureData> data = |
364 PrepareEncodeData(size, &memory); | 365 PrepareEncodeData(size, &memory); |
365 std::vector<std::vector<SkIRect> > test_rect_lists = | 366 std::vector<std::vector<SkIRect> > test_rect_lists = |
366 MakeTestRectLists(size); | 367 MakeTestRectLists(size); |
367 for (size_t i = 0; i < test_rect_lists.size(); ++i) { | 368 for (size_t i = 0; i < test_rect_lists.size(); ++i) { |
368 const std::vector<SkIRect>& test_rects = test_rect_lists[i]; | 369 const std::vector<SkIRect>& test_rects = test_rect_lists[i]; |
369 TestEncodingRects(encoder, &tester, data, | 370 TestEncodingRects(encoder, &tester, data, |
370 &test_rects[0], test_rects.size()); | 371 &test_rects[0], test_rects.size()); |
371 } | 372 } |
372 } | 373 } |
373 } | 374 } |
374 } | 375 } |
375 | 376 |
376 static void TestEncodeDecodeRects(VideoEncoder* encoder, | 377 static void TestEncodeDecodeRects(VideoEncoder* encoder, |
377 VideoEncoderTester* encoder_tester, | 378 VideoEncoderTester* encoder_tester, |
378 VideoDecoderTester* decoder_tester, | 379 VideoDecoderTester* decoder_tester, |
379 scoped_refptr<CaptureData> data, | 380 scoped_refptr<media::ScreenCaptureData> data, |
380 const SkIRect* rects, int count) { | 381 const SkIRect* rects, int count) { |
381 data->mutable_dirty_region().setRects(rects, count); | 382 data->mutable_dirty_region().setRects(rects, count); |
382 encoder_tester->AddRects(rects, count); | 383 encoder_tester->AddRects(rects, count); |
383 decoder_tester->AddRects(rects, count); | 384 decoder_tester->AddRects(rects, count); |
384 | 385 |
385 // Generate random data for the updated region. | 386 // Generate random data for the updated region. |
386 srand(0); | 387 srand(0); |
387 for (int i = 0; i < count; ++i) { | 388 for (int i = 0; i < count; ++i) { |
388 const int bytes_per_pixel = 4; // Because of RGB32 on previous line. | 389 const int bytes_per_pixel = 4; // Because of RGB32 on previous line. |
389 const int row_size = bytes_per_pixel * rects[i].width(); | 390 const int row_size = bytes_per_pixel * rects[i].width(); |
(...skipping 16 matching lines...) Expand all Loading... |
406 void TestVideoEncoderDecoder( | 407 void TestVideoEncoderDecoder( |
407 VideoEncoder* encoder, VideoDecoder* decoder, bool strict) { | 408 VideoEncoder* encoder, VideoDecoder* decoder, bool strict) { |
408 SkISize kSize = SkISize::Make(320, 240); | 409 SkISize kSize = SkISize::Make(320, 240); |
409 | 410 |
410 VideoEncoderMessageTester message_tester; | 411 VideoEncoderMessageTester message_tester; |
411 message_tester.set_strict(strict); | 412 message_tester.set_strict(strict); |
412 | 413 |
413 VideoEncoderTester encoder_tester(&message_tester); | 414 VideoEncoderTester encoder_tester(&message_tester); |
414 | 415 |
415 scoped_array<uint8> memory; | 416 scoped_array<uint8> memory; |
416 scoped_refptr<CaptureData> data = PrepareEncodeData(kSize, &memory); | 417 scoped_refptr<media::ScreenCaptureData> data = |
| 418 PrepareEncodeData(kSize, &memory); |
417 | 419 |
418 VideoDecoderTester decoder_tester(decoder, kSize, kSize); | 420 VideoDecoderTester decoder_tester(decoder, kSize, kSize); |
419 decoder_tester.set_strict(strict); | 421 decoder_tester.set_strict(strict); |
420 decoder_tester.set_capture_data(data); | 422 decoder_tester.set_capture_data(data); |
421 encoder_tester.set_decoder_tester(&decoder_tester); | 423 encoder_tester.set_decoder_tester(&decoder_tester); |
422 | 424 |
423 std::vector<std::vector<SkIRect> > test_rect_lists = MakeTestRectLists(kSize); | 425 std::vector<std::vector<SkIRect> > test_rect_lists = MakeTestRectLists(kSize); |
424 for (size_t i = 0; i < test_rect_lists.size(); ++i) { | 426 for (size_t i = 0; i < test_rect_lists.size(); ++i) { |
425 const std::vector<SkIRect> test_rects = test_rect_lists[i]; | 427 const std::vector<SkIRect> test_rects = test_rect_lists[i]; |
426 TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data, | 428 TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data, |
(...skipping 24 matching lines...) Expand all Loading... |
451 SkIRect screen_rect = SkIRect::MakeSize(screen_size); | 453 SkIRect screen_rect = SkIRect::MakeSize(screen_size); |
452 scoped_array<uint8> screen_data(new uint8[ | 454 scoped_array<uint8> screen_data(new uint8[ |
453 screen_size.width() * screen_size.height() * kBytesPerPixel]); | 455 screen_size.width() * screen_size.height() * kBytesPerPixel]); |
454 FillWithGradient(screen_data.get(), screen_size, screen_rect); | 456 FillWithGradient(screen_data.get(), screen_size, screen_rect); |
455 | 457 |
456 SkIRect view_rect = SkIRect::MakeSize(view_size); | 458 SkIRect view_rect = SkIRect::MakeSize(view_size); |
457 scoped_array<uint8> expected_view_data(new uint8[ | 459 scoped_array<uint8> expected_view_data(new uint8[ |
458 view_size.width() * view_size.height() * kBytesPerPixel]); | 460 view_size.width() * view_size.height() * kBytesPerPixel]); |
459 FillWithGradient(expected_view_data.get(), view_size, view_rect); | 461 FillWithGradient(expected_view_data.get(), view_size, view_rect); |
460 | 462 |
461 scoped_refptr<CaptureData> capture_data = | 463 scoped_refptr<media::ScreenCaptureData> capture_data = |
462 new CaptureData(screen_data.get(), screen_size.width() * kBytesPerPixel, | 464 new media::ScreenCaptureData( |
463 screen_size); | 465 screen_data.get(), screen_size.width() * kBytesPerPixel, screen_size); |
464 capture_data->mutable_dirty_region().op(screen_rect, SkRegion::kUnion_Op); | 466 capture_data->mutable_dirty_region().op(screen_rect, SkRegion::kUnion_Op); |
465 | 467 |
466 VideoDecoderTester decoder_tester(decoder, screen_size, view_size); | 468 VideoDecoderTester decoder_tester(decoder, screen_size, view_size); |
467 decoder_tester.set_capture_data(capture_data); | 469 decoder_tester.set_capture_data(capture_data); |
468 decoder_tester.AddRegion(capture_data->dirty_region()); | 470 decoder_tester.AddRegion(capture_data->dirty_region()); |
469 | 471 |
470 encoder->Encode(capture_data, true, | 472 encoder->Encode(capture_data, true, |
471 base::Bind(&VideoDecoderTester::ReceivedScopedPacket, | 473 base::Bind(&VideoDecoderTester::ReceivedScopedPacket, |
472 base::Unretained(&decoder_tester))); | 474 base::Unretained(&decoder_tester))); |
473 | 475 |
474 decoder_tester.VerifyResultsApprox(expected_view_data.get(), | 476 decoder_tester.VerifyResultsApprox(expected_view_data.get(), |
475 max_error_limit, mean_error_limit); | 477 max_error_limit, mean_error_limit); |
476 | 478 |
477 // Check that the decoder correctly re-renders the frame if its client | 479 // Check that the decoder correctly re-renders the frame if its client |
478 // invalidates the frame. | 480 // invalidates the frame. |
479 decoder_tester.ResetRenderedData(); | 481 decoder_tester.ResetRenderedData(); |
480 decoder->Invalidate(view_size, SkRegion(view_rect)); | 482 decoder->Invalidate(view_size, SkRegion(view_rect)); |
481 decoder_tester.RenderFrame(); | 483 decoder_tester.RenderFrame(); |
482 decoder_tester.VerifyResultsApprox(expected_view_data.get(), | 484 decoder_tester.VerifyResultsApprox(expected_view_data.get(), |
483 max_error_limit, mean_error_limit); | 485 max_error_limit, mean_error_limit); |
484 } | 486 } |
485 | 487 |
486 } // namespace remoting | 488 } // namespace remoting |
OLD | NEW |