Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 1 | /* |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 2 | ** |
| 3 | ** Copyright 2009, The Android Open Source Project |
| 4 | ** |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 5 | ** Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | ** you may not use this file except in compliance with the License. |
| 7 | ** You may obtain a copy of the License at |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 8 | ** |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 9 | ** http://www.apache.org/licenses/LICENSE-2.0 |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 10 | ** |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 11 | ** Unless required by applicable law or agreed to in writing, software |
| 12 | ** distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | ** See the License for the specific language governing permissions and |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 15 | ** limitations under the License. |
| 16 | */ |
| 17 | |
Mathias Agopian | 5629eb1 | 2010-04-15 14:57:39 -0700 | [diff] [blame] | 18 | #define LOG_TAG "GraphicBufferAllocator" |
Mathias Agopian | cf56319 | 2012-02-29 20:43:29 -0800 | [diff] [blame] | 19 | #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
Mathias Agopian | 5629eb1 | 2010-04-15 14:57:39 -0700 | [diff] [blame] | 20 | |
Mathias Agopian | fe2f54f | 2017-02-15 19:48:58 -0800 | [diff] [blame] | 21 | #include <ui/GraphicBufferAllocator.h> |
| 22 | |
Valerie Hau | fb4c986 | 2019-07-22 15:24:37 -0700 | [diff] [blame] | 23 | #include <limits.h> |
Mathias Agopian | fe2f54f | 2017-02-15 19:48:58 -0800 | [diff] [blame] | 24 | #include <stdio.h> |
| 25 | |
Chia-I Wu | 5bac7f3 | 2017-04-06 12:34:32 -0700 | [diff] [blame] | 26 | #include <grallocusage/GrallocUsageConversion.h> |
| 27 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 28 | #include <android-base/stringprintf.h> |
Mark Salyzyn | 7823e12 | 2016-09-29 08:08:05 -0700 | [diff] [blame] | 29 | #include <log/log.h> |
Mathias Agopian | 4243e66 | 2009-04-15 18:34:24 -0700 | [diff] [blame] | 30 | #include <utils/Singleton.h> |
Mathias Agopian | cf56319 | 2012-02-29 20:43:29 -0800 | [diff] [blame] | 31 | #include <utils/Trace.h> |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 32 | |
Marissa Wall | d380e2c | 2018-12-29 14:17:29 -0800 | [diff] [blame] | 33 | #include <ui/Gralloc.h> |
Chia-I Wu | 5bac7f3 | 2017-04-06 12:34:32 -0700 | [diff] [blame] | 34 | #include <ui/Gralloc2.h> |
Marissa Wall | 925bf7f | 2018-12-29 14:27:11 -0800 | [diff] [blame] | 35 | #include <ui/Gralloc3.h> |
Marissa Wall | 87c8ba7 | 2019-06-20 14:20:52 -0700 | [diff] [blame] | 36 | #include <ui/Gralloc4.h> |
Chia-I Wu | 9ba189d | 2016-09-22 17:13:08 +0800 | [diff] [blame] | 37 | #include <ui/GraphicBufferMapper.h> |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 38 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 39 | namespace android { |
| 40 | // --------------------------------------------------------------------------- |
| 41 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 42 | using base::StringAppendF; |
| 43 | |
Mathias Agopian | 3330b20 | 2009-10-05 17:07:12 -0700 | [diff] [blame] | 44 | ANDROID_SINGLETON_STATIC_INSTANCE( GraphicBufferAllocator ) |
Mathias Agopian | 4243e66 | 2009-04-15 18:34:24 -0700 | [diff] [blame] | 45 | |
Mathias Agopian | 3330b20 | 2009-10-05 17:07:12 -0700 | [diff] [blame] | 46 | Mutex GraphicBufferAllocator::sLock; |
Mathias Agopian | b26af23 | 2009-10-05 18:19:57 -0700 | [diff] [blame] | 47 | KeyedVector<buffer_handle_t, |
| 48 | GraphicBufferAllocator::alloc_rec_t> GraphicBufferAllocator::sAllocList; |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 49 | |
Marissa Wall | 925bf7f | 2018-12-29 14:27:11 -0800 | [diff] [blame] | 50 | GraphicBufferAllocator::GraphicBufferAllocator() : mMapper(GraphicBufferMapper::getInstance()) { |
Marissa Wall | 87c8ba7 | 2019-06-20 14:20:52 -0700 | [diff] [blame] | 51 | mAllocator = std::make_unique<const Gralloc4Allocator>( |
| 52 | reinterpret_cast<const Gralloc4Mapper&>(mMapper.getGrallocMapper())); |
| 53 | if (mAllocator->isLoaded()) { |
| 54 | return; |
| 55 | } |
Marissa Wall | 925bf7f | 2018-12-29 14:27:11 -0800 | [diff] [blame] | 56 | mAllocator = std::make_unique<const Gralloc3Allocator>( |
| 57 | reinterpret_cast<const Gralloc3Mapper&>(mMapper.getGrallocMapper())); |
Marissa Wall | 87c8ba7 | 2019-06-20 14:20:52 -0700 | [diff] [blame] | 58 | if (mAllocator->isLoaded()) { |
| 59 | return; |
| 60 | } |
| 61 | mAllocator = std::make_unique<const Gralloc2Allocator>( |
| 62 | reinterpret_cast<const Gralloc2Mapper&>(mMapper.getGrallocMapper())); |
| 63 | if (mAllocator->isLoaded()) { |
| 64 | return; |
Marissa Wall | 925bf7f | 2018-12-29 14:27:11 -0800 | [diff] [blame] | 65 | } |
| 66 | |
Marissa Wall | 87c8ba7 | 2019-06-20 14:20:52 -0700 | [diff] [blame] | 67 | LOG_ALWAYS_FATAL("gralloc-allocator is missing"); |
Marissa Wall | 925bf7f | 2018-12-29 14:27:11 -0800 | [diff] [blame] | 68 | } |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 69 | |
Dan Stoza | 8deb4da | 2016-06-01 18:21:44 -0700 | [diff] [blame] | 70 | GraphicBufferAllocator::~GraphicBufferAllocator() {} |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 71 | |
Dan Stoza | 45de5ba | 2019-04-25 14:12:09 -0700 | [diff] [blame] | 72 | size_t GraphicBufferAllocator::getTotalSize() const { |
| 73 | Mutex::Autolock _l(sLock); |
| 74 | size_t total = 0; |
| 75 | for (size_t i = 0; i < sAllocList.size(); ++i) { |
| 76 | total += sAllocList.valueAt(i).size; |
| 77 | } |
| 78 | return total; |
| 79 | } |
| 80 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 81 | void GraphicBufferAllocator::dump(std::string& result) const { |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 82 | Mutex::Autolock _l(sLock); |
| 83 | KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList); |
| 84 | size_t total = 0; |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 85 | result.append("Allocated buffers:\n"); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 86 | const size_t c = list.size(); |
| 87 | for (size_t i=0 ; i<c ; i++) { |
| 88 | const alloc_rec_t& rec(list.valueAt(i)); |
Mathias Agopian | a947de8 | 2011-07-29 16:35:41 -0700 | [diff] [blame] | 89 | if (rec.size) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 90 | StringAppendF(&result, |
| 91 | "%10p: %7.2f KiB | %4u (%4u) x %4u | %4u | %8X | 0x%" PRIx64 " | %s\n", |
Nick Desaulniers | ea6c713 | 2019-10-15 19:14:39 -0700 | [diff] [blame] | 92 | list.keyAt(i), static_cast<double>(rec.size) / 1024.0, rec.width, rec.stride, rec.height, |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 93 | rec.layerCount, rec.format, rec.usage, rec.requestorName.c_str()); |
Mathias Agopian | a947de8 | 2011-07-29 16:35:41 -0700 | [diff] [blame] | 94 | } else { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 95 | StringAppendF(&result, |
| 96 | "%10p: unknown | %4u (%4u) x %4u | %4u | %8X | 0x%" PRIx64 " | %s\n", |
| 97 | list.keyAt(i), rec.width, rec.stride, rec.height, rec.layerCount, |
| 98 | rec.format, rec.usage, rec.requestorName.c_str()); |
Mathias Agopian | a947de8 | 2011-07-29 16:35:41 -0700 | [diff] [blame] | 99 | } |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 100 | total += rec.size; |
| 101 | } |
Nick Desaulniers | ea6c713 | 2019-10-15 19:14:39 -0700 | [diff] [blame] | 102 | StringAppendF(&result, "Total allocated (estimate): %.2f KB\n", static_cast<double>(total) / 1024.0); |
Chia-I Wu | 9ba189d | 2016-09-22 17:13:08 +0800 | [diff] [blame] | 103 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 104 | result.append(mAllocator->dumpDebugInfo()); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 105 | } |
| 106 | |
Mathias Agopian | 678bdd6 | 2010-12-03 17:33:09 -0800 | [diff] [blame] | 107 | void GraphicBufferAllocator::dumpToSystemLog() |
| 108 | { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 109 | std::string s; |
Mathias Agopian | 678bdd6 | 2010-12-03 17:33:09 -0800 | [diff] [blame] | 110 | GraphicBufferAllocator::getInstance().dump(s); |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 111 | ALOGD("%s", s.c_str()); |
Mathias Agopian | 678bdd6 | 2010-12-03 17:33:09 -0800 | [diff] [blame] | 112 | } |
| 113 | |
Marissa Wall | bfcf81f | 2019-11-27 10:36:29 -0800 | [diff] [blame^] | 114 | status_t GraphicBufferAllocator::allocateHelper(uint32_t width, uint32_t height, PixelFormat format, |
| 115 | uint32_t layerCount, uint64_t usage, |
| 116 | buffer_handle_t* handle, uint32_t* stride, |
| 117 | std::string requestorName, bool importBuffer) { |
Mathias Agopian | cf56319 | 2012-02-29 20:43:29 -0800 | [diff] [blame] | 118 | ATRACE_CALL(); |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 119 | |
Mathias Agopian | 5629eb1 | 2010-04-15 14:57:39 -0700 | [diff] [blame] | 120 | // make sure to not allocate a N x 0 or 0 x N buffer, since this is |
| 121 | // allowed from an API stand-point allocate a 1x1 buffer instead. |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 122 | if (!width || !height) |
| 123 | width = height = 1; |
Mathias Agopian | cbb288b | 2009-09-07 16:32:45 -0700 | [diff] [blame] | 124 | |
Valerie Hau | fb4c986 | 2019-07-22 15:24:37 -0700 | [diff] [blame] | 125 | const uint32_t bpp = bytesPerPixel(format); |
| 126 | if (std::numeric_limits<size_t>::max() / width / height < static_cast<size_t>(bpp)) { |
| 127 | ALOGE("Failed to allocate (%u x %u) layerCount %u format %d " |
| 128 | "usage %" PRIx64 ": Requesting too large a buffer size", |
| 129 | width, height, layerCount, format, usage); |
| 130 | return BAD_VALUE; |
| 131 | } |
| 132 | |
Craig Donner | 6ebc46a | 2016-10-21 15:23:44 -0700 | [diff] [blame] | 133 | // Ensure that layerCount is valid. |
| 134 | if (layerCount < 1) |
| 135 | layerCount = 1; |
| 136 | |
Chia-I Wu | 12ca527 | 2018-11-05 09:41:30 -0800 | [diff] [blame] | 137 | // TODO(b/72323293, b/72703005): Remove these invalid bits from callers |
| 138 | usage &= ~static_cast<uint64_t>((1 << 10) | (1 << 13)); |
| 139 | |
Marissa Wall | bfcf81f | 2019-11-27 10:36:29 -0800 | [diff] [blame^] | 140 | status_t error = mAllocator->allocate(width, height, format, layerCount, usage, 1, stride, |
| 141 | handle, importBuffer); |
| 142 | if (error != NO_ERROR) { |
| 143 | ALOGE("Failed to allocate (%u x %u) layerCount %u format %d " |
| 144 | "usage %" PRIx64 ": %d", |
| 145 | width, height, layerCount, format, usage, error); |
| 146 | return NO_MEMORY; |
| 147 | } |
| 148 | |
| 149 | if (!importBuffer) { |
| 150 | return NO_ERROR; |
| 151 | } |
Valerie Hau | 35493e7 | 2019-10-18 13:25:27 -0700 | [diff] [blame] | 152 | size_t bufSize; |
| 153 | |
| 154 | // if stride has no meaning or is too large, |
| 155 | // approximate size with the input width instead |
Valerie Hau | e64b877 | 2019-10-29 10:00:37 -0700 | [diff] [blame] | 156 | if ((*stride) != 0 && |
| 157 | std::numeric_limits<size_t>::max() / height / (*stride) < static_cast<size_t>(bpp)) { |
Valerie Hau | 35493e7 | 2019-10-18 13:25:27 -0700 | [diff] [blame] | 158 | bufSize = static_cast<size_t>(width) * height * bpp; |
| 159 | } else { |
| 160 | bufSize = static_cast<size_t>((*stride)) * height * bpp; |
| 161 | } |
| 162 | |
Marissa Wall | bfcf81f | 2019-11-27 10:36:29 -0800 | [diff] [blame^] | 163 | Mutex::Autolock _l(sLock); |
| 164 | KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList); |
| 165 | alloc_rec_t rec; |
| 166 | rec.width = width; |
| 167 | rec.height = height; |
| 168 | rec.stride = *stride; |
| 169 | rec.format = format; |
| 170 | rec.layerCount = layerCount; |
| 171 | rec.usage = usage; |
| 172 | rec.size = bufSize; |
| 173 | rec.requestorName = std::move(requestorName); |
| 174 | list.add(*handle, rec); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 175 | |
Marissa Wall | bfcf81f | 2019-11-27 10:36:29 -0800 | [diff] [blame^] | 176 | return NO_ERROR; |
| 177 | } |
| 178 | status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format, |
| 179 | uint32_t layerCount, uint64_t usage, |
| 180 | buffer_handle_t* handle, uint32_t* stride, |
| 181 | std::string requestorName) { |
| 182 | return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName, |
| 183 | true); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 184 | } |
| 185 | |
Marissa Wall | bfcf81f | 2019-11-27 10:36:29 -0800 | [diff] [blame^] | 186 | status_t GraphicBufferAllocator::allocateRawHandle(uint32_t width, uint32_t height, |
| 187 | PixelFormat format, uint32_t layerCount, |
| 188 | uint64_t usage, buffer_handle_t* handle, |
| 189 | uint32_t* stride, std::string requestorName) { |
| 190 | return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName, |
| 191 | false); |
| 192 | } |
| 193 | |
| 194 | // DEPRECATED |
Marissa Wall | 67514c2 | 2019-11-25 11:15:08 -0800 | [diff] [blame] | 195 | status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format, |
| 196 | uint32_t layerCount, uint64_t usage, |
| 197 | buffer_handle_t* handle, uint32_t* stride, |
| 198 | uint64_t /*graphicBufferId*/, std::string requestorName) { |
Marissa Wall | bfcf81f | 2019-11-27 10:36:29 -0800 | [diff] [blame^] | 199 | return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName, |
| 200 | true); |
Marissa Wall | 67514c2 | 2019-11-25 11:15:08 -0800 | [diff] [blame] | 201 | } |
| 202 | |
Mathias Agopian | 3330b20 | 2009-10-05 17:07:12 -0700 | [diff] [blame] | 203 | status_t GraphicBufferAllocator::free(buffer_handle_t handle) |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 204 | { |
Mathias Agopian | cf56319 | 2012-02-29 20:43:29 -0800 | [diff] [blame] | 205 | ATRACE_CALL(); |
Mathias Agopian | 0a75781 | 2010-12-08 16:40:01 -0800 | [diff] [blame] | 206 | |
Chia-I Wu | cb8405e | 2017-04-17 15:20:19 -0700 | [diff] [blame] | 207 | // We allocated a buffer from the allocator and imported it into the |
| 208 | // mapper to get the handle. We just need to free the handle now. |
| 209 | mMapper.freeBuffer(handle); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 210 | |
Dan Stoza | 8deb4da | 2016-06-01 18:21:44 -0700 | [diff] [blame] | 211 | Mutex::Autolock _l(sLock); |
| 212 | KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList); |
| 213 | list.removeItem(handle); |
| 214 | |
| 215 | return NO_ERROR; |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 216 | } |
| 217 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 218 | // --------------------------------------------------------------------------- |
| 219 | }; // namespace android |