SkCanvasPriv.cpp 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
  1. /*
  2. * Copyright 2018 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #include "src/core/SkAutoMalloc.h"
  8. #include "src/core/SkCanvasPriv.h"
  9. #include "src/core/SkReadBuffer.h"
  10. #include "src/core/SkWriter32.h"
  11. SkAutoCanvasMatrixPaint::SkAutoCanvasMatrixPaint(SkCanvas* canvas, const SkMatrix* matrix,
  12. const SkPaint* paint, const SkRect& bounds)
  13. : fCanvas(canvas)
  14. , fSaveCount(canvas->getSaveCount())
  15. {
  16. if (paint) {
  17. SkRect newBounds = bounds;
  18. if (matrix) {
  19. matrix->mapRect(&newBounds);
  20. }
  21. canvas->saveLayer(&newBounds, paint);
  22. } else if (matrix) {
  23. canvas->save();
  24. }
  25. if (matrix) {
  26. canvas->concat(*matrix);
  27. }
  28. }
  29. SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
  30. fCanvas->restoreToCount(fSaveCount);
  31. }
  32. ///////////////////////////////////////////////////////////////////////////////////////////////////
  33. bool SkCanvasPriv::ReadLattice(SkReadBuffer& buffer, SkCanvas::Lattice* lattice) {
  34. lattice->fXCount = buffer.readInt();
  35. lattice->fXDivs = buffer.skipT<int32_t>(lattice->fXCount);
  36. lattice->fYCount = buffer.readInt();
  37. lattice->fYDivs = buffer.skipT<int32_t>(lattice->fYCount);
  38. int flagCount = buffer.readInt();
  39. lattice->fRectTypes = nullptr;
  40. lattice->fColors = nullptr;
  41. if (flagCount) {
  42. lattice->fRectTypes = buffer.skipT<SkCanvas::Lattice::RectType>(flagCount);
  43. lattice->fColors = buffer.skipT<SkColor>(flagCount);
  44. }
  45. lattice->fBounds = buffer.skipT<SkIRect>();
  46. return buffer.isValid();
  47. }
  48. size_t SkCanvasPriv::WriteLattice(void* buffer, const SkCanvas::Lattice& lattice) {
  49. int flagCount = lattice.fRectTypes ? (lattice.fXCount + 1) * (lattice.fYCount + 1) : 0;
  50. const size_t size = (1 + lattice.fXCount + 1 + lattice.fYCount + 1) * sizeof(int32_t) +
  51. SkAlign4(flagCount * sizeof(SkCanvas::Lattice::RectType)) +
  52. SkAlign4(flagCount * sizeof(SkColor)) +
  53. sizeof(SkIRect);
  54. if (buffer) {
  55. SkWriter32 writer(buffer, size);
  56. writer.write32(lattice.fXCount);
  57. writer.write(lattice.fXDivs, lattice.fXCount * sizeof(uint32_t));
  58. writer.write32(lattice.fYCount);
  59. writer.write(lattice.fYDivs, lattice.fYCount * sizeof(uint32_t));
  60. writer.write32(flagCount);
  61. writer.writePad(lattice.fRectTypes, flagCount * sizeof(uint8_t));
  62. writer.write(lattice.fColors, flagCount * sizeof(SkColor));
  63. SkASSERT(lattice.fBounds);
  64. writer.write(lattice.fBounds, sizeof(SkIRect));
  65. SkASSERT(writer.bytesWritten() == size);
  66. }
  67. return size;
  68. };
  69. void SkCanvasPriv::WriteLattice(SkWriteBuffer& buffer, const SkCanvas::Lattice& lattice) {
  70. const size_t size = WriteLattice(nullptr, lattice);
  71. SkAutoSMalloc<1024> storage(size);
  72. WriteLattice(storage.get(), lattice);
  73. buffer.writePad32(storage.get(), size);
  74. }
  75. void SkCanvasPriv::GetDstClipAndMatrixCounts(const SkCanvas::ImageSetEntry set[], int count,
  76. int* totalDstClipCount, int* totalMatrixCount) {
  77. int dstClipCount = 0;
  78. int maxMatrixIndex = -1;
  79. for (int i = 0; i < count; ++i) {
  80. dstClipCount += 4 * set[i].fHasClip;
  81. if (set[i].fMatrixIndex > maxMatrixIndex) {
  82. maxMatrixIndex = set[i].fMatrixIndex;
  83. }
  84. }
  85. *totalDstClipCount = dstClipCount;
  86. *totalMatrixCount = maxMatrixIndex + 1;
  87. }