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 #include <cutils/log.h>
19
20 #include <utils/Singleton.h>
21 #include <utils/String8.h>
22
23 #include <ui/GraphicBufferAllocator.h>
24
25 #include <private/ui/sw_gralloc_handle.h>
26
27 namespace android {
28 // ---------------------------------------------------------------------------
29
30 ANDROID_SINGLETON_STATIC_INSTANCE( GraphicBufferAllocator )
31
32 Mutex GraphicBufferAllocator::sLock;
33 KeyedVector<buffer_handle_t,
34 GraphicBufferAllocator::alloc_rec_t> GraphicBufferAllocator::sAllocList;
35
GraphicBufferAllocator()36 GraphicBufferAllocator::GraphicBufferAllocator()
37 : mAllocDev(0)
38 {
39 hw_module_t const* module;
40 int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
41 LOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID);
42 if (err == 0) {
43 gralloc_open(module, &mAllocDev);
44 }
45 }
46
~GraphicBufferAllocator()47 GraphicBufferAllocator::~GraphicBufferAllocator()
48 {
49 gralloc_close(mAllocDev);
50 }
51
dump(String8 & result) const52 void GraphicBufferAllocator::dump(String8& result) const
53 {
54 Mutex::Autolock _l(sLock);
55 KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
56 size_t total = 0;
57 const size_t SIZE = 512;
58 char buffer[SIZE];
59 snprintf(buffer, SIZE, "Allocated buffers:\n");
60 result.append(buffer);
61 const size_t c = list.size();
62 for (size_t i=0 ; i<c ; i++) {
63 const alloc_rec_t& rec(list.valueAt(i));
64 snprintf(buffer, SIZE, "%10p: %7.2f KiB | %4u x %4u | %2d | 0x%08x\n",
65 list.keyAt(i), rec.size/1024.0f,
66 rec.w, rec.h, rec.format, rec.usage);
67 result.append(buffer);
68 total += rec.size;
69 }
70 snprintf(buffer, SIZE, "Total allocated: %.2f KB\n", total/1024.0f);
71 result.append(buffer);
72 }
73
clamp(uint32_t c)74 static inline uint32_t clamp(uint32_t c) {
75 return c>0 ? c : 1;
76 }
77
alloc(uint32_t w,uint32_t h,PixelFormat format,int usage,buffer_handle_t * handle,int32_t * stride)78 status_t GraphicBufferAllocator::alloc(uint32_t w, uint32_t h, PixelFormat format,
79 int usage, buffer_handle_t* handle, int32_t* stride)
80 {
81 Mutex::Autolock _l(mLock);
82
83 // make sure to not allocate a 0 x 0 buffer
84 w = clamp(w);
85 h = clamp(h);
86
87 // we have a h/w allocator and h/w buffer is requested
88 status_t err;
89
90 if (usage & GRALLOC_USAGE_HW_MASK) {
91 err = mAllocDev->alloc(mAllocDev, w, h, format, usage, handle, stride);
92 } else {
93 err = sw_gralloc_handle_t::alloc(w, h, format, usage, handle, stride);
94 }
95
96 LOGW_IF(err, "alloc(%u, %u, %d, %08x, ...) failed %d (%s)",
97 w, h, format, usage, err, strerror(-err));
98
99 if (err == NO_ERROR) {
100 Mutex::Autolock _l(sLock);
101 KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
102 alloc_rec_t rec;
103 rec.w = w;
104 rec.h = h;
105 rec.format = format;
106 rec.usage = usage;
107 rec.vaddr = 0;
108 rec.size = h * stride[0] * bytesPerPixel(format);
109 list.add(*handle, rec);
110 } else {
111 String8 s;
112 dump(s);
113 LOGD("%s", s.string());
114 }
115
116 return err;
117 }
118
free(buffer_handle_t handle)119 status_t GraphicBufferAllocator::free(buffer_handle_t handle)
120 {
121 Mutex::Autolock _l(mLock);
122
123 status_t err;
124 if (sw_gralloc_handle_t::validate(handle) < 0) {
125 err = mAllocDev->free(mAllocDev, handle);
126 } else {
127 err = sw_gralloc_handle_t::free((sw_gralloc_handle_t*)handle);
128 }
129
130 LOGW_IF(err, "free(...) failed %d (%s)", err, strerror(-err));
131 if (err == NO_ERROR) {
132 Mutex::Autolock _l(sLock);
133 KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
134 list.removeItem(handle);
135 }
136
137 return err;
138 }
139
140 // ---------------------------------------------------------------------------
141 }; // namespace android
142