Home | History | Annotate | Download | only in ui 
      1 /*
      2 **
      3 ** Copyright 2009, The Android Open Source Project
      4 **
      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
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     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
     15 ** limitations under the License.
     16 */
     17 
     18 #define LOG_TAG "GraphicBufferAllocator"
     19 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
     20 
     21 #include <cutils/log.h>
     22 
     23 #include <utils/Singleton.h>
     24 #include <utils/String8.h>
     25 #include <utils/Trace.h>
     26 
     27 #include <ui/GraphicBufferAllocator.h>
     28 
     29 namespace android {
     30 // ---------------------------------------------------------------------------
     31 
     32 ANDROID_SINGLETON_STATIC_INSTANCE( GraphicBufferAllocator )
     33 
     34 Mutex GraphicBufferAllocator::sLock;
     35 KeyedVector<buffer_handle_t,
     36     GraphicBufferAllocator::alloc_rec_t> GraphicBufferAllocator::sAllocList;
     37 
     38 GraphicBufferAllocator::GraphicBufferAllocator()
     39     : mAllocDev(0)
     40 {
     41     hw_module_t const* module;
     42     int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
     43     ALOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID);
     44     if (err == 0) {
     45         gralloc_open(module, &mAllocDev);
     46     }
     47 }
     48 
     49 GraphicBufferAllocator::~GraphicBufferAllocator()
     50 {
     51     gralloc_close(mAllocDev);
     52 }
     53 
     54 void GraphicBufferAllocator::dump(String8& result) const
     55 {
     56     Mutex::Autolock _l(sLock);
     57     KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
     58     size_t total = 0;
     59     const size_t SIZE = 4096;
     60     char buffer[SIZE];
     61     snprintf(buffer, SIZE, "Allocated buffers:\n");
     62     result.append(buffer);
     63     const size_t c = list.size();
     64     for (size_t i=0 ; i<c ; i++) {
     65         const alloc_rec_t& rec(list.valueAt(i));
     66         if (rec.size) {
     67             snprintf(buffer, SIZE, "%10p: %7.2f KiB | %4u (%4u) x %4u | %8X | 0x%08x\n",
     68                     list.keyAt(i), rec.size/1024.0f,
     69                     rec.w, rec.s, rec.h, rec.format, rec.usage);
     70         } else {
     71             snprintf(buffer, SIZE, "%10p: unknown     | %4u (%4u) x %4u | %8X | 0x%08x\n",
     72                     list.keyAt(i),
     73                     rec.w, rec.s, rec.h, rec.format, rec.usage);
     74         }
     75         result.append(buffer);
     76         total += rec.size;
     77     }
     78     snprintf(buffer, SIZE, "Total allocated (estimate): %.2f KB\n", total/1024.0f);
     79     result.append(buffer);
     80     if (mAllocDev->common.version >= 1 && mAllocDev->dump) {
     81         mAllocDev->dump(mAllocDev, buffer, SIZE);
     82         result.append(buffer);
     83     }
     84 }
     85 
     86 void GraphicBufferAllocator::dumpToSystemLog()
     87 {
     88     String8 s;
     89     GraphicBufferAllocator::getInstance().dump(s);
     90     ALOGD("%s", s.string());
     91 }
     92 
     93 status_t GraphicBufferAllocator::alloc(uint32_t w, uint32_t h, PixelFormat format,
     94         int usage, buffer_handle_t* handle, int32_t* stride)
     95 {
     96     ATRACE_CALL();
     97     // make sure to not allocate a N x 0 or 0 x N buffer, since this is
     98     // allowed from an API stand-point allocate a 1x1 buffer instead.
     99     if (!w || !h)
    100         w = h = 1;
    101 
    102     // we have a h/w allocator and h/w buffer is requested
    103     status_t err;
    104 
    105     err = mAllocDev->alloc(mAllocDev, w, h, format, usage, handle, stride);
    106 
    107     ALOGW_IF(err, "alloc(%u, %u, %d, %08x, ...) failed %d (%s)",
    108             w, h, format, usage, err, strerror(-err));
    109 
    110     if (err == NO_ERROR) {
    111         Mutex::Autolock _l(sLock);
    112         KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
    113         int bpp = bytesPerPixel(format);
    114         if (bpp < 0) {
    115             // probably a HAL custom format. in any case, we don't know
    116             // what its pixel size is.
    117             bpp = 0;
    118         }
    119         alloc_rec_t rec;
    120         rec.w = w;
    121         rec.h = h;
    122         rec.s = *stride;
    123         rec.format = format;
    124         rec.usage = usage;
    125         rec.size = h * stride[0] * bpp;
    126         list.add(*handle, rec);
    127     }
    128 
    129     return err;
    130 }
    131 
    132 status_t GraphicBufferAllocator::free(buffer_handle_t handle)
    133 {
    134     ATRACE_CALL();
    135     status_t err;
    136 
    137     err = mAllocDev->free(mAllocDev, handle);
    138 
    139     ALOGW_IF(err, "free(...) failed %d (%s)", err, strerror(-err));
    140     if (err == NO_ERROR) {
    141         Mutex::Autolock _l(sLock);
    142         KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
    143         list.removeItem(handle);
    144     }
    145 
    146     return err;
    147 }
    148 
    149 // ---------------------------------------------------------------------------
    150 }; // namespace android
    151