1 /*
2 **
3 ** Copyright 2007 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 "FramebufferNativeWindow"
19
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <errno.h>
24
25 #include <cutils/log.h>
26 #include <cutils/atomic.h>
27 #include <utils/threads.h>
28 #include <utils/RefBase.h>
29
30 #include <ui/ANativeObjectBase.h>
31 #include <ui/Fence.h>
32 #include <ui/FramebufferNativeWindow.h>
33 #include <ui/Rect.h>
34
35 #include <EGL/egl.h>
36
37 #include <hardware/hardware.h>
38 #include <hardware/gralloc.h>
39
40 // ----------------------------------------------------------------------------
41 namespace android {
42 // ----------------------------------------------------------------------------
43
44 class NativeBuffer
45 : public ANativeObjectBase<
46 ANativeWindowBuffer,
47 NativeBuffer,
48 LightRefBase<NativeBuffer> >
49 {
50 public:
NativeBuffer(int w,int h,int f,int u)51 NativeBuffer(int w, int h, int f, int u) : BASE() {
52 ANativeWindowBuffer::width = w;
53 ANativeWindowBuffer::height = h;
54 ANativeWindowBuffer::format = f;
55 ANativeWindowBuffer::usage = u;
56 }
57 private:
58 friend class LightRefBase<NativeBuffer>;
~NativeBuffer()59 ~NativeBuffer() { }; // this class cannot be overloaded
60 };
61
62
63 /*
64 * This implements the (main) framebuffer management. This class is used
65 * mostly by SurfaceFlinger, but also by command line GL application.
66 *
67 * In fact this is an implementation of ANativeWindow on top of
68 * the framebuffer.
69 *
70 * Currently it is pretty simple, it manages only two buffers (the front and
71 * back buffer).
72 *
73 */
74
FramebufferNativeWindow()75 FramebufferNativeWindow::FramebufferNativeWindow()
76 : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false)
77 {
78 hw_module_t const* module;
79 if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) {
80 int stride;
81 int err;
82 int i;
83 err = framebuffer_open(module, &fbDev);
84 ALOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err));
85
86 err = gralloc_open(module, &grDev);
87 ALOGE_IF(err, "couldn't open gralloc HAL (%s)", strerror(-err));
88
89 // bail out if we can't initialize the modules
90 if (!fbDev || !grDev)
91 return;
92
93 mUpdateOnDemand = (fbDev->setUpdateRect != 0);
94
95 // initialize the buffer FIFO
96 if(fbDev->numFramebuffers >= MIN_NUM_FRAME_BUFFERS &&
97 fbDev->numFramebuffers <= MAX_NUM_FRAME_BUFFERS){
98 mNumBuffers = fbDev->numFramebuffers;
99 } else {
100 mNumBuffers = MIN_NUM_FRAME_BUFFERS;
101 }
102 mNumFreeBuffers = mNumBuffers;
103 mBufferHead = mNumBuffers-1;
104
105 /*
106 * This does not actually change the framebuffer format. It merely
107 * fakes this format to surfaceflinger so that when it creates
108 * framebuffer surfaces it will use this format. It's really a giant
109 * HACK to allow interworking with buggy gralloc+GPU driver
110 * implementations. You should *NEVER* need to set this for shipping
111 * devices.
112 */
113 #ifdef FRAMEBUFFER_FORCE_FORMAT
114 *((uint32_t *)&fbDev->format) = FRAMEBUFFER_FORCE_FORMAT;
115 #endif
116
117 for (i = 0; i < mNumBuffers; i++)
118 {
119 buffers[i] = new NativeBuffer(
120 fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);
121 }
122
123 for (i = 0; i < mNumBuffers; i++)
124 {
125 err = grDev->alloc(grDev,
126 fbDev->width, fbDev->height, fbDev->format,
127 GRALLOC_USAGE_HW_FB, &buffers[i]->handle, &buffers[i]->stride);
128
129 ALOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s",
130 i, fbDev->width, fbDev->height, strerror(-err));
131
132 if (err)
133 {
134 mNumBuffers = i;
135 mNumFreeBuffers = i;
136 mBufferHead = mNumBuffers-1;
137 break;
138 }
139 }
140
141 const_cast<uint32_t&>(ANativeWindow::flags) = fbDev->flags;
142 const_cast<float&>(ANativeWindow::xdpi) = fbDev->xdpi;
143 const_cast<float&>(ANativeWindow::ydpi) = fbDev->ydpi;
144 const_cast<int&>(ANativeWindow::minSwapInterval) =
145 fbDev->minSwapInterval;
146 const_cast<int&>(ANativeWindow::maxSwapInterval) =
147 fbDev->maxSwapInterval;
148 } else {
149 ALOGE("Couldn't get gralloc module");
150 }
151
152 ANativeWindow::setSwapInterval = setSwapInterval;
153 ANativeWindow::dequeueBuffer = dequeueBuffer;
154 ANativeWindow::queueBuffer = queueBuffer;
155 ANativeWindow::query = query;
156 ANativeWindow::perform = perform;
157
158 ANativeWindow::dequeueBuffer_DEPRECATED = dequeueBuffer_DEPRECATED;
159 ANativeWindow::lockBuffer_DEPRECATED = lockBuffer_DEPRECATED;
160 ANativeWindow::queueBuffer_DEPRECATED = queueBuffer_DEPRECATED;
161 }
162
~FramebufferNativeWindow()163 FramebufferNativeWindow::~FramebufferNativeWindow()
164 {
165 if (grDev) {
166 for(int i = 0; i < mNumBuffers; i++) {
167 if (buffers[i] != NULL) {
168 grDev->free(grDev, buffers[i]->handle);
169 }
170 }
171 gralloc_close(grDev);
172 }
173
174 if (fbDev) {
175 framebuffer_close(fbDev);
176 }
177 }
178
setUpdateRectangle(const Rect & r)179 status_t FramebufferNativeWindow::setUpdateRectangle(const Rect& r)
180 {
181 if (!mUpdateOnDemand) {
182 return INVALID_OPERATION;
183 }
184 return fbDev->setUpdateRect(fbDev, r.left, r.top, r.width(), r.height());
185 }
186
compositionComplete()187 status_t FramebufferNativeWindow::compositionComplete()
188 {
189 if (fbDev->compositionComplete) {
190 return fbDev->compositionComplete(fbDev);
191 }
192 return INVALID_OPERATION;
193 }
194
setSwapInterval(ANativeWindow * window,int interval)195 int FramebufferNativeWindow::setSwapInterval(
196 ANativeWindow* window, int interval)
197 {
198 framebuffer_device_t* fb = getSelf(window)->fbDev;
199 return fb->setSwapInterval(fb, interval);
200 }
201
dump(String8 & result)202 void FramebufferNativeWindow::dump(String8& result) {
203 if (fbDev->common.version >= 1 && fbDev->dump) {
204 const size_t SIZE = 4096;
205 char buffer[SIZE];
206
207 fbDev->dump(fbDev, buffer, SIZE);
208 result.append(buffer);
209 }
210 }
211
212 // only for debugging / logging
getCurrentBufferIndex() const213 int FramebufferNativeWindow::getCurrentBufferIndex() const
214 {
215 Mutex::Autolock _l(mutex);
216 const int index = mCurrentBufferIndex;
217 return index;
218 }
219
dequeueBuffer_DEPRECATED(ANativeWindow * window,ANativeWindowBuffer ** buffer)220 int FramebufferNativeWindow::dequeueBuffer_DEPRECATED(ANativeWindow* window,
221 ANativeWindowBuffer** buffer)
222 {
223 int fenceFd = -1;
224 int result = dequeueBuffer(window, buffer, &fenceFd);
225 sp<Fence> fence(new Fence(fenceFd));
226 int waitResult = fence->wait(Fence::TIMEOUT_NEVER);
227 if (waitResult != OK) {
228 ALOGE("dequeueBuffer_DEPRECATED: Fence::wait returned an "
229 "error: %d", waitResult);
230 return waitResult;
231 }
232 return result;
233 }
234
dequeueBuffer(ANativeWindow * window,ANativeWindowBuffer ** buffer,int * fenceFd)235 int FramebufferNativeWindow::dequeueBuffer(ANativeWindow* window,
236 ANativeWindowBuffer** buffer, int* fenceFd)
237 {
238 FramebufferNativeWindow* self = getSelf(window);
239 Mutex::Autolock _l(self->mutex);
240 framebuffer_device_t* fb = self->fbDev;
241
242 int index = self->mBufferHead++;
243 if (self->mBufferHead >= self->mNumBuffers)
244 self->mBufferHead = 0;
245
246 // wait for a free non-front buffer
247 while (self->mNumFreeBuffers < 2) {
248 self->mCondition.wait(self->mutex);
249 }
250 ALOG_ASSERT(self->buffers[index] != self->front);
251
252 // get this buffer
253 self->mNumFreeBuffers--;
254 self->mCurrentBufferIndex = index;
255
256 *buffer = self->buffers[index].get();
257 *fenceFd = -1;
258
259 return 0;
260 }
261
lockBuffer_DEPRECATED(ANativeWindow * window,ANativeWindowBuffer * buffer)262 int FramebufferNativeWindow::lockBuffer_DEPRECATED(ANativeWindow* window,
263 ANativeWindowBuffer* buffer)
264 {
265 return NO_ERROR;
266 }
267
queueBuffer_DEPRECATED(ANativeWindow * window,ANativeWindowBuffer * buffer)268 int FramebufferNativeWindow::queueBuffer_DEPRECATED(ANativeWindow* window,
269 ANativeWindowBuffer* buffer)
270 {
271 return queueBuffer(window, buffer, -1);
272 }
273
queueBuffer(ANativeWindow * window,ANativeWindowBuffer * buffer,int fenceFd)274 int FramebufferNativeWindow::queueBuffer(ANativeWindow* window,
275 ANativeWindowBuffer* buffer, int fenceFd)
276 {
277 FramebufferNativeWindow* self = getSelf(window);
278 Mutex::Autolock _l(self->mutex);
279 framebuffer_device_t* fb = self->fbDev;
280 buffer_handle_t handle = static_cast<NativeBuffer*>(buffer)->handle;
281
282 sp<Fence> fence(new Fence(fenceFd));
283 fence->wait(Fence::TIMEOUT_NEVER);
284
285 const int index = self->mCurrentBufferIndex;
286 int res = fb->post(fb, handle);
287 self->front = static_cast<NativeBuffer*>(buffer);
288 self->mNumFreeBuffers++;
289 self->mCondition.broadcast();
290 return res;
291 }
292
query(const ANativeWindow * window,int what,int * value)293 int FramebufferNativeWindow::query(const ANativeWindow* window,
294 int what, int* value)
295 {
296 const FramebufferNativeWindow* self = getSelf(window);
297 Mutex::Autolock _l(self->mutex);
298 framebuffer_device_t* fb = self->fbDev;
299 switch (what) {
300 case NATIVE_WINDOW_WIDTH:
301 *value = fb->width;
302 return NO_ERROR;
303 case NATIVE_WINDOW_HEIGHT:
304 *value = fb->height;
305 return NO_ERROR;
306 case NATIVE_WINDOW_FORMAT:
307 *value = fb->format;
308 return NO_ERROR;
309 case NATIVE_WINDOW_CONCRETE_TYPE:
310 *value = NATIVE_WINDOW_FRAMEBUFFER;
311 return NO_ERROR;
312 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER:
313 *value = 0;
314 return NO_ERROR;
315 case NATIVE_WINDOW_DEFAULT_WIDTH:
316 *value = fb->width;
317 return NO_ERROR;
318 case NATIVE_WINDOW_DEFAULT_HEIGHT:
319 *value = fb->height;
320 return NO_ERROR;
321 case NATIVE_WINDOW_TRANSFORM_HINT:
322 *value = 0;
323 return NO_ERROR;
324 }
325 *value = 0;
326 return BAD_VALUE;
327 }
328
perform(ANativeWindow * window,int operation,...)329 int FramebufferNativeWindow::perform(ANativeWindow* window,
330 int operation, ...)
331 {
332 switch (operation) {
333 case NATIVE_WINDOW_CONNECT:
334 case NATIVE_WINDOW_DISCONNECT:
335 case NATIVE_WINDOW_SET_USAGE:
336 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
337 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:
338 case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
339 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
340 case NATIVE_WINDOW_API_CONNECT:
341 case NATIVE_WINDOW_API_DISCONNECT:
342 // TODO: we should implement these
343 return NO_ERROR;
344
345 case NATIVE_WINDOW_LOCK:
346 case NATIVE_WINDOW_UNLOCK_AND_POST:
347 case NATIVE_WINDOW_SET_CROP:
348 case NATIVE_WINDOW_SET_BUFFER_COUNT:
349 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
350 case NATIVE_WINDOW_SET_SCALING_MODE:
351 return INVALID_OPERATION;
352 }
353 return NAME_NOT_FOUND;
354 }
355
356 // ----------------------------------------------------------------------------
357 }; // namespace android
358 // ----------------------------------------------------------------------------
359
360 using namespace android;
361
android_createDisplaySurface(void)362 EGLNativeWindowType android_createDisplaySurface(void)
363 {
364 FramebufferNativeWindow* w;
365 w = new FramebufferNativeWindow();
366 if (w->getDevice() == NULL) {
367 // get a ref so it can be destroyed when we exit this block
368 sp<FramebufferNativeWindow> ref(w);
369 return NULL;
370 }
371 return (EGLNativeWindowType)w;
372 }
373