reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 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 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame^] | 8 | #include "include/core/SkData.h" |
| 9 | #include "include/core/SkDataTable.h" |
| 10 | #include "include/private/SkOnce.h" |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 11 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 12 | static void malloc_freeproc(void* context) { |
| 13 | sk_free(context); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 14 | } |
| 15 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 16 | // Makes empty table |
| 17 | SkDataTable::SkDataTable() { |
| 18 | fCount = 0; |
| 19 | fElemSize = 0; // 0 signals that we use fDir instead of fElems |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 20 | fU.fDir = nullptr; |
| 21 | fFreeProc = nullptr; |
| 22 | fFreeProcContext = nullptr; |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 23 | } |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 24 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 25 | SkDataTable::SkDataTable(const void* array, size_t elemSize, int count, |
| 26 | FreeProc proc, void* context) { |
| 27 | SkASSERT(count > 0); |
rmistry@google.com | c9f3b38 | 2013-04-22 12:45:30 +0000 | [diff] [blame] | 28 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 29 | fCount = count; |
| 30 | fElemSize = elemSize; // non-zero signals we use fElems instead of fDir |
| 31 | fU.fElems = (const char*)array; |
| 32 | fFreeProc = proc; |
| 33 | fFreeProcContext = context; |
| 34 | } |
| 35 | |
| 36 | SkDataTable::SkDataTable(const Dir* dir, int count, FreeProc proc, void* ctx) { |
| 37 | SkASSERT(count > 0); |
rmistry@google.com | c9f3b38 | 2013-04-22 12:45:30 +0000 | [diff] [blame] | 38 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 39 | fCount = count; |
| 40 | fElemSize = 0; // 0 signals that we use fDir instead of fElems |
| 41 | fU.fDir = dir; |
| 42 | fFreeProc = proc; |
| 43 | fFreeProcContext = ctx; |
| 44 | } |
| 45 | |
| 46 | SkDataTable::~SkDataTable() { |
| 47 | if (fFreeProc) { |
| 48 | fFreeProc(fFreeProcContext); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 49 | } |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 50 | } |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 51 | |
| 52 | size_t SkDataTable::atSize(int index) const { |
| 53 | SkASSERT((unsigned)index < (unsigned)fCount); |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 54 | |
| 55 | if (fElemSize) { |
| 56 | return fElemSize; |
| 57 | } else { |
| 58 | return fU.fDir[index].fSize; |
| 59 | } |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 60 | } |
| 61 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 62 | const void* SkDataTable::at(int index, size_t* size) const { |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 63 | SkASSERT((unsigned)index < (unsigned)fCount); |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 64 | |
| 65 | if (fElemSize) { |
| 66 | if (size) { |
| 67 | *size = fElemSize; |
| 68 | } |
| 69 | return fU.fElems + index * fElemSize; |
| 70 | } else { |
| 71 | if (size) { |
| 72 | *size = fU.fDir[index].fSize; |
| 73 | } |
| 74 | return fU.fDir[index].fPtr; |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 75 | } |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 76 | } |
| 77 | |
reed@google.com | 3cceb9f | 2013-04-19 20:22:39 +0000 | [diff] [blame] | 78 | /////////////////////////////////////////////////////////////////////////////// |
| 79 | |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 80 | sk_sp<SkDataTable> SkDataTable::MakeEmpty() { |
| 81 | static SkDataTable* singleton; |
| 82 | static SkOnce once; |
| 83 | once([]{ singleton = new SkDataTable(); }); |
| 84 | return sk_ref_sp(singleton); |
reed@google.com | 3cceb9f | 2013-04-19 20:22:39 +0000 | [diff] [blame] | 85 | } |
| 86 | |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 87 | sk_sp<SkDataTable> SkDataTable::MakeCopyArrays(const void * const * ptrs, |
| 88 | const size_t sizes[], int count) { |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 89 | if (count <= 0) { |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 90 | return SkDataTable::MakeEmpty(); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 91 | } |
| 92 | |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 93 | size_t dataSize = 0; |
| 94 | for (int i = 0; i < count; ++i) { |
| 95 | dataSize += sizes[i]; |
| 96 | } |
| 97 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 98 | size_t bufferSize = count * sizeof(Dir) + dataSize; |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 99 | void* buffer = sk_malloc_throw(bufferSize); |
| 100 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 101 | Dir* dir = (Dir*)buffer; |
| 102 | char* elem = (char*)(dir + count); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 103 | for (int i = 0; i < count; ++i) { |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 104 | dir[i].fPtr = elem; |
| 105 | dir[i].fSize = sizes[i]; |
| 106 | memcpy(elem, ptrs[i], sizes[i]); |
| 107 | elem += sizes[i]; |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 108 | } |
rmistry@google.com | c9f3b38 | 2013-04-22 12:45:30 +0000 | [diff] [blame] | 109 | |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 110 | return sk_sp<SkDataTable>(new SkDataTable(dir, count, malloc_freeproc, buffer)); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 111 | } |
| 112 | |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 113 | sk_sp<SkDataTable> SkDataTable::MakeCopyArray(const void* array, size_t elemSize, int count) { |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 114 | if (count <= 0) { |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 115 | return SkDataTable::MakeEmpty(); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 116 | } |
skia.committer@gmail.com | 64b682c | 2013-04-20 07:01:07 +0000 | [diff] [blame] | 117 | |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 118 | size_t bufferSize = elemSize * count; |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 119 | void* buffer = sk_malloc_throw(bufferSize); |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 120 | memcpy(buffer, array, bufferSize); |
skia.committer@gmail.com | 64b682c | 2013-04-20 07:01:07 +0000 | [diff] [blame] | 121 | |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 122 | return sk_sp<SkDataTable>(new SkDataTable(buffer, elemSize, count, malloc_freeproc, buffer)); |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 123 | } |
| 124 | |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 125 | sk_sp<SkDataTable> SkDataTable::MakeArrayProc(const void* array, size_t elemSize, int count, |
| 126 | FreeProc proc, void* ctx) { |
mike@reedtribe.org | cac3ae3 | 2013-04-21 01:37:46 +0000 | [diff] [blame] | 127 | if (count <= 0) { |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 128 | return SkDataTable::MakeEmpty(); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 129 | } |
bungeman | feb3c1a | 2016-08-05 06:51:50 -0700 | [diff] [blame] | 130 | return sk_sp<SkDataTable>(new SkDataTable(array, elemSize, count, proc, ctx)); |
reed@google.com | 8c5c7a9 | 2013-04-19 20:16:01 +0000 | [diff] [blame] | 131 | } |