/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "SurfaceFlinger"
#include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
#include <cutils/properties.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <utils/StopWatch.h>
#include <ui/PixelFormat.h>
#include <ui/EGLDisplaySurface.h>
#include "clz.h"
#include "Layer.h"
#include "LayerBitmap.h"
#include "SurfaceFlinger.h"
#include "VRamHeap.h"
#include "DisplayHardware/DisplayHardware.h"
#define DEBUG_RESIZE 0
namespace android {
// ---------------------------------------------------------------------------
const uint32_t Layer::typeInfo = LayerBaseClient::typeInfo | 4;
const char* const Layer::typeID = "Layer";
// ---------------------------------------------------------------------------
Layer::Layer(SurfaceFlinger* flinger, DisplayID display, Client* c, int32_t i)
: LayerBaseClient(flinger, display, c, i),
mSecure(false),
mFrontBufferIndex(1),
mNeedsBlending(true),
mResizeTransactionDone(false),
mTextureName(-1U), mTextureWidth(0), mTextureHeight(0)
{
// no OpenGL operation is possible here, since we might not be
// in the OpenGL thread.
}
Layer::~Layer()
{
client->free(clientIndex());
// this should always be called from the OpenGL thread
if (mTextureName != -1U) {
//glDeleteTextures(1, &mTextureName);
deletedTextures.add(mTextureName);
}
}
void Layer::initStates(uint32_t w, uint32_t h, uint32_t flags)
{
LayerBase::initStates(w,h,flags);
if (flags & ISurfaceComposer::eDestroyBackbuffer)
lcblk->flags |= eNoCopyBack;
}
sp<LayerBaseClient::Surface> Layer::getSurface() const
{
return mSurface;
}
status_t Layer::setBuffers( Client* client,
uint32_t w, uint32_t h,
PixelFormat format, uint32_t flags)
{
PixelFormatInfo info;
status_t err = getPixelFormatInfo(format, &info);
if (err) return err;
// TODO: if eHardware is explicitly requested, we should fail
// on systems where we can't allocate memory that can be used with
// DMA engines for instance.
// FIXME: we always ask for hardware for now (this should come from copybit)
flags |= ISurfaceComposer::eHardware;
const uint32_t memory_flags = flags &
(ISurfaceComposer::eGPU |
ISurfaceComposer::eHardware |
ISurfaceComposer::eSecure);
// pixel-alignment. the final alignment may be bigger because
// we always force a 4-byte aligned bpr.
uint32_t alignment = 1;
if ((flags & ISurfaceComposer::eGPU) && (mFlinger->getGPU() != 0)) {
// FIXME: this value should come from the h/w
alignment = 8;
// FIXME: this is msm7201A specific, as its GPU only supports
// BGRA_8888.
if (format == PIXEL_FORMAT_RGBA_8888) {
format = PIXEL_FORMAT_BGRA_8888;
}
}
mSecure = (flags & ISurfaceComposer::eSecure) ? true : false;
mNeedsBlending = (info.h_alpha - info.l_alpha) > 0;
sp<MemoryDealer> allocators[2];
for (int i=0 ; i<2 ; i++) {
allocators[i] = client->createAllocator(memory_flags);
if (allocators[i] == 0)
return NO_MEMORY;
mBuffers[i].init(allocators[i]);
int err = mBuffers[i].setBits(w, h, alignment, format, LayerBitmap::SECURE_BITS);
if (err != NO_ERROR)
return err;
mBuffers[i].clear(); // clear the bits for security
mBuffers[i].getInfo(lcblk->surface + i);
}
mSurface = new Surface(clientIndex(),
allocators[0]->getMemoryHeap(),
allocators[1]->getMemoryHeap(),
mIdentity);
return NO_ERROR;
}
void Layer::reloadTexture(const Region& dirty)
{
if (UNLIKELY(mTextureName == -1U)) {
// create the texture name the first time
// can't do that in the ctor, because it runs in another thread.
mTextureName = createTexture();
}
const GGLSurface& t(frontBuffer().surface());
loadTexture(dirty, mTextureName, t, mTextureWidth, mTextureHeight);
}
void Layer::onDraw(const Region& clip) const
{
if (UNLIKELY(mTextureName == -1LU)) {
//LOGW("Layer %p doesn't have a texture", this);
// the texture has not been created yet, this Layer has
// in fact never been drawn into. this happens frequently with
// SurfaceView.
clearWithOpenGL(clip);
return;
}
const DisplayHardware& hw(graphicPlane(0).displayHardware());
const LayerBitmap& front(frontBuffer());
const GGLSurface& t(front.surface());
status_t err = NO_ERROR;
const int can_use_copybit = canUseCopybit();
if (can_use_copybit) {
// StopWatch watch("copybit");
const State& s(drawingState());
copybit_image_t dst;
hw.getDisplaySurface(&dst);
const copybit_rect_t& drect
= reinterpret_cast<const copybit_rect_t&>(mTransformedBounds);
copybit_image_t src;
front.getBitmapSurface(&src);
copybit_rect_t srect = { 0, 0, t.width, t.height };
copybit_device_t* copybit = mFlinger->getBlitEngine();
copybit->set_parameter(copybit, COPYBIT_TRANSFORM, getOrientation());
copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, s.alpha);
copybit->set_parameter(copybit, COPYBIT_DITHER,
s.flags & ISurfaceComposer::eLayerDither ?
COPYBIT_ENABLE : COPYBIT_DISABLE);
region_iterator it(clip);
err = copybit->stretch(copybit, &dst, &src, &drect, &srect, &it);
}
if (!can_use_copybit || err) {
drawWithOpenGL(clip, mTextureName, t);
}
}
status_t Layer::reallocateBuffer(int32_t index, uint32_t w, uint32_t h)
{
LOGD_IF(DEBUG_RESIZE,
"reallocateBuffer (layer=%p), "
"requested (%dx%d), "
"index=%d, (%dx%d), (%dx%d)",
this,
int(w), int(h),
int(index),
int(mBuffers[0].width()), int(mBuffers[0].height()),
int(mBuffers[1].width()), int(mBuffers[1].height()));
status_t err = mBuffers[index].resize(w, h);
if (err == NO_ERROR) {
mBuffers[index].getInfo(lcblk->surface + index);
} else {
LOGE("resizing buffer %d to (%u,%u) failed [%08x] %s",
index, w, h, err, strerror(err));
// XXX: what to do, what to do? We could try to free some
// hidden surfaces, instead of killing this one?
}
return err;
}
uint32_t Layer::doTransaction(uint32_t flags)
{
const Layer::State& front(drawingState());
const Layer::State& temp(currentState());
// the test front.{w|h} != temp.{w|h} is not enough because it is possible
// that the size changed back to its previous value before the buffer
// was resized (in the eLocked case below), in which case, we still
// need to execute the code below so the clients have a chance to be
// release. resze() deals with the fact that the size can be the same.
/*
* Various states we could be in...
resize = state & eResizeRequested;
if (backbufferChanged) {
if (resize == 0) {
// ERROR, the resized buffer doesn't have its resize flag set
} else if (resize == mask) {
// ERROR one of the buffer has already been resized
} else if (resize == mask ^ eResizeRequested) {
// ERROR, the resized buffer doesn't have its resize flag set
} else if (resize == eResizeRequested) {
// OK, Normal case, proceed with resize
}
} else {
if (resize == 0) {
// OK, nothing special, do nothing
} else if (resize == mask) {
// restarted transaction, do nothing
} else if (resize == mask ^ eResizeRequested) {
// restarted transaction, do nothing
} else if (resize == eResizeRequested) {
// OK, size reset to previous value, proceed with resize
}
}
*/
// Index of the back buffer
const bool backbufferChanged = (front.w != temp.w) || (front.h != temp.h);
const uint32_t state = lcblk->swapState;
const int32_t clientBackBufferIndex = layer_cblk_t::backBuffer(state);
const uint32_t mask = clientBackBufferIndex ? eResizeBuffer1 : eResizeBuffer0;
uint32_t resizeFlags = state & eResizeRequested;
if (UNLIKELY(backbufferChanged && (resizeFlags != eResizeRequested))) {
LOGE( "backbuffer size changed, but both resize flags are not set! "
"(layer=%p), state=%08x, requested (%dx%d), drawing (%d,%d), "
"index=%d, (%dx%d), (%dx%d)",
this, state,
int(temp.w), int(temp.h),
int(drawingState().w), int(drawingState().h),
int(clientBackBufferIndex),
int(mBuffers[0].width()), int(mBuffers[0].height()),
int(mBuffers[1].width()), int(mBuffers[1].height()));
// if we get there we're pretty screwed. the only reasonable
// thing to do is to pretend we should do the resize since
// backbufferChanged is set (this also will give a chance to
// client to get unblocked)
resizeFlags = eResizeRequested;
}
if (resizeFlags == eResizeRequested) {
// NOTE: asserting that clientBackBufferIndex!=mFrontBufferIndex
// here, would be wrong and misleading because by this point
// mFrontBufferIndex has not been updated yet.
LOGD_IF(DEBUG_RESIZE,
"resize (layer=%p), state=%08x, "
"requested (%dx%d), "
"drawing (%d,%d), "
"index=%d, (%dx%d), (%dx%d)",
this, state,
int(temp.w), int(temp.h),
int(drawingState().w), int(drawingState().h),
int(clientBackBufferIndex),
int(mBuffers[0].width()), int(mBuffers[0].height()),
int(mBuffers[1].width()), int(mBuffers[1].height()));
if (state & eLocked) {
// if the buffer is locked, we can't resize anything because
// - the backbuffer is currently in use by the user
// - the front buffer is being shown
// We just act as if the transaction didn't happen and we
// reschedule it later...
flags |= eRestartTransaction;
} else {
// This buffer needs to be resized
status_t err =
resize(clientBackBufferIndex, temp.w, temp.h, "transaction");
if (err == NO_ERROR) {
const uint32_t mask = clientBackBufferIndex ? eResizeBuffer1 : eResizeBuffer0;
android_atomic_and(~mask, &(lcblk->swapState));
// since a buffer became available, we can let the client go...
mFlinger->scheduleBroadcast(client);
mResizeTransactionDone = true;
// we're being resized and there is a freeze display request,
// acquire a freeze lock, so that the screen stays put
// until we've redrawn at the new size; this is to avoid
// glitches upon orientation changes.
if (mFlinger->hasFreezeRequest()) {
// if the surface is hidden, don't try to acquire the
// freeze lock, since hidden surfaces may never redraw
if (!(front.flags & ISurfaceComposer::eLayerHidden)) {
mFreezeLock = mFlinger->getFreezeLock();
}
}
}
}
}
if (temp.sequence != front.sequence) {
if (temp.flags & ISurfaceComposer::eLayerHidden || temp.alpha == 0) {
// this surface is now hidden, so it shouldn't hold a freeze lock
// (it may never redraw, which is fine if it is hidden)
mFreezeLock.clear();
}
}
return LayerBase::doTransaction(flags);
}
status_t Layer::resize(
int32_t clientBackBufferIndex,
uint32_t width, uint32_t height,
const char* what)
{
/*
* handle resize (backbuffer and frontbuffer reallocation)
*/
const LayerBitmap& clientBackBuffer(mBuffers[clientBackBufferIndex]);
// if the new (transaction) size is != from the the backbuffer
// then we need to reallocate the backbuffer
bool backbufferChanged = (clientBackBuffer.width() != width) ||
(clientBackBuffer.height() != height);
LOGD_IF(!backbufferChanged,
"(%s) eResizeRequested (layer=%p), but size not changed: "
"requested (%dx%d), drawing (%d,%d), current (%d,%d),"
"state=%08lx, index=%d, (%dx%d), (%dx%d)",
what, this,
int(width), int(height),
int(drawingState().w), int(drawingState().h),
int(currentState().w), int(currentState().h),
long(lcblk->swapState),
int(clientBackBufferIndex),
int(mBuffers[0].width()), int(mBuffers[0].height()),
int(mBuffers[1].width()), int(mBuffers[1].height()));
// this can happen when changing the size back and forth quickly
status_t err = NO_ERROR;
if (backbufferChanged) {
err = reallocateBuffer(clientBackBufferIndex, width, height);
}
if (UNLIKELY(err != NO_ERROR)) {
// couldn't reallocate the surface
android_atomic_write(eInvalidSurface, &lcblk->swapState);
memset(lcblk->surface+clientBackBufferIndex, 0, sizeof(surface_info_t));
}
return err;
}
void Layer::setSizeChanged(uint32_t w, uint32_t h)
{
LOGD_IF(DEBUG_RESIZE,
"setSizeChanged w=%d, h=%d (old: w=%d, h=%d)",
w, h, mCurrentState.w, mCurrentState.h);
android_atomic_or(eResizeRequested, &(lcblk->swapState));
}
// ----------------------------------------------------------------------------
// pageflip handling...
// ----------------------------------------------------------------------------
void Layer::lockPageFlip(bool& recomputeVisibleRegions)
{
uint32_t state = android_atomic_or(eBusy, &(lcblk->swapState));
// preemptively block the client, because he might set
// eFlipRequested at any time and want to use this buffer
// for the next frame. This will be unset below if it
// turns out we didn't need it.
uint32_t mask = eInvalidSurface | eFlipRequested | eResizeRequested;
if (!(state & mask))
return;
if (UNLIKELY(state & eInvalidSurface)) {
// if eInvalidSurface is set, this means the surface
// became invalid during a transaction (NO_MEMORY for instance)
mFlinger->scheduleBroadcast(client);
return;
}
if (UNLIKELY(state & eFlipRequested)) {
uint32_t oldState;
mPostedDirtyRegion = post(&oldState, recomputeVisibleRegions);
if (oldState & eNextFlipPending) {
// Process another round (we know at least a buffer
// is ready for that client).
mFlinger->signalEvent();
}
}
}
Region Layer::post(uint32_t* previousSate, bool& recomputeVisibleRegions)
{
// atomically swap buffers and (re)set eFlipRequested
int32_t oldValue, newValue;
layer_cblk_t * const lcblk = this->lcblk;
do {
oldValue = lcblk->swapState;
// get the current value
LOG_ASSERT(oldValue&eFlipRequested,
"eFlipRequested not set, yet we're flipping! (state=0x%08lx)",
long(oldValue));
newValue = (oldValue ^ eIndex);
// swap buffers
newValue &= ~(eFlipRequested | eNextFlipPending);
// clear eFlipRequested and eNextFlipPending
if (oldValue & eNextFlipPending)
newValue |= eFlipRequested;
// if eNextFlipPending is set (second buffer already has something
// in it) we need to reset eFlipRequested because the client
// might never do it
} while(android_atomic_cmpxchg(oldValue, newValue, &(lcblk->swapState)));
*previousSate = oldValue;
const int32_t index = (newValue & eIndex) ^ 1;
mFrontBufferIndex = index;
// ... post the new front-buffer
Region dirty(lcblk->region + index);
dirty.andSelf(frontBuffer().bounds());
//LOGI("Did post oldValue=%08lx, newValue=%08lx, mFrontBufferIndex=%u\n",
// oldValue, newValue, mFrontBufferIndex);
//dirty.dump("dirty");
if (UNLIKELY(oldValue & eResizeRequested)) {
LOGD_IF(DEBUG_RESIZE,
"post (layer=%p), state=%08x, "
"index=%d, (%dx%d), (%dx%d)",
this, newValue,
int(1-index),
int(mBuffers[0].width()), int(mBuffers[0].height()),
int(mBuffers[1].width()), int(mBuffers[1].height()));
// here, we just posted the surface and we have resolved
// the front/back buffer indices. The client is blocked, so
// it cannot start using the new backbuffer.
// If the backbuffer was resized in THIS round, we actually cannot
// resize the frontbuffer because it has *just* been drawn (and we
// would have nothing to draw). In this case we just skip the resize
// it'll happen after the next page flip or during the next
// transaction.
const uint32_t mask = (1-index) ? eResizeBuffer1 : eResizeBuffer0;
if (mResizeTransactionDone && (newValue & mask)) {
// Resize the layer's second buffer only if the transaction
// happened. It may not have happened yet if eResizeRequested
// was set immediately after the "transactionRequested" test,
// in which case the drawing state's size would be wrong.
mFreezeLock.clear();
const Layer::State& s(drawingState());
if (resize(1-index, s.w, s.h, "post") == NO_ERROR) {
do {
oldValue = lcblk->swapState;
if ((oldValue & eResizeRequested) == eResizeRequested) {
// ugh, another resize was requested since we processed
// the first buffer, don't free the client, and let
// the next transaction handle everything.
break;
}
newValue = oldValue & ~mask;
} while(android_atomic_cmpxchg(oldValue, newValue, &(lcblk->swapState)));
}
mResizeTransactionDone = false;
recomputeVisibleRegions = true;
this->contentDirty = true;
}
}
reloadTexture(dirty);
return dirty;
}
Point Layer::getPhysicalSize() const
{
const LayerBitmap& front(frontBuffer());
return Point(front.width(), front.height());
}
void Layer::unlockPageFlip(
const Transform& planeTransform, Region& outDirtyRegion)
{
Region dirtyRegion(mPostedDirtyRegion);
if (!dirtyRegion.isEmpty()) {
mPostedDirtyRegion.clear();
// The dirty region is given in the layer's coordinate space
// transform the dirty region by the surface's transformation
// and the global transformation.
const Layer::State& s(drawingState());
const Transform tr(planeTransform * s.transform);
dirtyRegion = tr.transform(dirtyRegion);
// At this point, the dirty region is in screen space.
// Make sure it's constrained by the visible region (which
// is in screen space as well).
dirtyRegion.andSelf(visibleRegionScreen);
outDirtyRegion.orSelf(dirtyRegion);
// client could be blocked, so signal them so they get a
// chance to reevaluate their condition.
mFlinger->scheduleBroadcast(client);
}
}
void Layer::finishPageFlip()
{
if (LIKELY(!(lcblk->swapState & eInvalidSurface))) {
LOGE_IF(!(lcblk->swapState & eBusy),
"layer %p wasn't locked!", this);
android_atomic_and(~eBusy, &(lcblk->swapState));
}
mFlinger->scheduleBroadcast(client);
}
// ---------------------------------------------------------------------------
}; // namespace android