OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 Google Inc. | 2 * Copyright 2012 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "PictureRenderer.h" | 8 #include "PictureRenderer.h" |
9 #include "picture_utils.h" | 9 #include "picture_utils.h" |
10 #include "SamplePipeControllers.h" | 10 #include "SamplePipeControllers.h" |
(...skipping 210 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
221 */ | 221 */ |
222 void PictureRenderer::buildBBoxHierarchy() { | 222 void PictureRenderer::buildBBoxHierarchy() { |
223 SkASSERT(fPicture); | 223 SkASSERT(fPicture); |
224 if (kNone_BBoxHierarchyType != fBBoxHierarchyType && fPicture) { | 224 if (kNone_BBoxHierarchyType != fBBoxHierarchyType && fPicture) { |
225 SkAutoTDelete<SkBBHFactory> factory(this->getFactory()); | 225 SkAutoTDelete<SkBBHFactory> factory(this->getFactory()); |
226 SkPictureRecorder recorder; | 226 SkPictureRecorder recorder; |
227 uint32_t flags = this->recordFlags(); | 227 uint32_t flags = this->recordFlags(); |
228 if (fUseMultiPictureDraw) { | 228 if (fUseMultiPictureDraw) { |
229 flags |= SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag; | 229 flags |= SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag; |
230 } | 230 } |
231 SkCanvas* canvas = recorder.beginRecording(fPicture->cullRect().width(),
| 231 SkCanvas* canvas = recorder.beginRecording(fPicture->cullRect().width(), |
232 fPicture->cullRect().height()
, | 232 fPicture->cullRect().height()
, |
233 factory.get(), | 233 factory.get(), |
234 flags); | 234 flags); |
235 fPicture->playback(canvas); | 235 fPicture->playback(canvas); |
236 fPicture.reset(recorder.endRecording()); | 236 fPicture.reset(recorder.endRecording()); |
237 } | 237 } |
238 } | 238 } |
239 | 239 |
240 void PictureRenderer::resetState(bool callFinish) { | 240 void PictureRenderer::resetState(bool callFinish) { |
241 #if SK_SUPPORT_GPU | 241 #if SK_SUPPORT_GPU |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
369 bool onUseEncodedData(const void*, size_t) SK_OVERRIDE { return true; } | 369 bool onUseEncodedData(const void*, size_t) SK_OVERRIDE { return true; } |
370 SkData* onEncodePixels(const SkImageInfo& info, const void* pixels, | 370 SkData* onEncodePixels(const SkImageInfo& info, const void* pixels, |
371 size_t rowBytes) SK_OVERRIDE { | 371 size_t rowBytes) SK_OVERRIDE { |
372 return SkImageEncoder::EncodeData(info, pixels, rowBytes, SkImageEncoder
::kPNG_Type, 100); | 372 return SkImageEncoder::EncodeData(info, pixels, rowBytes, SkImageEncoder
::kPNG_Type, 100); |
373 } | 373 } |
374 }; | 374 }; |
375 | 375 |
376 bool RecordPictureRenderer::render(SkBitmap** out) { | 376 bool RecordPictureRenderer::render(SkBitmap** out) { |
377 SkAutoTDelete<SkBBHFactory> factory(this->getFactory()); | 377 SkAutoTDelete<SkBBHFactory> factory(this->getFactory()); |
378 SkPictureRecorder recorder; | 378 SkPictureRecorder recorder; |
379 SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(this->getViewWidth(
)), | 379 SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(this->getViewWidth(
)), |
380 SkIntToScalar(this->getViewHeight
()), | 380 SkIntToScalar(this->getViewHeight
()), |
381 factory.get(), | 381 factory.get(), |
382 this->recordFlags()); | 382 this->recordFlags()); |
383 this->scaleToScaleFactor(canvas); | 383 this->scaleToScaleFactor(canvas); |
384 fPicture->playback(canvas); | 384 fPicture->playback(canvas); |
385 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); | 385 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); |
386 if (!fWritePath.isEmpty()) { | 386 if (!fWritePath.isEmpty()) { |
387 // Record the new picture as a new SKP with PNG encoded bitmaps. | 387 // Record the new picture as a new SKP with PNG encoded bitmaps. |
388 SkString skpPath = SkOSPath::Join(fWritePath.c_str(), fInputFilename.c_s
tr()); | 388 SkString skpPath = SkOSPath::Join(fWritePath.c_str(), fInputFilename.c_s
tr()); |
389 SkFILEWStream stream(skpPath.c_str()); | 389 SkFILEWStream stream(skpPath.c_str()); |
(...skipping 18 matching lines...) Expand all Loading... |
408 } | 408 } |
409 | 409 |
410 PipeController pipeController(fCanvas.get()); | 410 PipeController pipeController(fCanvas.get()); |
411 SkGPipeWriter writer; | 411 SkGPipeWriter writer; |
412 SkCanvas* pipeCanvas = writer.startRecording(&pipeController); | 412 SkCanvas* pipeCanvas = writer.startRecording(&pipeController); |
413 pipeCanvas->drawPicture(fPicture); | 413 pipeCanvas->drawPicture(fPicture); |
414 writer.endRecording(); | 414 writer.endRecording(); |
415 fCanvas->flush(); | 415 fCanvas->flush(); |
416 if (out) { | 416 if (out) { |
417 *out = SkNEW(SkBitmap); | 417 *out = SkNEW(SkBitmap); |
418 setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), | 418 setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), |
419 SkScalarCeilToInt(fPicture->cullRect().height())); | 419 SkScalarCeilToInt(fPicture->cullRect().height())); |
420 fCanvas->readPixels(*out, 0, 0); | 420 fCanvas->readPixels(*out, 0, 0); |
421 } | 421 } |
422 if (fEnableWrites) { | 422 if (fEnableWrites) { |
423 return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSu
mmaryPtr, | 423 return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSu
mmaryPtr, |
424 fUseChecksumBasedFilenames); | 424 fUseChecksumBasedFilenames); |
425 } else { | 425 } else { |
426 return true; | 426 return true; |
427 } | 427 } |
428 } | 428 } |
429 | 429 |
430 SkString PipePictureRenderer::getConfigNameInternal() { | 430 SkString PipePictureRenderer::getConfigNameInternal() { |
431 return SkString("pipe"); | 431 return SkString("pipe"); |
432 } | 432 } |
433 | 433 |
434 ////////////////////////////////////////////////////////////////////////////////
/////////////// | 434 ////////////////////////////////////////////////////////////////////////////////
/////////////// |
435 | 435 |
436 void SimplePictureRenderer::init(const SkPicture* picture, const SkString* write
Path, | 436 void SimplePictureRenderer::init(const SkPicture* picture, const SkString* write
Path, |
437 const SkString* mismatchPath, const SkString* i
nputFilename, | 437 const SkString* mismatchPath, const SkString* i
nputFilename, |
438 bool useChecksumBasedFilenames, bool useMultiPi
ctureDraw) { | 438 bool useChecksumBasedFilenames, bool useMultiPi
ctureDraw) { |
439 INHERITED::init(picture, writePath, mismatchPath, inputFilename, | 439 INHERITED::init(picture, writePath, mismatchPath, inputFilename, |
440 useChecksumBasedFilenames, useMultiPictureDraw); | 440 useChecksumBasedFilenames, useMultiPictureDraw); |
441 this->buildBBoxHierarchy(); | 441 this->buildBBoxHierarchy(); |
442 } | 442 } |
443 | 443 |
444 bool SimplePictureRenderer::render(SkBitmap** out) { | 444 bool SimplePictureRenderer::render(SkBitmap** out) { |
445 SkASSERT(fCanvas.get() != NULL); | 445 SkASSERT(fCanvas.get() != NULL); |
446 SkASSERT(fPicture); | 446 SkASSERT(fPicture); |
447 if (NULL == fCanvas.get() || NULL == fPicture) { | 447 if (NULL == fCanvas.get() || NULL == fPicture) { |
448 return false; | 448 return false; |
449 } | 449 } |
450 | 450 |
451 if (fUseMultiPictureDraw) { | 451 if (fUseMultiPictureDraw) { |
452 SkMultiPictureDraw mpd; | 452 SkMultiPictureDraw mpd; |
453 | 453 |
454 mpd.add(fCanvas, fPicture); | 454 mpd.add(fCanvas, fPicture); |
455 | 455 |
456 mpd.draw(); | 456 mpd.draw(); |
457 } else { | 457 } else { |
458 fCanvas->drawPicture(fPicture); | 458 fCanvas->drawPicture(fPicture); |
459 } | 459 } |
460 fCanvas->flush(); | 460 fCanvas->flush(); |
461 if (out) { | 461 if (out) { |
462 *out = SkNEW(SkBitmap); | 462 *out = SkNEW(SkBitmap); |
463 setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), | 463 setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), |
464 SkScalarCeilToInt(fPicture->cullRect().height())); | 464 SkScalarCeilToInt(fPicture->cullRect().height())); |
465 fCanvas->readPixels(*out, 0, 0); | 465 fCanvas->readPixels(*out, 0, 0); |
466 } | 466 } |
467 if (fEnableWrites) { | 467 if (fEnableWrites) { |
468 return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSu
mmaryPtr, | 468 return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSu
mmaryPtr, |
469 fUseChecksumBasedFilenames); | 469 fUseChecksumBasedFilenames); |
470 } else { | 470 } else { |
471 return true; | 471 return true; |
472 } | 472 } |
473 } | 473 } |
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
664 return true; | 664 return true; |
665 } | 665 } |
666 return false; | 666 return false; |
667 } | 667 } |
668 | 668 |
669 void TiledPictureRenderer::drawCurrentTile() { | 669 void TiledPictureRenderer::drawCurrentTile() { |
670 SkASSERT(fCurrentTileOffset >= 0 && fCurrentTileOffset < fTileRects.count())
; | 670 SkASSERT(fCurrentTileOffset >= 0 && fCurrentTileOffset < fTileRects.count())
; |
671 draw_tile_to_canvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture); | 671 draw_tile_to_canvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture); |
672 } | 672 } |
673 | 673 |
674 bool TiledPictureRenderer::postRender(SkCanvas* canvas, const SkIRect& tileRect,
| 674 bool TiledPictureRenderer::postRender(SkCanvas* canvas, const SkIRect& tileRect, |
675 SkBitmap* tempBM, SkBitmap** out, | 675 SkBitmap* tempBM, SkBitmap** out, |
676 int tileNumber) { | 676 int tileNumber) { |
677 bool success = true; | 677 bool success = true; |
678 | 678 |
679 if (fEnableWrites) { | 679 if (fEnableWrites) { |
680 success &= write(canvas, fWritePath, fMismatchPath, fInputFilename, fJso
nSummaryPtr, | 680 success &= write(canvas, fWritePath, fMismatchPath, fInputFilename, fJso
nSummaryPtr, |
681 fUseChecksumBasedFilenames, &tileNumber); | 681 fUseChecksumBasedFilenames, &tileNumber); |
682 } | 682 } |
683 if (out) { | 683 if (out) { |
684 if (canvas->readPixels(tempBM, 0, 0)) { | 684 if (canvas->readPixels(tempBM, 0, 0)) { |
685 // Add this tile to the entire bitmap. | 685 // Add this tile to the entire bitmap. |
686 bitmapCopyAtOffset(*tempBM, *out, tileRect.left(), tileRect.top()); | 686 bitmapCopyAtOffset(*tempBM, *out, tileRect.left(), tileRect.top()); |
687 } else { | 687 } else { |
688 success = false; | 688 success = false; |
689 } | 689 } |
690 } | 690 } |
691 | 691 |
692 return success; | 692 return success; |
693 } | 693 } |
694 | 694 |
695 bool TiledPictureRenderer::render(SkBitmap** out) { | 695 bool TiledPictureRenderer::render(SkBitmap** out) { |
696 SkASSERT(fPicture != NULL); | 696 SkASSERT(fPicture != NULL); |
697 if (NULL == fPicture) { | 697 if (NULL == fPicture) { |
698 return false; | 698 return false; |
699 } | 699 } |
700 | 700 |
701 SkBitmap bitmap; | 701 SkBitmap bitmap; |
702 if (out) { | 702 if (out) { |
703 *out = SkNEW(SkBitmap); | 703 *out = SkNEW(SkBitmap); |
704 setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), | 704 setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), |
705 SkScalarCeilToInt(fPicture->cullRect().height())); | 705 SkScalarCeilToInt(fPicture->cullRect().height())); |
706 setup_bitmap(&bitmap, fTileWidth, fTileHeight); | 706 setup_bitmap(&bitmap, fTileWidth, fTileHeight); |
707 } | 707 } |
708 bool success = true; | 708 bool success = true; |
709 | 709 |
710 if (fUseMultiPictureDraw) { | 710 if (fUseMultiPictureDraw) { |
711 SkMultiPictureDraw mpd; | 711 SkMultiPictureDraw mpd; |
712 SkTDArray<SkSurface*> surfaces; | 712 SkTDArray<SkSurface*> surfaces; |
713 surfaces.setReserve(fTileRects.count()); | 713 surfaces.setReserve(fTileRects.count()); |
714 | 714 |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
794 name.appendf("%i", fTileHeight); | 794 name.appendf("%i", fTileHeight); |
795 } | 795 } |
796 return name; | 796 return name; |
797 } | 797 } |
798 | 798 |
799 ////////////////////////////////////////////////////////////////////////////////
/////////////// | 799 ////////////////////////////////////////////////////////////////////////////////
/////////////// |
800 | 800 |
801 void PlaybackCreationRenderer::setup() { | 801 void PlaybackCreationRenderer::setup() { |
802 SkAutoTDelete<SkBBHFactory> factory(this->getFactory()); | 802 SkAutoTDelete<SkBBHFactory> factory(this->getFactory()); |
803 fRecorder.reset(SkNEW(SkPictureRecorder)); | 803 fRecorder.reset(SkNEW(SkPictureRecorder)); |
804 SkCanvas* canvas = fRecorder->beginRecording(SkIntToScalar(this->getViewWidt
h()), | 804 SkCanvas* canvas = fRecorder->beginRecording(SkIntToScalar(this->getViewWidt
h()), |
805 SkIntToScalar(this->getViewHeig
ht()), | 805 SkIntToScalar(this->getViewHeig
ht()), |
806 factory.get(), | 806 factory.get(), |
807 this->recordFlags()); | 807 this->recordFlags()); |
808 this->scaleToScaleFactor(canvas); | 808 this->scaleToScaleFactor(canvas); |
809 canvas->drawPicture(fPicture); | 809 canvas->drawPicture(fPicture); |
810 } | 810 } |
811 | 811 |
812 bool PlaybackCreationRenderer::render(SkBitmap** out) { | 812 bool PlaybackCreationRenderer::render(SkBitmap** out) { |
813 fPicture.reset(fRecorder->endRecording()); | 813 fPicture.reset(fRecorder->endRecording()); |
814 // Since this class does not actually render, return false. | 814 // Since this class does not actually render, return false. |
815 return false; | 815 return false; |
816 } | 816 } |
817 | 817 |
818 SkString PlaybackCreationRenderer::getConfigNameInternal() { | 818 SkString PlaybackCreationRenderer::getConfigNameInternal() { |
819 return SkString("playback_creation"); | 819 return SkString("playback_creation"); |
820 } | 820 } |
821 | 821 |
822 ////////////////////////////////////////////////////////////////////////////////
/////////////// | 822 ////////////////////////////////////////////////////////////////////////////////
/////////////// |
823 // SkPicture variants for each BBoxHierarchy type | 823 // SkPicture variants for each BBoxHierarchy type |
824 | 824 |
825 SkBBHFactory* PictureRenderer::getFactory() { | 825 SkBBHFactory* PictureRenderer::getFactory() { |
826 switch (fBBoxHierarchyType) { | 826 switch (fBBoxHierarchyType) { |
827 case kNone_BBoxHierarchyType: | 827 case kNone_BBoxHierarchyType: |
828 return NULL; | 828 return NULL; |
829 case kRTree_BBoxHierarchyType: | 829 case kRTree_BBoxHierarchyType: |
830 return SkNEW(SkRTreeFactory); | 830 return SkNEW(SkRTreeFactory); |
831 case kTileGrid_BBoxHierarchyType: | |
832 return SkNEW_ARGS(SkTileGridFactory, (fGridInfo)); | |
833 } | 831 } |
834 SkASSERT(0); // invalid bbhType | 832 SkASSERT(0); // invalid bbhType |
835 return NULL; | 833 return NULL; |
836 } | 834 } |
837 | 835 |
838 /////////////////////////////////////////////////////////////////////////////// | 836 /////////////////////////////////////////////////////////////////////////////// |
839 | 837 |
840 class GatherRenderer : public PictureRenderer { | 838 class GatherRenderer : public PictureRenderer { |
841 public: | 839 public: |
842 #if SK_SUPPORT_GPU | 840 #if SK_SUPPORT_GPU |
(...skipping 21 matching lines...) Expand all Loading... |
864 PictureRenderer* CreateGatherPixelRefsRenderer(const GrContext::Options& opts) { | 862 PictureRenderer* CreateGatherPixelRefsRenderer(const GrContext::Options& opts) { |
865 return SkNEW_ARGS(GatherRenderer, (opts)); | 863 return SkNEW_ARGS(GatherRenderer, (opts)); |
866 } | 864 } |
867 #else | 865 #else |
868 PictureRenderer* CreateGatherPixelRefsRenderer() { | 866 PictureRenderer* CreateGatherPixelRefsRenderer() { |
869 return SkNEW(GatherRenderer); | 867 return SkNEW(GatherRenderer); |
870 } | 868 } |
871 #endif | 869 #endif |
872 | 870 |
873 } // namespace sk_tools | 871 } // namespace sk_tools |
OLD | NEW |