libs/ui/GraphicBuffer.cpp

   1 /*
   2  * Copyright (C) 2007 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "GraphicBuffer"
  18
  19 #include <ui/GraphicBuffer.h>
  20
  21 #include <cutils/atomic.h>
  22
  23 #include <grallocusage/GrallocUsageConversion.h>
  24
  25 #include <ui/Gralloc2.h>
  26 #include <ui/GraphicBufferAllocator.h>
  27 #include <ui/GraphicBufferMapper.h>
  28
  29 namespace android {
  30
  31 // ===========================================================================
  32 // Buffer and implementation of ANativeWindowBuffer
  33 // ===========================================================================
  34
  35 static uint64_t getUniqueId() {
  36     static volatile int32_t nextId = 0;
  37     uint64_t id = static_cast<uint64_t>(getpid()) << 32;
  38     id |= static_cast<uint32_t>(android_atomic_inc(&nextId));
  39     return id;
  40 }
  41
  42 sp<GraphicBuffer> GraphicBuffer::from(ANativeWindowBuffer* anwb) {
  43     return static_cast<GraphicBuffer *>(anwb);
  44 }
  45
  46 GraphicBuffer::GraphicBuffer()
  47     : BASE(), mOwner(ownData), mBufferMapper(GraphicBufferMapper::get()),
  48       mInitCheck(NO_ERROR), mId(getUniqueId()), mGenerationNumber(0)
  49 {
  50     width  =
  51     height =
  52     stride =
  53     format =
  54     usage_deprecated = 0;
  55     usage  = 0;
  56     layerCount = 0;
  57     handle = NULL;
  58 }
  59
  60 // deprecated
  61 GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight,
  62         PixelFormat inFormat, uint32_t inUsage, std::string requestorName)
  63     : GraphicBuffer(inWidth, inHeight, inFormat, 1, static_cast<uint64_t>(inUsage), requestorName)
  64 {
  65 }
  66
  67 GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight,
  68         PixelFormat inFormat, uint32_t inLayerCount, uint64_t usage, std::string requestorName)
  69     : GraphicBuffer()
  70 {
  71     mInitCheck = initWithSize(inWidth, inHeight, inFormat, inLayerCount,
  72             usage, std::move(requestorName));
  73 }
  74
  75 // deprecated
  76 GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight,
  77         PixelFormat inFormat, uint32_t inLayerCount, uint32_t inUsage,
  78         uint32_t inStride, native_handle_t* inHandle, bool keepOwnership)
  79     : GraphicBuffer(inHandle, keepOwnership ? TAKE_HANDLE : WRAP_HANDLE,
  80             inWidth, inHeight, inFormat, inLayerCount, static_cast<uint64_t>(inUsage),
  81             inStride)
  82 {
  83 }
  84
  85 GraphicBuffer::GraphicBuffer(const native_handle_t* handle,
  86         HandleWrapMethod method, uint32_t width, uint32_t height,
  87         PixelFormat format, uint32_t layerCount,
  88         uint64_t usage,
  89         uint32_t stride)
  90     : GraphicBuffer()
  91 {
  92     mInitCheck = initWithHandle(handle, method, width, height, format,
  93             layerCount, usage, stride);
  94 }
  95
  96 GraphicBuffer::~GraphicBuffer()
  97 {
  98     if (handle) {
  99         free_handle();
 100     }
 101 }
 102
 103 void GraphicBuffer::free_handle()
 104 {
 105     if (mOwner == ownHandle) {
 106         mBufferMapper.freeBuffer(handle);
 107     } else if (mOwner == ownData) {
 108         GraphicBufferAllocator& allocator(GraphicBufferAllocator::get());
 109         allocator.free(handle);
 110     }
 111     handle = NULL;
 112 }
 113
 114 status_t GraphicBuffer::initCheck() const {
 115     return static_cast<status_t>(mInitCheck);
 116 }
 117
 118 void GraphicBuffer::dumpAllocationsToSystemLog()
 119 {
 120     GraphicBufferAllocator::dumpToSystemLog();
 121 }
 122
 123 ANativeWindowBuffer* GraphicBuffer::getNativeBuffer() const
 124 {
 125     LOG_ALWAYS_FATAL_IF(this == NULL, "getNativeBuffer() called on NULL GraphicBuffer");
 126     return static_cast<ANativeWindowBuffer*>(
 127             const_cast<GraphicBuffer*>(this));
 128 }
 129
 130 status_t GraphicBuffer::reallocate(uint32_t inWidth, uint32_t inHeight,
 131         PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage)
 132 {
 133     if (mOwner != ownData)
 134         return INVALID_OPERATION;
 135
 136     if (handle &&
 137             static_cast<int>(inWidth) == width &&
 138             static_cast<int>(inHeight) == height &&
 139             inFormat == format &&
 140             inLayerCount == layerCount &&
 141             inUsage == usage)
 142         return NO_ERROR;
 143
 144     if (handle) {
 145         GraphicBufferAllocator& allocator(GraphicBufferAllocator::get());
 146         allocator.free(handle);
 147         handle = 0;
 148     }
 149     return initWithSize(inWidth, inHeight, inFormat, inLayerCount, inUsage, "[Reallocation]");
 150 }
 151
 152 bool GraphicBuffer::needsReallocation(uint32_t inWidth, uint32_t inHeight,
 153         PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage)
 154 {
 155     if (static_cast<int>(inWidth) != width) return true;
 156     if (static_cast<int>(inHeight) != height) return true;
 157     if (inFormat != format) return true;
 158     if (inLayerCount != layerCount) return true;
 159     if ((usage & inUsage) != inUsage) return true;
 160     return false;
 161 }
 162
 163 status_t GraphicBuffer::initWithSize(uint32_t inWidth, uint32_t inHeight,
 164         PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage,
 165         std::string requestorName)
 166 {
 167     GraphicBufferAllocator& allocator = GraphicBufferAllocator::get();
 168     uint32_t outStride = 0;
 169     status_t err = allocator.allocate(inWidth, inHeight, inFormat, inLayerCount,
 170             inUsage, &handle, &outStride, mId,
 171             std::move(requestorName));
 172     if (err == NO_ERROR) {
 173         width = static_cast<int>(inWidth);
 174         height = static_cast<int>(inHeight);
 175         format = inFormat;
 176         layerCount = inLayerCount;
 177         usage = inUsage;
 178         usage_deprecated = int(usage);
 179         stride = static_cast<int>(outStride);
 180     }
 181     return err;
 182 }
 183
 184 status_t GraphicBuffer::initWithHandle(const native_handle_t* handle,
 185         HandleWrapMethod method, uint32_t width, uint32_t height,
 186         PixelFormat format, uint32_t layerCount, uint64_t usage,
 187         uint32_t stride)
 188 {
 189     ANativeWindowBuffer::width  = static_cast<int>(width);
 190     ANativeWindowBuffer::height = static_cast<int>(height);
 191     ANativeWindowBuffer::stride = static_cast<int>(stride);
 192     ANativeWindowBuffer::format = format;
 193     ANativeWindowBuffer::usage  = usage;
 194     ANativeWindowBuffer::usage_deprecated = int(usage);
 195
 196     ANativeWindowBuffer::layerCount = layerCount;
 197
 198     mOwner = (method == WRAP_HANDLE) ? ownNone : ownHandle;
 199
 200     if (method == TAKE_UNREGISTERED_HANDLE || method == CLONE_HANDLE) {
 201         buffer_handle_t importedHandle;
 202         status_t err = mBufferMapper.importBuffer(handle, &importedHandle);
 203         if (err != NO_ERROR) {
 204             initWithHandle(nullptr, WRAP_HANDLE, 0, 0, 0, 0, 0, 0);
 205
 206             return err;
 207         }
 208
 209         if (method == TAKE_UNREGISTERED_HANDLE) {
 210             native_handle_close(handle);
 211             native_handle_delete(const_cast<native_handle_t*>(handle));
 212         }
 213
 214         handle = importedHandle;
 215     }
 216
 217     ANativeWindowBuffer::handle = handle;
 218
 219     return NO_ERROR;
 220 }
 221
 222 status_t GraphicBuffer::lock(uint32_t inUsage, void** vaddr)
 223 {
 224     const Rect lockBounds(width, height);
 225     status_t res = lock(inUsage, lockBounds, vaddr);
 226     return res;
 227 }
 228
 229 status_t GraphicBuffer::lock(uint32_t inUsage, const Rect& rect, void** vaddr)
 230 {
 231     if (rect.left < 0 || rect.right  > width ||
 232         rect.top  < 0 || rect.bottom > height) {
 233         ALOGE("locking pixels (%d,%d,%d,%d) outside of buffer (w=%d, h=%d)",
 234                 rect.left, rect.top, rect.right, rect.bottom,
 235                 width, height);
 236         return BAD_VALUE;
 237     }
 238     status_t res = getBufferMapper().lock(handle, inUsage, rect, vaddr);
 239     return res;
 240 }
 241
 242 status_t GraphicBuffer::lockYCbCr(uint32_t inUsage, android_ycbcr* ycbcr)
 243 {
 244     const Rect lockBounds(width, height);
 245     status_t res = lockYCbCr(inUsage, lockBounds, ycbcr);
 246     return res;
 247 }
 248
 249 status_t GraphicBuffer::lockYCbCr(uint32_t inUsage, const Rect& rect,
 250         android_ycbcr* ycbcr)
 251 {
 252     if (rect.left < 0 || rect.right  > width ||
 253         rect.top  < 0 || rect.bottom > height) {
 254         ALOGE("locking pixels (%d,%d,%d,%d) outside of buffer (w=%d, h=%d)",
 255                 rect.left, rect.top, rect.right, rect.bottom,
 256                 width, height);
 257         return BAD_VALUE;
 258     }
 259     status_t res = getBufferMapper().lockYCbCr(handle, inUsage, rect, ycbcr);
 260     return res;
 261 }
 262
 263 status_t GraphicBuffer::unlock()
 264 {
 265     status_t res = getBufferMapper().unlock(handle);
 266     return res;
 267 }
 268
 269 status_t GraphicBuffer::lockAsync(uint32_t inUsage, void** vaddr, int fenceFd)
 270 {
 271     const Rect lockBounds(width, height);
 272     status_t res = lockAsync(inUsage, lockBounds, vaddr, fenceFd);
 273     return res;
 274 }
 275
 276 status_t GraphicBuffer::lockAsync(uint32_t inUsage, const Rect& rect,
 277         void** vaddr, int fenceFd)
 278 {
 279     return lockAsync(inUsage, inUsage, rect, vaddr, fenceFd);
 280 }
 281
 282 status_t GraphicBuffer::lockAsync(uint64_t inProducerUsage,
 283         uint64_t inConsumerUsage, const Rect& rect, void** vaddr, int fenceFd)
 284 {
 285     if (rect.left < 0 || rect.right  > width ||
 286         rect.top  < 0 || rect.bottom > height) {
 287         ALOGE("locking pixels (%d,%d,%d,%d) outside of buffer (w=%d, h=%d)",
 288                 rect.left, rect.top, rect.right, rect.bottom,
 289                 width, height);
 290         return BAD_VALUE;
 291     }
 292     status_t res = getBufferMapper().lockAsync(handle, inProducerUsage,
 293             inConsumerUsage, rect, vaddr, fenceFd);
 294     return res;
 295 }
 296
 297 status_t GraphicBuffer::lockAsyncYCbCr(uint32_t inUsage, android_ycbcr* ycbcr,
 298         int fenceFd)
 299 {
 300     const Rect lockBounds(width, height);
 301     status_t res = lockAsyncYCbCr(inUsage, lockBounds, ycbcr, fenceFd);
 302     return res;
 303 }
 304
 305 status_t GraphicBuffer::lockAsyncYCbCr(uint32_t inUsage, const Rect& rect,
 306         android_ycbcr* ycbcr, int fenceFd)
 307 {
 308     if (rect.left < 0 || rect.right  > width ||
 309         rect.top  < 0 || rect.bottom > height) {
 310         ALOGE("locking pixels (%d,%d,%d,%d) outside of buffer (w=%d, h=%d)",
 311                 rect.left, rect.top, rect.right, rect.bottom,
 312                 width, height);
 313         return BAD_VALUE;
 314     }
 315     status_t res = getBufferMapper().lockAsyncYCbCr(handle, inUsage, rect, ycbcr, fenceFd);
 316     return res;
 317 }
 318
 319 status_t GraphicBuffer::unlockAsync(int *fenceFd)
 320 {
 321     status_t res = getBufferMapper().unlockAsync(handle, fenceFd);
 322     return res;
 323 }
 324
 325 size_t GraphicBuffer::getFlattenedSize() const {
 326     return static_cast<size_t>(13 + (handle ? handle->numInts : 0)) * sizeof(int);
 327 }
 328
 329 size_t GraphicBuffer::getFdCount() const {
 330     return static_cast<size_t>(handle ? handle->numFds : 0);
 331 }
 332
 333 status_t GraphicBuffer::flatten(void*& buffer, size_t& size, int*& fds, size_t& count) const {
 334     size_t sizeNeeded = GraphicBuffer::getFlattenedSize();
 335     if (size < sizeNeeded) return NO_MEMORY;
 336
 337     size_t fdCountNeeded = GraphicBuffer::getFdCount();
 338     if (count < fdCountNeeded) return NO_MEMORY;
 339
 340     int32_t* buf = static_cast<int32_t*>(buffer);
 341     buf[0] = 'GB01';
 342     buf[1] = width;
 343     buf[2] = height;
 344     buf[3] = stride;
 345     buf[4] = format;
 346     buf[5] = static_cast<int32_t>(layerCount);
 347     buf[6] = int(usage); // low 32-bits
 348     buf[7] = static_cast<int32_t>(mId >> 32);
 349     buf[8] = static_cast<int32_t>(mId & 0xFFFFFFFFull);
 350     buf[9] = static_cast<int32_t>(mGenerationNumber);
 351     buf[10] = 0;
 352     buf[11] = 0;
 353     buf[12] = int(usage >> 32); // high 32-bits
 354
 355     if (handle) {
 356         buf[10] = handle->numFds;
 357         buf[11] = handle->numInts;
 358         memcpy(fds, handle->data, static_cast<size_t>(handle->numFds) * sizeof(int));
 359         memcpy(buf + 13, handle->data + handle->numFds,
 360                 static_cast<size_t>(handle->numInts) * sizeof(int));
 361     }
 362
 363     buffer = static_cast<void*>(static_cast<uint8_t*>(buffer) + sizeNeeded);
 364     size -= sizeNeeded;
 365     if (handle) {
 366         fds += handle->numFds;
 367         count -= static_cast<size_t>(handle->numFds);
 368     }
 369
 370     return NO_ERROR;
 371 }
 372
 373 status_t GraphicBuffer::unflatten(
 374         void const*& buffer, size_t& size, int const*& fds, size_t& count) {
 375
 376     int const* buf = static_cast<int const*>(buffer);
 377
 378     // NOTE: it turns out that some media code generates a flattened GraphicBuffer manually!!!!!
 379     // see H2BGraphicBufferProducer.cpp
 380     uint32_t flattenWordCount = 0;
 381     if (buf[0] == 'GB01') {
 382         // new version with 64-bits usage bits
 383         flattenWordCount = 13;
 384     } else if (buf[0] == 'GBFR') {
 385         // old version, when usage bits were 32-bits
 386         flattenWordCount = 12;
 387     } else {
 388         return BAD_TYPE;
 389     }
 390
 391     const size_t numFds  = static_cast<size_t>(buf[10]);
 392     const size_t numInts = static_cast<size_t>(buf[11]);
 393
 394     // Limit the maxNumber to be relatively small. The number of fds or ints
 395     // should not come close to this number, and the number itself was simply
 396     // chosen to be high enough to not cause issues and low enough to prevent
 397     // overflow problems.
 398     const size_t maxNumber = 4096;
 399     if (numFds >= maxNumber || numInts >= (maxNumber - flattenWordCount)) {
 400         width = height = stride = format = usage_deprecated = 0;
 401         layerCount = 0;
 402         usage = 0;
 403         handle = NULL;
 404         ALOGE("unflatten: numFds or numInts is too large: %zd, %zd", numFds, numInts);
 405         return BAD_VALUE;
 406     }
 407
 408     const size_t sizeNeeded = (flattenWordCount + numInts) * sizeof(int);
 409     if (size < sizeNeeded) return NO_MEMORY;
 410
 411     size_t fdCountNeeded = numFds;
 412     if (count < fdCountNeeded) return NO_MEMORY;
 413
 414     if (handle) {
 415         // free previous handle if any
 416         free_handle();
 417     }
 418
 419     if (numFds || numInts) {
 420         width  = buf[1];
 421         height = buf[2];
 422         stride = buf[3];
 423         format = buf[4];
 424         layerCount = static_cast<uintptr_t>(buf[5]);
 425         usage_deprecated = buf[6];
 426         if (flattenWordCount == 13) {
 427             usage = (uint64_t(buf[12]) << 32) | uint32_t(buf[6]);
 428         } else {
 429             usage = uint64_t(usage_deprecated);
 430         }
 431         native_handle* h = native_handle_create(
 432                 static_cast<int>(numFds), static_cast<int>(numInts));
 433         if (!h) {
 434             width = height = stride = format = usage_deprecated = 0;
 435             layerCount = 0;
 436             usage = 0;
 437             handle = NULL;
 438             ALOGE("unflatten: native_handle_create failed");
 439             return NO_MEMORY;
 440         }
 441         memcpy(h->data, fds, numFds * sizeof(int));
 442         memcpy(h->data + numFds, buf + flattenWordCount, numInts * sizeof(int));
 443         handle = h;
 444     } else {
 445         width = height = stride = format = usage_deprecated = 0;
 446         layerCount = 0;
 447         usage = 0;
 448         handle = NULL;
 449     }
 450
 451     mId = static_cast<uint64_t>(buf[7]) << 32;
 452     mId |= static_cast<uint32_t>(buf[8]);
 453
 454     mGenerationNumber = static_cast<uint32_t>(buf[9]);
 455
 456     mOwner = ownHandle;
 457
 458     if (handle != 0) {
 459         buffer_handle_t importedHandle;
 460         status_t err = mBufferMapper.importBuffer(handle, &importedHandle);
 461         if (err != NO_ERROR) {
 462             width = height = stride = format = usage_deprecated = 0;
 463             layerCount = 0;
 464             usage = 0;
 465             handle = NULL;
 466             ALOGE("unflatten: registerBuffer failed: %s (%d)", strerror(-err), err);
 467             return err;
 468         }
 469
 470         native_handle_close(handle);
 471         native_handle_delete(const_cast<native_handle_t*>(handle));
 472         handle = importedHandle;
 473     }
 474
 475     buffer = static_cast<void const*>(static_cast<uint8_t const*>(buffer) + sizeNeeded);
 476     size -= sizeNeeded;
 477     fds += numFds;
 478     count -= numFds;
 479
 480     return NO_ERROR;
 481 }
 482
 483 // ---------------------------------------------------------------------------
 484
 485 }; // namespace android