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/SurfaceComposerClient.h>
31 #include <ui/Rect.h>
32 #include <ui/FramebufferNativeWindow.h>
33
34 #include <EGL/egl.h>
35
36 #include <pixelflinger/format.h>
37 #include <pixelflinger/pixelflinger.h>
38
39 #include <hardware/hardware.h>
40 #include <hardware/gralloc.h>
41
42 #include <private/ui/android_natives_priv.h>
43
44 // ----------------------------------------------------------------------------
45 namespace android {
46 // ----------------------------------------------------------------------------
47
48 class NativeBuffer
49 : public EGLNativeBase<
50 android_native_buffer_t,
51 NativeBuffer,
52 LightRefBase<NativeBuffer> >
53 {
54 public:
NativeBuffer(int w,int h,int f,int u)55 NativeBuffer(int w, int h, int f, int u) : BASE() {
56 android_native_buffer_t::width = w;
57 android_native_buffer_t::height = h;
58 android_native_buffer_t::format = f;
59 android_native_buffer_t::usage = u;
60 }
61 private:
62 friend class LightRefBase<NativeBuffer>;
~NativeBuffer()63 ~NativeBuffer() { }; // this class cannot be overloaded
64 };
65
66
67 /*
68 * This implements the (main) framebuffer management. This class is used
69 * mostly by SurfaceFlinger, but also by command line GL application.
70 *
71 * In fact this is an implementation of android_native_window_t on top of
72 * the framebuffer.
73 *
74 * Currently it is pretty simple, it manages only two buffers (the front and
75 * back buffer).
76 *
77 */
78
FramebufferNativeWindow()79 FramebufferNativeWindow::FramebufferNativeWindow()
80 : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false)
81 {
82 hw_module_t const* module;
83 if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) {
84 int stride;
85 int err;
86 err = framebuffer_open(module, &fbDev);
87 LOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err));
88
89 err = gralloc_open(module, &grDev);
90 LOGE_IF(err, "couldn't open gralloc HAL (%s)", strerror(-err));
91
92 // bail out if we can't initialize the modules
93 if (!fbDev || !grDev)
94 return;
95
96 mUpdateOnDemand = (fbDev->setUpdateRect != 0);
97
98 // initialize the buffer FIFO
99 mNumBuffers = 2;
100 mNumFreeBuffers = 2;
101 mBufferHead = mNumBuffers-1;
102 buffers[0] = new NativeBuffer(
103 fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);
104 buffers[1] = new NativeBuffer(
105 fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);
106
107 err = grDev->alloc(grDev,
108 fbDev->width, fbDev->height, fbDev->format,
109 GRALLOC_USAGE_HW_FB, &buffers[0]->handle, &buffers[0]->stride);
110
111 LOGE_IF(err, "fb buffer 0 allocation failed w=%d, h=%d, err=%s",
112 fbDev->width, fbDev->height, strerror(-err));
113
114 err = grDev->alloc(grDev,
115 fbDev->width, fbDev->height, fbDev->format,
116 GRALLOC_USAGE_HW_FB, &buffers[1]->handle, &buffers[1]->stride);
117
118 LOGE_IF(err, "fb buffer 1 allocation failed w=%d, h=%d, err=%s",
119 fbDev->width, fbDev->height, strerror(-err));
120
121 const_cast<uint32_t&>(android_native_window_t::flags) = fbDev->flags;
122 const_cast<float&>(android_native_window_t::xdpi) = fbDev->xdpi;
123 const_cast<float&>(android_native_window_t::ydpi) = fbDev->ydpi;
124 const_cast<int&>(android_native_window_t::minSwapInterval) =
125 fbDev->minSwapInterval;
126 const_cast<int&>(android_native_window_t::maxSwapInterval) =
127 fbDev->maxSwapInterval;
128 } else {
129 LOGE("Couldn't get gralloc module");
130 }
131
132 android_native_window_t::setSwapInterval = setSwapInterval;
133 android_native_window_t::dequeueBuffer = dequeueBuffer;
134 android_native_window_t::lockBuffer = lockBuffer;
135 android_native_window_t::queueBuffer = queueBuffer;
136 android_native_window_t::query = query;
137 android_native_window_t::perform = perform;
138 }
139
~FramebufferNativeWindow()140 FramebufferNativeWindow::~FramebufferNativeWindow()
141 {
142 if (grDev) {
143 if (buffers[0] != NULL)
144 grDev->free(grDev, buffers[0]->handle);
145 if (buffers[1] != NULL)
146 grDev->free(grDev, buffers[1]->handle);
147 gralloc_close(grDev);
148 }
149
150 if (fbDev) {
151 framebuffer_close(fbDev);
152 }
153 }
154
setUpdateRectangle(const Rect & r)155 status_t FramebufferNativeWindow::setUpdateRectangle(const Rect& r)
156 {
157 if (!mUpdateOnDemand) {
158 return INVALID_OPERATION;
159 }
160 return fbDev->setUpdateRect(fbDev, r.left, r.top, r.width(), r.height());
161 }
162
compositionComplete()163 status_t FramebufferNativeWindow::compositionComplete()
164 {
165 if (fbDev->compositionComplete) {
166 return fbDev->compositionComplete(fbDev);
167 }
168 return INVALID_OPERATION;
169 }
170
setSwapInterval(android_native_window_t * window,int interval)171 int FramebufferNativeWindow::setSwapInterval(
172 android_native_window_t* window, int interval)
173 {
174 framebuffer_device_t* fb = getSelf(window)->fbDev;
175 return fb->setSwapInterval(fb, interval);
176 }
177
dequeueBuffer(android_native_window_t * window,android_native_buffer_t ** buffer)178 int FramebufferNativeWindow::dequeueBuffer(android_native_window_t* window,
179 android_native_buffer_t** buffer)
180 {
181 FramebufferNativeWindow* self = getSelf(window);
182 Mutex::Autolock _l(self->mutex);
183 framebuffer_device_t* fb = self->fbDev;
184
185 // wait for a free buffer
186 while (!self->mNumFreeBuffers) {
187 self->mCondition.wait(self->mutex);
188 }
189 // get this buffer
190 self->mNumFreeBuffers--;
191 int index = self->mBufferHead++;
192 if (self->mBufferHead >= self->mNumBuffers)
193 self->mBufferHead = 0;
194
195 *buffer = self->buffers[index].get();
196
197 return 0;
198 }
199
lockBuffer(android_native_window_t * window,android_native_buffer_t * buffer)200 int FramebufferNativeWindow::lockBuffer(android_native_window_t* window,
201 android_native_buffer_t* buffer)
202 {
203 FramebufferNativeWindow* self = getSelf(window);
204 Mutex::Autolock _l(self->mutex);
205
206 // wait that the buffer we're locking is not front anymore
207 while (self->front == buffer) {
208 self->mCondition.wait(self->mutex);
209 }
210
211 return NO_ERROR;
212 }
213
queueBuffer(android_native_window_t * window,android_native_buffer_t * buffer)214 int FramebufferNativeWindow::queueBuffer(android_native_window_t* window,
215 android_native_buffer_t* buffer)
216 {
217 FramebufferNativeWindow* self = getSelf(window);
218 Mutex::Autolock _l(self->mutex);
219 framebuffer_device_t* fb = self->fbDev;
220 buffer_handle_t handle = static_cast<NativeBuffer*>(buffer)->handle;
221 int res = fb->post(fb, handle);
222 self->front = static_cast<NativeBuffer*>(buffer);
223 self->mNumFreeBuffers++;
224 self->mCondition.broadcast();
225 return res;
226 }
227
query(android_native_window_t * window,int what,int * value)228 int FramebufferNativeWindow::query(android_native_window_t* window,
229 int what, int* value)
230 {
231 FramebufferNativeWindow* self = getSelf(window);
232 Mutex::Autolock _l(self->mutex);
233 framebuffer_device_t* fb = self->fbDev;
234 switch (what) {
235 case NATIVE_WINDOW_WIDTH:
236 *value = fb->width;
237 return NO_ERROR;
238 case NATIVE_WINDOW_HEIGHT:
239 *value = fb->height;
240 return NO_ERROR;
241 case NATIVE_WINDOW_FORMAT:
242 *value = fb->format;
243 return NO_ERROR;
244 }
245 *value = 0;
246 return BAD_VALUE;
247 }
248
perform(android_native_window_t * window,int operation,...)249 int FramebufferNativeWindow::perform(android_native_window_t* window,
250 int operation, ...)
251 {
252 switch (operation) {
253 case NATIVE_WINDOW_SET_USAGE:
254 break;
255 default:
256 return NAME_NOT_FOUND;
257 }
258 return NO_ERROR;
259 }
260
261 // ----------------------------------------------------------------------------
262 }; // namespace android
263 // ----------------------------------------------------------------------------
264
265 using namespace android;
266
android_createDisplaySurface(void)267 EGLNativeWindowType android_createDisplaySurface(void)
268 {
269 FramebufferNativeWindow* w;
270 w = new FramebufferNativeWindow();
271 if (w->getDevice() == NULL) {
272 // get a ref so it can be destroyed when we exit this block
273 sp<FramebufferNativeWindow> ref(w);
274 return NULL;
275 }
276 return (EGLNativeWindowType)w;
277 }
278