SkDescriptor.cpp 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
  1. /*
  2. * Copyright 2019 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/SkDescriptor.h"
  8. #include <new>
  9. #include "include/core/SkTypes.h"
  10. #include "include/private/SkTo.h"
  11. #include "src/core/SkOpts.h"
  12. std::unique_ptr<SkDescriptor> SkDescriptor::Alloc(size_t length) {
  13. SkASSERT(SkAlign4(length) == length);
  14. return std::unique_ptr<SkDescriptor>(static_cast<SkDescriptor*>(::operator new (length)));
  15. }
  16. void SkDescriptor::operator delete(void* p) { ::operator delete(p); }
  17. void* SkDescriptor::addEntry(uint32_t tag, size_t length, const void* data) {
  18. SkASSERT(tag);
  19. SkASSERT(SkAlign4(length) == length);
  20. SkASSERT(this->findEntry(tag, nullptr) == nullptr);
  21. Entry* entry = (Entry*)((char*)this + fLength);
  22. entry->fTag = tag;
  23. entry->fLen = SkToU32(length);
  24. if (data) {
  25. memcpy(entry + 1, data, length);
  26. }
  27. fCount += 1;
  28. fLength = SkToU32(fLength + sizeof(Entry) + length);
  29. return (entry + 1); // return its data
  30. }
  31. void SkDescriptor::computeChecksum() {
  32. fChecksum = SkDescriptor::ComputeChecksum(this);
  33. }
  34. const void* SkDescriptor::findEntry(uint32_t tag, uint32_t* length) const {
  35. const Entry* entry = (const Entry*)(this + 1);
  36. int count = fCount;
  37. while (--count >= 0) {
  38. if (entry->fTag == tag) {
  39. if (length) {
  40. *length = entry->fLen;
  41. }
  42. return entry + 1;
  43. }
  44. entry = (const Entry*)((const char*)(entry + 1) + entry->fLen);
  45. }
  46. return nullptr;
  47. }
  48. std::unique_ptr<SkDescriptor> SkDescriptor::copy() const {
  49. std::unique_ptr<SkDescriptor> desc = SkDescriptor::Alloc(fLength);
  50. memcpy(desc.get(), this, fLength);
  51. return desc;
  52. }
  53. bool SkDescriptor::operator==(const SkDescriptor& other) const {
  54. // the first value we should look at is the checksum, so this loop
  55. // should terminate early if they descriptors are different.
  56. // NOTE: if we wrote a sentinel value at the end of each, we could
  57. // remove the aa < stop test in the loop...
  58. const uint32_t* aa = (const uint32_t*)this;
  59. const uint32_t* bb = (const uint32_t*)&other;
  60. const uint32_t* stop = (const uint32_t*)((const char*)aa + fLength);
  61. do {
  62. if (*aa++ != *bb++)
  63. return false;
  64. } while (aa < stop);
  65. return true;
  66. }
  67. uint32_t SkDescriptor::ComputeChecksum(const SkDescriptor* desc) {
  68. const uint32_t* ptr = (const uint32_t*)desc + 1; // skip the checksum field
  69. size_t len = desc->fLength - sizeof(uint32_t);
  70. return SkOpts::hash(ptr, len);
  71. }
  72. bool SkDescriptor::isValid() const {
  73. uint32_t count = 0;
  74. size_t offset = sizeof(SkDescriptor);
  75. while (offset < fLength) {
  76. const Entry* entry = (const Entry*)(reinterpret_cast<const char*>(this) + offset);
  77. // rec tags are always a known size.
  78. if (entry->fTag == kRec_SkDescriptorTag && entry->fLen != sizeof(SkScalerContextRec)) {
  79. return false;
  80. }
  81. offset += sizeof(Entry) + entry->fLen;
  82. count++;
  83. }
  84. return offset <= fLength && count == fCount;
  85. }
  86. SkAutoDescriptor::SkAutoDescriptor() = default;
  87. SkAutoDescriptor::SkAutoDescriptor(size_t size) { this->reset(size); }
  88. SkAutoDescriptor::SkAutoDescriptor(const SkDescriptor& desc) { this->reset(desc); }
  89. SkAutoDescriptor::SkAutoDescriptor(const SkAutoDescriptor& ad) {
  90. this->reset(*ad.getDesc());
  91. }
  92. SkAutoDescriptor& SkAutoDescriptor::operator=(const SkAutoDescriptor& ad) {
  93. this->reset(*ad.getDesc());
  94. return *this;
  95. }
  96. SkAutoDescriptor::~SkAutoDescriptor() { this->free(); }
  97. void SkAutoDescriptor::reset(size_t size) {
  98. this->free();
  99. if (size <= sizeof(fStorage)) {
  100. fDesc = reinterpret_cast<SkDescriptor*>(&fStorage);
  101. } else {
  102. fDesc = SkDescriptor::Alloc(size).release();
  103. }
  104. }
  105. void SkAutoDescriptor::reset(const SkDescriptor& desc) {
  106. size_t size = desc.getLength();
  107. this->reset(size);
  108. memcpy(fDesc, &desc, size);
  109. }
  110. void SkAutoDescriptor::free() {
  111. if (fDesc != (SkDescriptor*)&fStorage) {
  112. delete fDesc;
  113. }
  114. }