SkData.cpp 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
  1. /*
  2. * Copyright 2011 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 "include/core/SkData.h"
  8. #include "include/core/SkStream.h"
  9. #include "include/private/SkOnce.h"
  10. #include "src/core/SkOSFile.h"
  11. #include "src/core/SkReadBuffer.h"
  12. #include "src/core/SkWriteBuffer.h"
  13. #include <new>
  14. SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context) {
  15. fPtr = const_cast<void*>(ptr);
  16. fSize = size;
  17. fReleaseProc = proc;
  18. fReleaseProcContext = context;
  19. }
  20. /** This constructor means we are inline with our fPtr's contents.
  21. * Thus we set fPtr to point right after this.
  22. */
  23. SkData::SkData(size_t size) {
  24. fPtr = (char*)(this + 1); // contents are immediately after this
  25. fSize = size;
  26. fReleaseProc = nullptr;
  27. fReleaseProcContext = nullptr;
  28. }
  29. SkData::~SkData() {
  30. if (fReleaseProc) {
  31. fReleaseProc(fPtr, fReleaseProcContext);
  32. }
  33. }
  34. bool SkData::equals(const SkData* other) const {
  35. if (nullptr == other) {
  36. return false;
  37. }
  38. return fSize == other->fSize && !memcmp(fPtr, other->fPtr, fSize);
  39. }
  40. size_t SkData::copyRange(size_t offset, size_t length, void* buffer) const {
  41. size_t available = fSize;
  42. if (offset >= available || 0 == length) {
  43. return 0;
  44. }
  45. available -= offset;
  46. if (length > available) {
  47. length = available;
  48. }
  49. SkASSERT(length > 0);
  50. memcpy(buffer, this->bytes() + offset, length);
  51. return length;
  52. }
  53. void SkData::operator delete(void* p) {
  54. ::operator delete(p);
  55. }
  56. sk_sp<SkData> SkData::PrivateNewWithCopy(const void* srcOrNull, size_t length) {
  57. if (0 == length) {
  58. return SkData::MakeEmpty();
  59. }
  60. const size_t actualLength = length + sizeof(SkData);
  61. SkASSERT_RELEASE(length < actualLength); // Check for overflow.
  62. void* storage = ::operator new (actualLength);
  63. sk_sp<SkData> data(new (storage) SkData(length));
  64. if (srcOrNull) {
  65. memcpy(data->writable_data(), srcOrNull, length);
  66. }
  67. return data;
  68. }
  69. void SkData::DummyReleaseProc(const void*, void*) {}
  70. ///////////////////////////////////////////////////////////////////////////////
  71. sk_sp<SkData> SkData::MakeEmpty() {
  72. static SkOnce once;
  73. static SkData* empty;
  74. once([]{ empty = new SkData(nullptr, 0, nullptr, nullptr); });
  75. return sk_ref_sp(empty);
  76. }
  77. // assumes fPtr was allocated via sk_malloc
  78. static void sk_free_releaseproc(const void* ptr, void*) {
  79. sk_free((void*)ptr);
  80. }
  81. sk_sp<SkData> SkData::MakeFromMalloc(const void* data, size_t length) {
  82. return sk_sp<SkData>(new SkData(data, length, sk_free_releaseproc, nullptr));
  83. }
  84. sk_sp<SkData> SkData::MakeWithCopy(const void* src, size_t length) {
  85. SkASSERT(src);
  86. return PrivateNewWithCopy(src, length);
  87. }
  88. sk_sp<SkData> SkData::MakeUninitialized(size_t length) {
  89. return PrivateNewWithCopy(nullptr, length);
  90. }
  91. sk_sp<SkData> SkData::MakeWithProc(const void* ptr, size_t length, ReleaseProc proc, void* ctx) {
  92. return sk_sp<SkData>(new SkData(ptr, length, proc, ctx));
  93. }
  94. // assumes fPtr was allocated with sk_fmmap
  95. static void sk_mmap_releaseproc(const void* addr, void* ctx) {
  96. size_t length = reinterpret_cast<size_t>(ctx);
  97. sk_fmunmap(addr, length);
  98. }
  99. sk_sp<SkData> SkData::MakeFromFILE(FILE* f) {
  100. size_t size;
  101. void* addr = sk_fmmap(f, &size);
  102. if (nullptr == addr) {
  103. return nullptr;
  104. }
  105. return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
  106. }
  107. sk_sp<SkData> SkData::MakeFromFileName(const char path[]) {
  108. FILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : nullptr;
  109. if (nullptr == f) {
  110. return nullptr;
  111. }
  112. auto data = MakeFromFILE(f);
  113. sk_fclose(f);
  114. return data;
  115. }
  116. sk_sp<SkData> SkData::MakeFromFD(int fd) {
  117. size_t size;
  118. void* addr = sk_fdmmap(fd, &size);
  119. if (nullptr == addr) {
  120. return nullptr;
  121. }
  122. return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
  123. }
  124. // assumes context is a SkData
  125. static void sk_dataref_releaseproc(const void*, void* context) {
  126. SkData* src = reinterpret_cast<SkData*>(context);
  127. src->unref();
  128. }
  129. sk_sp<SkData> SkData::MakeSubset(const SkData* src, size_t offset, size_t length) {
  130. /*
  131. We could, if we wanted/need to, just make a deep copy of src's data,
  132. rather than referencing it. This would duplicate the storage (of the
  133. subset amount) but would possibly allow src to go out of scope sooner.
  134. */
  135. size_t available = src->size();
  136. if (offset >= available || 0 == length) {
  137. return SkData::MakeEmpty();
  138. }
  139. available -= offset;
  140. if (length > available) {
  141. length = available;
  142. }
  143. SkASSERT(length > 0);
  144. src->ref(); // this will be balanced in sk_dataref_releaseproc
  145. return sk_sp<SkData>(new SkData(src->bytes() + offset, length, sk_dataref_releaseproc,
  146. const_cast<SkData*>(src)));
  147. }
  148. sk_sp<SkData> SkData::MakeWithCString(const char cstr[]) {
  149. size_t size;
  150. if (nullptr == cstr) {
  151. cstr = "";
  152. size = 1;
  153. } else {
  154. size = strlen(cstr) + 1;
  155. }
  156. return MakeWithCopy(cstr, size);
  157. }
  158. ///////////////////////////////////////////////////////////////////////////////
  159. sk_sp<SkData> SkData::MakeFromStream(SkStream* stream, size_t size) {
  160. sk_sp<SkData> data(SkData::MakeUninitialized(size));
  161. if (stream->read(data->writable_data(), size) != size) {
  162. return nullptr;
  163. }
  164. return data;
  165. }