FramebufferNativeWindow.cpp revision ff78750c6432f3b73c97cac05728c5d165ba0f27
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#define INCLUDED_FROM_FRAMEBUFFER_NATIVE_WINDOW_CPP 33#include <ui/FramebufferNativeWindow.h> 34#undef INCLUDED_FROM_FRAMEBUFFER_NATIVE_WINDOW_CPP 35#include <ui/Rect.h> 36 37#include <EGL/egl.h> 38 39#include <hardware/hardware.h> 40#include <hardware/gralloc.h> 41 42// ---------------------------------------------------------------------------- 43namespace android { 44// ---------------------------------------------------------------------------- 45 46class NativeBuffer final 47 : public ANativeObjectBase< 48 ANativeWindowBuffer, 49 NativeBuffer, 50 LightRefBase<NativeBuffer>> 51{ 52public: 53 NativeBuffer(int w, int h, int f, int u) : BASE() { 54 ANativeWindowBuffer::width = w; 55 ANativeWindowBuffer::height = h; 56 ANativeWindowBuffer::format = f; 57 ANativeWindowBuffer::usage = u; 58 } 59private: 60 friend class LightRefBase<NativeBuffer>; 61}; 62 63 64/* 65 * This implements the (main) framebuffer management. This class is used 66 * mostly by SurfaceFlinger, but also by command line GL application. 67 * 68 * In fact this is an implementation of ANativeWindow on top of 69 * the framebuffer. 70 * 71 * Currently it is pretty simple, it manages only two buffers (the front and 72 * back buffer). 73 * 74 */ 75 76FramebufferNativeWindow::FramebufferNativeWindow() 77 : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false) 78{ 79 hw_module_t const* module; 80 if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) { 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 buffers[i] = new NativeBuffer( 119 static_cast<int>(fbDev->width), 120 static_cast<int>(fbDev->height), 121 fbDev->format, GRALLOC_USAGE_HW_FB); 122 } 123 124 for (i = 0; i < mNumBuffers; i++) { 125 err = grDev->alloc(grDev, 126 static_cast<int>(fbDev->width), 127 static_cast<int>(fbDev->height), 128 fbDev->format, GRALLOC_USAGE_HW_FB, 129 &buffers[i]->handle, &buffers[i]->stride); 130 131 ALOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s", 132 i, fbDev->width, fbDev->height, strerror(-err)); 133 134 if (err) { 135 mNumBuffers = i; 136 mNumFreeBuffers = i; 137 mBufferHead = mNumBuffers-1; 138 break; 139 } 140 } 141 142 const_cast<uint32_t&>(ANativeWindow::flags) = fbDev->flags; 143 const_cast<float&>(ANativeWindow::xdpi) = fbDev->xdpi; 144 const_cast<float&>(ANativeWindow::ydpi) = fbDev->ydpi; 145 const_cast<int&>(ANativeWindow::minSwapInterval) = 146 fbDev->minSwapInterval; 147 const_cast<int&>(ANativeWindow::maxSwapInterval) = 148 fbDev->maxSwapInterval; 149 } else { 150 ALOGE("Couldn't get gralloc module"); 151 } 152 153 ANativeWindow::setSwapInterval = setSwapInterval; 154 ANativeWindow::dequeueBuffer = dequeueBuffer; 155 ANativeWindow::queueBuffer = queueBuffer; 156 ANativeWindow::query = query; 157 ANativeWindow::perform = perform; 158 159 ANativeWindow::dequeueBuffer_DEPRECATED = dequeueBuffer_DEPRECATED; 160 ANativeWindow::lockBuffer_DEPRECATED = lockBuffer_DEPRECATED; 161 ANativeWindow::queueBuffer_DEPRECATED = queueBuffer_DEPRECATED; 162} 163 164FramebufferNativeWindow::~FramebufferNativeWindow() 165{ 166 if (grDev) { 167 for(int i = 0; i < mNumBuffers; i++) { 168 if (buffers[i] != NULL) { 169 grDev->free(grDev, buffers[i]->handle); 170 } 171 } 172 gralloc_close(grDev); 173 } 174 175 if (fbDev) { 176 framebuffer_close(fbDev); 177 } 178} 179 180status_t FramebufferNativeWindow::setUpdateRectangle(const Rect& r) 181{ 182 if (!mUpdateOnDemand) { 183 return INVALID_OPERATION; 184 } 185 return fbDev->setUpdateRect(fbDev, r.left, r.top, r.width(), r.height()); 186} 187 188status_t FramebufferNativeWindow::compositionComplete() 189{ 190 if (fbDev->compositionComplete) { 191 return fbDev->compositionComplete(fbDev); 192 } 193 return INVALID_OPERATION; 194} 195 196int FramebufferNativeWindow::setSwapInterval( 197 ANativeWindow* window, int interval) 198{ 199 framebuffer_device_t* fb = getSelf(window)->fbDev; 200 return fb->setSwapInterval(fb, interval); 201} 202 203void FramebufferNativeWindow::dump(String8& result) { 204 if (fbDev->common.version >= 1 && fbDev->dump) { 205 const size_t SIZE = 4096; 206 char buffer[SIZE]; 207 208 fbDev->dump(fbDev, buffer, SIZE); 209 result.append(buffer); 210 } 211} 212 213// only for debugging / logging 214int FramebufferNativeWindow::getCurrentBufferIndex() const 215{ 216 Mutex::Autolock _l(mutex); 217 const int index = mCurrentBufferIndex; 218 return index; 219} 220 221int FramebufferNativeWindow::dequeueBuffer_DEPRECATED(ANativeWindow* window, 222 ANativeWindowBuffer** buffer) 223{ 224 int fenceFd = -1; 225 int result = dequeueBuffer(window, buffer, &fenceFd); 226 sp<Fence> fence(new Fence(fenceFd)); 227 int waitResult = fence->wait(Fence::TIMEOUT_NEVER); 228 if (waitResult != OK) { 229 ALOGE("dequeueBuffer_DEPRECATED: Fence::wait returned an " 230 "error: %d", waitResult); 231 return waitResult; 232 } 233 return result; 234} 235 236int FramebufferNativeWindow::dequeueBuffer(ANativeWindow* window, 237 ANativeWindowBuffer** buffer, int* fenceFd) 238{ 239 FramebufferNativeWindow* self = getSelf(window); 240 Mutex::Autolock _l(self->mutex); 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 262int FramebufferNativeWindow::lockBuffer_DEPRECATED(ANativeWindow* /*window*/, 263 ANativeWindowBuffer* /*buffer*/) 264{ 265 return NO_ERROR; 266} 267 268int FramebufferNativeWindow::queueBuffer_DEPRECATED(ANativeWindow* window, 269 ANativeWindowBuffer* buffer) 270{ 271 return queueBuffer(window, buffer, -1); 272} 273 274int 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 int res = fb->post(fb, handle); 286 self->front = static_cast<NativeBuffer*>(buffer); 287 self->mNumFreeBuffers++; 288 self->mCondition.broadcast(); 289 return res; 290} 291 292int FramebufferNativeWindow::query(const ANativeWindow* window, 293 int what, int* value) 294{ 295 const FramebufferNativeWindow* self = getSelf(window); 296 Mutex::Autolock _l(self->mutex); 297 framebuffer_device_t* fb = self->fbDev; 298 switch (what) { 299 case NATIVE_WINDOW_WIDTH: 300 *value = static_cast<int>(fb->width); 301 return NO_ERROR; 302 case NATIVE_WINDOW_HEIGHT: 303 *value = static_cast<int>(fb->height); 304 return NO_ERROR; 305 case NATIVE_WINDOW_FORMAT: 306 *value = fb->format; 307 return NO_ERROR; 308 case NATIVE_WINDOW_CONCRETE_TYPE: 309 *value = NATIVE_WINDOW_FRAMEBUFFER; 310 return NO_ERROR; 311 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: 312 *value = 0; 313 return NO_ERROR; 314 case NATIVE_WINDOW_DEFAULT_WIDTH: 315 *value = static_cast<int>(fb->width); 316 return NO_ERROR; 317 case NATIVE_WINDOW_DEFAULT_HEIGHT: 318 *value = static_cast<int>(fb->height); 319 return NO_ERROR; 320 case NATIVE_WINDOW_TRANSFORM_HINT: 321 *value = 0; 322 return NO_ERROR; 323 } 324 *value = 0; 325 return BAD_VALUE; 326} 327 328int FramebufferNativeWindow::perform(ANativeWindow* /*window*/, 329 int operation, ...) 330{ 331 switch (operation) { 332 case NATIVE_WINDOW_CONNECT: 333 case NATIVE_WINDOW_DISCONNECT: 334 case NATIVE_WINDOW_SET_USAGE: 335 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY: 336 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS: 337 case NATIVE_WINDOW_SET_BUFFERS_FORMAT: 338 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM: 339 case NATIVE_WINDOW_API_CONNECT: 340 case NATIVE_WINDOW_API_DISCONNECT: 341 // TODO: we should implement these 342 return NO_ERROR; 343 344 case NATIVE_WINDOW_LOCK: 345 case NATIVE_WINDOW_UNLOCK_AND_POST: 346 case NATIVE_WINDOW_SET_CROP: 347 case NATIVE_WINDOW_SET_BUFFER_COUNT: 348 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP: 349 case NATIVE_WINDOW_SET_SCALING_MODE: 350 return INVALID_OPERATION; 351 } 352 return NAME_NOT_FOUND; 353} 354 355// ---------------------------------------------------------------------------- 356}; // namespace android 357// ---------------------------------------------------------------------------- 358 359using android::sp; 360using android::FramebufferNativeWindow; 361 362EGLNativeWindowType 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 static_cast<EGLNativeWindowType>(w); 372} 373