c7f3381c3b
We were not updating the h/w composer state when the buffer size changed. We also didn't update the h/w composer state when the transformation matrix changed (which is related to the above issue, since it would probably change when the buffer size changes). Also moved updating the crop to setGeometry(), since we decided that the "crop" change requires the GEOMETRY_CHANGED flag (ie: not need to do this every frame) Bug: 5238473 Change-Id: Ia7b47e145b48581b568d89d9aa2c14ff778be862
593 lines
20 KiB
C++
593 lines
20 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <cutils/compiler.h>
|
|
#include <cutils/native_handle.h>
|
|
#include <cutils/properties.h>
|
|
|
|
#include <utils/Errors.h>
|
|
#include <utils/Log.h>
|
|
#include <utils/StopWatch.h>
|
|
|
|
#include <ui/GraphicBuffer.h>
|
|
#include <ui/PixelFormat.h>
|
|
|
|
#include <surfaceflinger/Surface.h>
|
|
|
|
#include "clz.h"
|
|
#include "DisplayHardware/DisplayHardware.h"
|
|
#include "DisplayHardware/HWComposer.h"
|
|
#include "GLExtensions.h"
|
|
#include "Layer.h"
|
|
#include "SurfaceFlinger.h"
|
|
#include "SurfaceTextureLayer.h"
|
|
|
|
#define DEBUG_RESIZE 0
|
|
|
|
|
|
namespace android {
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
Layer::Layer(SurfaceFlinger* flinger,
|
|
DisplayID display, const sp<Client>& client)
|
|
: LayerBaseClient(flinger, display, client),
|
|
mTextureName(-1U),
|
|
mQueuedFrames(0),
|
|
mCurrentTransform(0),
|
|
mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
|
|
mCurrentOpacity(true),
|
|
mFormat(PIXEL_FORMAT_NONE),
|
|
mGLExtensions(GLExtensions::getInstance()),
|
|
mOpaqueLayer(true),
|
|
mNeedsDithering(false),
|
|
mSecure(false),
|
|
mProtectedByApp(false)
|
|
{
|
|
mCurrentCrop.makeInvalid();
|
|
glGenTextures(1, &mTextureName);
|
|
}
|
|
|
|
void Layer::onFirstRef()
|
|
{
|
|
LayerBaseClient::onFirstRef();
|
|
|
|
struct FrameQueuedListener : public SurfaceTexture::FrameAvailableListener {
|
|
FrameQueuedListener(Layer* layer) : mLayer(layer) { }
|
|
private:
|
|
wp<Layer> mLayer;
|
|
virtual void onFrameAvailable() {
|
|
sp<Layer> that(mLayer.promote());
|
|
if (that != 0) {
|
|
that->onFrameQueued();
|
|
}
|
|
}
|
|
};
|
|
mSurfaceTexture = new SurfaceTextureLayer(mTextureName, this);
|
|
mSurfaceTexture->setFrameAvailableListener(new FrameQueuedListener(this));
|
|
mSurfaceTexture->setSynchronousMode(true);
|
|
mSurfaceTexture->setBufferCountServer(2);
|
|
}
|
|
|
|
Layer::~Layer()
|
|
{
|
|
class MessageDestroyGLState : public MessageBase {
|
|
GLuint texture;
|
|
public:
|
|
MessageDestroyGLState(GLuint texture) : texture(texture) { }
|
|
virtual bool handler() {
|
|
glDeleteTextures(1, &texture);
|
|
return true;
|
|
}
|
|
};
|
|
mFlinger->postMessageAsync( new MessageDestroyGLState(mTextureName) );
|
|
}
|
|
|
|
void Layer::onFrameQueued() {
|
|
android_atomic_inc(&mQueuedFrames);
|
|
mFlinger->signalEvent();
|
|
}
|
|
|
|
// called with SurfaceFlinger::mStateLock as soon as the layer is entered
|
|
// in the purgatory list
|
|
void Layer::onRemoved()
|
|
{
|
|
mSurfaceTexture->abandon();
|
|
}
|
|
|
|
sp<ISurface> Layer::createSurface()
|
|
{
|
|
class BSurface : public BnSurface, public LayerCleaner {
|
|
wp<const Layer> mOwner;
|
|
virtual sp<ISurfaceTexture> getSurfaceTexture() const {
|
|
sp<ISurfaceTexture> res;
|
|
sp<const Layer> that( mOwner.promote() );
|
|
if (that != NULL) {
|
|
res = that->mSurfaceTexture;
|
|
}
|
|
return res;
|
|
}
|
|
public:
|
|
BSurface(const sp<SurfaceFlinger>& flinger,
|
|
const sp<Layer>& layer)
|
|
: LayerCleaner(flinger, layer), mOwner(layer) { }
|
|
};
|
|
sp<ISurface> sur(new BSurface(mFlinger, this));
|
|
return sur;
|
|
}
|
|
|
|
wp<IBinder> Layer::getSurfaceTextureBinder() const
|
|
{
|
|
return mSurfaceTexture->asBinder();
|
|
}
|
|
|
|
status_t Layer::setBuffers( uint32_t w, uint32_t h,
|
|
PixelFormat format, uint32_t flags)
|
|
{
|
|
// this surfaces pixel format
|
|
PixelFormatInfo info;
|
|
status_t err = getPixelFormatInfo(format, &info);
|
|
if (err) return err;
|
|
|
|
// the display's pixel format
|
|
const DisplayHardware& hw(graphicPlane(0).displayHardware());
|
|
uint32_t const maxSurfaceDims = min(
|
|
hw.getMaxTextureSize(), hw.getMaxViewportDims());
|
|
|
|
// never allow a surface larger than what our underlying GL implementation
|
|
// can handle.
|
|
if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
PixelFormatInfo displayInfo;
|
|
getPixelFormatInfo(hw.getFormat(), &displayInfo);
|
|
const uint32_t hwFlags = hw.getFlags();
|
|
|
|
mFormat = format;
|
|
|
|
mSecure = (flags & ISurfaceComposer::eSecure) ? true : false;
|
|
mProtectedByApp = (flags & ISurfaceComposer::eProtectedByApp) ? true : false;
|
|
mOpaqueLayer = (flags & ISurfaceComposer::eOpaque);
|
|
mCurrentOpacity = getOpacityForFormat(format);
|
|
|
|
mSurfaceTexture->setDefaultBufferSize(w, h);
|
|
mSurfaceTexture->setDefaultBufferFormat(format);
|
|
|
|
// we use the red index
|
|
int displayRedSize = displayInfo.getSize(PixelFormatInfo::INDEX_RED);
|
|
int layerRedsize = info.getSize(PixelFormatInfo::INDEX_RED);
|
|
mNeedsDithering = layerRedsize > displayRedSize;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void Layer::setGeometry(hwc_layer_t* hwcl)
|
|
{
|
|
LayerBaseClient::setGeometry(hwcl);
|
|
|
|
hwcl->flags &= ~HWC_SKIP_LAYER;
|
|
|
|
// we can't do alpha-fade with the hwc HAL
|
|
const State& s(drawingState());
|
|
if (s.alpha < 0xFF) {
|
|
hwcl->flags = HWC_SKIP_LAYER;
|
|
}
|
|
|
|
/*
|
|
* Transformations are applied in this order:
|
|
* 1) buffer orientation/flip/mirror
|
|
* 2) state transformation (window manager)
|
|
* 3) layer orientation (screen orientation)
|
|
* mTransform is already the composition of (2) and (3)
|
|
* (NOTE: the matrices are multiplied in reverse order)
|
|
*/
|
|
|
|
const Transform bufferOrientation(mCurrentTransform);
|
|
const Transform tr(mTransform * bufferOrientation);
|
|
|
|
// this gives us only the "orientation" component of the transform
|
|
const uint32_t finalTransform = tr.getOrientation();
|
|
|
|
// we can only handle simple transformation
|
|
if (finalTransform & Transform::ROT_INVALID) {
|
|
hwcl->flags = HWC_SKIP_LAYER;
|
|
} else {
|
|
hwcl->transform = finalTransform;
|
|
}
|
|
|
|
if (isCropped()) {
|
|
hwcl->sourceCrop.left = mCurrentCrop.left;
|
|
hwcl->sourceCrop.top = mCurrentCrop.top;
|
|
hwcl->sourceCrop.right = mCurrentCrop.right;
|
|
hwcl->sourceCrop.bottom = mCurrentCrop.bottom;
|
|
} else {
|
|
const sp<GraphicBuffer>& buffer(mActiveBuffer);
|
|
hwcl->sourceCrop.left = 0;
|
|
hwcl->sourceCrop.top = 0;
|
|
if (buffer != NULL) {
|
|
hwcl->sourceCrop.right = buffer->width;
|
|
hwcl->sourceCrop.bottom = buffer->height;
|
|
} else {
|
|
hwcl->sourceCrop.right = mTransformedBounds.width();
|
|
hwcl->sourceCrop.bottom = mTransformedBounds.height();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Layer::setPerFrameData(hwc_layer_t* hwcl) {
|
|
const sp<GraphicBuffer>& buffer(mActiveBuffer);
|
|
if (buffer == NULL) {
|
|
// this can happen if the client never drew into this layer yet,
|
|
// or if we ran out of memory. In that case, don't let
|
|
// HWC handle it.
|
|
hwcl->flags |= HWC_SKIP_LAYER;
|
|
hwcl->handle = NULL;
|
|
} else {
|
|
hwcl->handle = buffer->handle;
|
|
}
|
|
}
|
|
|
|
void Layer::onDraw(const Region& clip) const
|
|
{
|
|
if (CC_UNLIKELY(mActiveBuffer == 0)) {
|
|
// the texture has not been created yet, this Layer has
|
|
// in fact never been drawn into. This happens frequently with
|
|
// SurfaceView because the WindowManager can't know when the client
|
|
// has drawn the first time.
|
|
|
|
// If there is nothing under us, we paint the screen in black, otherwise
|
|
// we just skip this update.
|
|
|
|
// figure out if there is something below us
|
|
Region under;
|
|
const SurfaceFlinger::LayerVector& drawingLayers(
|
|
mFlinger->mDrawingState.layersSortedByZ);
|
|
const size_t count = drawingLayers.size();
|
|
for (size_t i=0 ; i<count ; ++i) {
|
|
const sp<LayerBase>& layer(drawingLayers[i]);
|
|
if (layer.get() == static_cast<LayerBase const*>(this))
|
|
break;
|
|
under.orSelf(layer->visibleRegionScreen);
|
|
}
|
|
// if not everything below us is covered, we plug the holes!
|
|
Region holes(clip.subtract(under));
|
|
if (!holes.isEmpty()) {
|
|
clearWithOpenGL(holes, 0, 0, 0, 1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
const GLenum target = GL_TEXTURE_EXTERNAL_OES;
|
|
glBindTexture(target, mTextureName);
|
|
if (getFiltering() || needsFiltering() || isFixedSize() || isCropped()) {
|
|
// TODO: we could be more subtle with isFixedSize()
|
|
glTexParameterx(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameterx(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
} else {
|
|
glTexParameterx(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameterx(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
}
|
|
glEnable(target);
|
|
glMatrixMode(GL_TEXTURE);
|
|
glLoadMatrixf(mTextureMatrix);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
drawWithOpenGL(clip);
|
|
|
|
glDisable(target);
|
|
}
|
|
|
|
// As documented in libhardware header, formats in the range
|
|
// 0x100 - 0x1FF are specific to the HAL implementation, and
|
|
// are known to have no alpha channel
|
|
// TODO: move definition for device-specific range into
|
|
// hardware.h, instead of using hard-coded values here.
|
|
#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF)
|
|
|
|
bool Layer::getOpacityForFormat(uint32_t format)
|
|
{
|
|
if (HARDWARE_IS_DEVICE_FORMAT(format)) {
|
|
return true;
|
|
}
|
|
PixelFormatInfo info;
|
|
status_t err = getPixelFormatInfo(PixelFormat(format), &info);
|
|
// in case of error (unknown format), we assume no blending
|
|
return (err || info.h_alpha <= info.l_alpha);
|
|
}
|
|
|
|
|
|
bool Layer::isOpaque() const
|
|
{
|
|
// if we don't have a buffer yet, we're translucent regardless of the
|
|
// layer's opaque flag.
|
|
if (mActiveBuffer == 0) {
|
|
return false;
|
|
}
|
|
|
|
// if the layer has the opaque flag, then we're always opaque,
|
|
// otherwise we use the current buffer's format.
|
|
return mOpaqueLayer || mCurrentOpacity;
|
|
}
|
|
|
|
bool Layer::isProtected() const
|
|
{
|
|
const sp<GraphicBuffer>& activeBuffer(mActiveBuffer);
|
|
return (activeBuffer != 0) &&
|
|
(activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED);
|
|
}
|
|
|
|
uint32_t Layer::doTransaction(uint32_t flags)
|
|
{
|
|
const Layer::State& front(drawingState());
|
|
const Layer::State& temp(currentState());
|
|
|
|
const bool sizeChanged = (front.requested_w != temp.requested_w) ||
|
|
(front.requested_h != temp.requested_h);
|
|
|
|
if (sizeChanged) {
|
|
// the size changed, we need to ask our client to request a new buffer
|
|
LOGD_IF(DEBUG_RESIZE,
|
|
"doTransaction: "
|
|
"resize (layer=%p), requested (%dx%d), drawing (%d,%d), "
|
|
"scalingMode=%d",
|
|
this,
|
|
int(temp.requested_w), int(temp.requested_h),
|
|
int(front.requested_w), int(front.requested_h),
|
|
mCurrentScalingMode);
|
|
|
|
if (!isFixedSize()) {
|
|
// 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();
|
|
}
|
|
}
|
|
|
|
// this will make sure LayerBase::doTransaction doesn't update
|
|
// the drawing state's size
|
|
Layer::State& editDraw(mDrawingState);
|
|
editDraw.requested_w = temp.requested_w;
|
|
editDraw.requested_h = temp.requested_h;
|
|
|
|
// record the new size, form this point on, when the client request
|
|
// a buffer, it'll get the new size.
|
|
mSurfaceTexture->setDefaultBufferSize(temp.requested_w, temp.requested_h);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
bool Layer::isFixedSize() const {
|
|
return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
|
|
}
|
|
|
|
bool Layer::isCropped() const {
|
|
return !mCurrentCrop.isEmpty();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// pageflip handling...
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void Layer::lockPageFlip(bool& recomputeVisibleRegions)
|
|
{
|
|
if (mQueuedFrames > 0) {
|
|
const bool oldOpacity = isOpaque();
|
|
|
|
// signal another event if we have more frames pending
|
|
if (android_atomic_dec(&mQueuedFrames) > 1) {
|
|
mFlinger->signalEvent();
|
|
}
|
|
|
|
if (mSurfaceTexture->updateTexImage() < NO_ERROR) {
|
|
// something happened!
|
|
recomputeVisibleRegions = true;
|
|
return;
|
|
}
|
|
|
|
sp<GraphicBuffer> newFrontBuffer(mSurfaceTexture->getCurrentBuffer());
|
|
|
|
const Rect crop(mSurfaceTexture->getCurrentCrop());
|
|
const uint32_t transform(mSurfaceTexture->getCurrentTransform());
|
|
const uint32_t scalingMode(mSurfaceTexture->getCurrentScalingMode());
|
|
if ((crop != mCurrentCrop) ||
|
|
(transform != mCurrentTransform) ||
|
|
(scalingMode != mCurrentScalingMode))
|
|
{
|
|
mCurrentCrop = crop;
|
|
mCurrentTransform = transform;
|
|
mCurrentScalingMode = scalingMode;
|
|
mFlinger->invalidateHwcGeometry();
|
|
}
|
|
|
|
GLfloat textureMatrix[16];
|
|
mSurfaceTexture->getTransformMatrix(textureMatrix);
|
|
if (memcmp(textureMatrix, mTextureMatrix, sizeof(textureMatrix))) {
|
|
memcpy(mTextureMatrix, textureMatrix, sizeof(textureMatrix));
|
|
mFlinger->invalidateHwcGeometry();
|
|
}
|
|
|
|
uint32_t bufWidth = newFrontBuffer->getWidth();
|
|
uint32_t bufHeight = newFrontBuffer->getHeight();
|
|
if (mActiveBuffer != NULL) {
|
|
if (bufWidth != uint32_t(mActiveBuffer->width) ||
|
|
bufHeight != uint32_t(mActiveBuffer->height)) {
|
|
mFlinger->invalidateHwcGeometry();
|
|
}
|
|
}
|
|
|
|
mCurrentOpacity = getOpacityForFormat(newFrontBuffer->format);
|
|
if (oldOpacity != isOpaque()) {
|
|
recomputeVisibleRegions = true;
|
|
}
|
|
|
|
glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
// update the layer size and release freeze-lock
|
|
const Layer::State& front(drawingState());
|
|
|
|
// FIXME: mPostedDirtyRegion = dirty & bounds
|
|
mPostedDirtyRegion.set(front.w, front.h);
|
|
|
|
// update active buffer
|
|
mActiveBuffer = newFrontBuffer;
|
|
|
|
if ((front.w != front.requested_w) ||
|
|
(front.h != front.requested_h))
|
|
{
|
|
// check that we received a buffer of the right size
|
|
// (Take the buffer's orientation into account)
|
|
if (mCurrentTransform & Transform::ROT_90) {
|
|
swap(bufWidth, bufHeight);
|
|
}
|
|
|
|
if (isFixedSize() ||
|
|
(bufWidth == front.requested_w &&
|
|
bufHeight == front.requested_h))
|
|
{
|
|
// Here we pretend the transaction happened by updating the
|
|
// current and drawing states. Drawing state is only accessed
|
|
// in this thread, no need to have it locked
|
|
Layer::State& editDraw(mDrawingState);
|
|
editDraw.w = editDraw.requested_w;
|
|
editDraw.h = editDraw.requested_h;
|
|
|
|
// We also need to update the current state so that we don't
|
|
// end-up doing too much work during the next transaction.
|
|
// NOTE: We actually don't need hold the transaction lock here
|
|
// because State::w and State::h are only accessed from
|
|
// this thread
|
|
Layer::State& editTemp(currentState());
|
|
editTemp.w = editDraw.w;
|
|
editTemp.h = editDraw.h;
|
|
|
|
// recompute visible region
|
|
recomputeVisibleRegions = true;
|
|
|
|
// we now have the correct size, unfreeze the screen
|
|
mFreezeLock.clear();
|
|
}
|
|
|
|
LOGD_IF(DEBUG_RESIZE,
|
|
"lockPageFlip : "
|
|
" (layer=%p), buffer (%ux%u, tr=%02x), "
|
|
"requested (%dx%d)",
|
|
this,
|
|
bufWidth, bufHeight, mCurrentTransform,
|
|
front.requested_w, front.requested_h);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
if (visibleRegionScreen.isEmpty()) {
|
|
// an invisible layer should not hold a freeze-lock
|
|
// (because it may never be updated and therefore never release it)
|
|
mFreezeLock.clear();
|
|
}
|
|
}
|
|
|
|
void Layer::dump(String8& result, char* buffer, size_t SIZE) const
|
|
{
|
|
LayerBaseClient::dump(result, buffer, SIZE);
|
|
|
|
sp<const GraphicBuffer> buf0(mActiveBuffer);
|
|
uint32_t w0=0, h0=0, s0=0, f0=0;
|
|
if (buf0 != 0) {
|
|
w0 = buf0->getWidth();
|
|
h0 = buf0->getHeight();
|
|
s0 = buf0->getStride();
|
|
f0 = buf0->format;
|
|
}
|
|
snprintf(buffer, SIZE,
|
|
" "
|
|
"format=%2d, activeBuffer=[%4ux%4u:%4u,%3X],"
|
|
" freezeLock=%p, transform-hint=0x%02x, queued-frames=%d\n",
|
|
mFormat, w0, h0, s0,f0,
|
|
getFreezeLock().get(), getTransformHint(), mQueuedFrames);
|
|
|
|
result.append(buffer);
|
|
|
|
if (mSurfaceTexture != 0) {
|
|
mSurfaceTexture->dump(result, " ", buffer, SIZE);
|
|
}
|
|
}
|
|
|
|
uint32_t Layer::getEffectiveUsage(uint32_t usage) const
|
|
{
|
|
// TODO: should we do something special if mSecure is set?
|
|
if (mProtectedByApp) {
|
|
// need a hardware-protected path to external video sink
|
|
usage |= GraphicBuffer::USAGE_PROTECTED;
|
|
}
|
|
usage |= GraphicBuffer::USAGE_HW_COMPOSER;
|
|
return usage;
|
|
}
|
|
|
|
uint32_t Layer::getTransformHint() const {
|
|
uint32_t orientation = 0;
|
|
if (!mFlinger->mDebugDisableTransformHint) {
|
|
orientation = getOrientation();
|
|
if (orientation & Transform::ROT_INVALID) {
|
|
orientation = 0;
|
|
}
|
|
}
|
|
return orientation;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
}; // namespace android
|