457 lines
14 KiB
C++
457 lines
14 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 <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#include <cutils/properties.h>
|
|
|
|
#include <utils/RefBase.h>
|
|
#include <utils/Log.h>
|
|
|
|
#include <ui/DisplayInfo.h>
|
|
#include <ui/PixelFormat.h>
|
|
|
|
#include <gui/Surface.h>
|
|
|
|
#include <hardware/gralloc.h>
|
|
|
|
#include "DisplayHardware/DisplaySurface.h"
|
|
#include "DisplayHardware/HWComposer.h"
|
|
#include "RenderEngine/RenderEngine.h"
|
|
|
|
#include "clz.h"
|
|
#include "DisplayDevice.h"
|
|
#include "SurfaceFlinger.h"
|
|
#include "Layer.h"
|
|
|
|
// ----------------------------------------------------------------------------
|
|
using namespace android;
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Initialize the display to the specified values.
|
|
*
|
|
*/
|
|
|
|
DisplayDevice::DisplayDevice(
|
|
const sp<SurfaceFlinger>& flinger,
|
|
DisplayType type,
|
|
int32_t hwcId,
|
|
bool isSecure,
|
|
const wp<IBinder>& displayToken,
|
|
const sp<DisplaySurface>& displaySurface,
|
|
const sp<IGraphicBufferProducer>& producer,
|
|
EGLConfig config)
|
|
: mFlinger(flinger),
|
|
mType(type), mHwcDisplayId(hwcId),
|
|
mDisplayToken(displayToken),
|
|
mDisplaySurface(displaySurface),
|
|
mDisplay(EGL_NO_DISPLAY),
|
|
mSurface(EGL_NO_SURFACE),
|
|
mDisplayWidth(), mDisplayHeight(), mFormat(),
|
|
mFlags(),
|
|
mPageFlipCount(),
|
|
mIsSecure(isSecure),
|
|
mSecureLayerVisible(false),
|
|
mScreenAcquired(false),
|
|
mLayerStack(NO_LAYER_STACK),
|
|
mOrientation()
|
|
{
|
|
mNativeWindow = new Surface(producer);
|
|
ANativeWindow* const window = mNativeWindow.get();
|
|
|
|
int format;
|
|
window->query(window, NATIVE_WINDOW_FORMAT, &format);
|
|
|
|
// Make sure that composition can never be stalled by a virtual display
|
|
// consumer that isn't processing buffers fast enough. We have to do this
|
|
// in two places:
|
|
// * Here, in case the display is composed entirely by HWC.
|
|
// * In makeCurrent(), using eglSwapInterval. Some EGL drivers set the
|
|
// window's swap interval in eglMakeCurrent, so they'll override the
|
|
// interval we set here.
|
|
if (mType >= DisplayDevice::DISPLAY_VIRTUAL)
|
|
window->setSwapInterval(window, 0);
|
|
|
|
/*
|
|
* Create our display's surface
|
|
*/
|
|
|
|
EGLSurface surface;
|
|
EGLint w, h;
|
|
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
surface = eglCreateWindowSurface(display, config, window, NULL);
|
|
eglQuerySurface(display, surface, EGL_WIDTH, &mDisplayWidth);
|
|
eglQuerySurface(display, surface, EGL_HEIGHT, &mDisplayHeight);
|
|
|
|
mDisplay = display;
|
|
mSurface = surface;
|
|
mFormat = format;
|
|
mPageFlipCount = 0;
|
|
mViewport.makeInvalid();
|
|
mFrame.makeInvalid();
|
|
|
|
// virtual displays are always considered enabled
|
|
mScreenAcquired = (mType >= DisplayDevice::DISPLAY_VIRTUAL);
|
|
|
|
// Name the display. The name will be replaced shortly if the display
|
|
// was created with createDisplay().
|
|
switch (mType) {
|
|
case DISPLAY_PRIMARY:
|
|
mDisplayName = "Built-in Screen";
|
|
break;
|
|
case DISPLAY_EXTERNAL:
|
|
mDisplayName = "HDMI Screen";
|
|
break;
|
|
default:
|
|
mDisplayName = "Virtual Screen"; // e.g. Overlay #n
|
|
break;
|
|
}
|
|
|
|
// initialize the display orientation transform.
|
|
setProjection(DisplayState::eOrientationDefault, mViewport, mFrame);
|
|
}
|
|
|
|
DisplayDevice::~DisplayDevice() {
|
|
if (mSurface != EGL_NO_SURFACE) {
|
|
eglDestroySurface(mDisplay, mSurface);
|
|
mSurface = EGL_NO_SURFACE;
|
|
}
|
|
}
|
|
|
|
void DisplayDevice::disconnect(HWComposer& hwc) {
|
|
if (mHwcDisplayId >= 0) {
|
|
hwc.disconnectDisplay(mHwcDisplayId);
|
|
if (mHwcDisplayId >= DISPLAY_VIRTUAL)
|
|
hwc.freeDisplayId(mHwcDisplayId);
|
|
mHwcDisplayId = -1;
|
|
}
|
|
}
|
|
|
|
bool DisplayDevice::isValid() const {
|
|
return mFlinger != NULL;
|
|
}
|
|
|
|
int DisplayDevice::getWidth() const {
|
|
return mDisplayWidth;
|
|
}
|
|
|
|
int DisplayDevice::getHeight() const {
|
|
return mDisplayHeight;
|
|
}
|
|
|
|
PixelFormat DisplayDevice::getFormat() const {
|
|
return mFormat;
|
|
}
|
|
|
|
EGLSurface DisplayDevice::getEGLSurface() const {
|
|
return mSurface;
|
|
}
|
|
|
|
void DisplayDevice::setDisplayName(const String8& displayName) {
|
|
if (!displayName.isEmpty()) {
|
|
// never override the name with an empty name
|
|
mDisplayName = displayName;
|
|
}
|
|
}
|
|
|
|
uint32_t DisplayDevice::getPageFlipCount() const {
|
|
return mPageFlipCount;
|
|
}
|
|
|
|
status_t DisplayDevice::compositionComplete() const {
|
|
return mDisplaySurface->compositionComplete();
|
|
}
|
|
|
|
void DisplayDevice::flip(const Region& dirty) const
|
|
{
|
|
mFlinger->getRenderEngine().checkErrors();
|
|
|
|
EGLDisplay dpy = mDisplay;
|
|
EGLSurface surface = mSurface;
|
|
|
|
#ifdef EGL_ANDROID_swap_rectangle
|
|
if (mFlags & SWAP_RECTANGLE) {
|
|
const Region newDirty(dirty.intersect(bounds()));
|
|
const Rect b(newDirty.getBounds());
|
|
eglSetSwapRectangleANDROID(dpy, surface,
|
|
b.left, b.top, b.width(), b.height());
|
|
}
|
|
#endif
|
|
|
|
mPageFlipCount++;
|
|
}
|
|
|
|
status_t DisplayDevice::prepareFrame(const HWComposer& hwc) const {
|
|
DisplaySurface::CompositionType compositionType;
|
|
bool haveGles = hwc.hasGlesComposition(mHwcDisplayId);
|
|
bool haveHwc = hwc.hasHwcComposition(mHwcDisplayId);
|
|
if (haveGles && haveHwc) {
|
|
compositionType = DisplaySurface::COMPOSITION_MIXED;
|
|
} else if (haveGles) {
|
|
compositionType = DisplaySurface::COMPOSITION_GLES;
|
|
} else if (haveHwc) {
|
|
compositionType = DisplaySurface::COMPOSITION_HWC;
|
|
} else {
|
|
// Nothing to do -- when turning the screen off we get a frame like
|
|
// this. Call it a HWC frame since we won't be doing any GLES work but
|
|
// will do a prepare/set cycle.
|
|
compositionType = DisplaySurface::COMPOSITION_HWC;
|
|
}
|
|
return mDisplaySurface->prepareFrame(compositionType);
|
|
}
|
|
|
|
void DisplayDevice::swapBuffers(HWComposer& hwc) const {
|
|
// We need to call eglSwapBuffers() unless:
|
|
// (a) there was no GLES composition this frame, or
|
|
// (b) we're using a legacy HWC with no framebuffer target support (in
|
|
// which case HWComposer::commit() handles things).
|
|
if (hwc.initCheck() != NO_ERROR ||
|
|
(hwc.hasGlesComposition(mHwcDisplayId) &&
|
|
hwc.supportsFramebufferTarget())) {
|
|
EGLBoolean success = eglSwapBuffers(mDisplay, mSurface);
|
|
if (!success) {
|
|
EGLint error = eglGetError();
|
|
if (error == EGL_CONTEXT_LOST ||
|
|
mType == DisplayDevice::DISPLAY_PRIMARY) {
|
|
LOG_ALWAYS_FATAL("eglSwapBuffers(%p, %p) failed with 0x%08x",
|
|
mDisplay, mSurface, error);
|
|
} else {
|
|
ALOGE("eglSwapBuffers(%p, %p) failed with 0x%08x",
|
|
mDisplay, mSurface, error);
|
|
}
|
|
}
|
|
}
|
|
|
|
status_t result = mDisplaySurface->advanceFrame();
|
|
if (result != NO_ERROR) {
|
|
ALOGE("[%s] failed pushing new frame to HWC: %d",
|
|
mDisplayName.string(), result);
|
|
}
|
|
}
|
|
|
|
void DisplayDevice::onSwapBuffersCompleted(HWComposer& hwc) const {
|
|
if (hwc.initCheck() == NO_ERROR) {
|
|
mDisplaySurface->onFrameCommitted();
|
|
}
|
|
}
|
|
|
|
uint32_t DisplayDevice::getFlags() const
|
|
{
|
|
return mFlags;
|
|
}
|
|
|
|
EGLBoolean DisplayDevice::makeCurrent(EGLDisplay dpy, EGLContext ctx) const {
|
|
EGLBoolean result = EGL_TRUE;
|
|
EGLSurface sur = eglGetCurrentSurface(EGL_DRAW);
|
|
if (sur != mSurface) {
|
|
result = eglMakeCurrent(dpy, mSurface, mSurface, ctx);
|
|
if (result == EGL_TRUE) {
|
|
if (mType >= DisplayDevice::DISPLAY_VIRTUAL)
|
|
eglSwapInterval(dpy, 0);
|
|
setViewportAndProjection();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void DisplayDevice::setViewportAndProjection() const {
|
|
size_t w = mDisplayWidth;
|
|
size_t h = mDisplayHeight;
|
|
mFlinger->getRenderEngine().setViewportAndProjection(w, h, w, h, false);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DisplayDevice::setVisibleLayersSortedByZ(const Vector< sp<Layer> >& layers) {
|
|
mVisibleLayersSortedByZ = layers;
|
|
mSecureLayerVisible = false;
|
|
size_t count = layers.size();
|
|
for (size_t i=0 ; i<count ; i++) {
|
|
const sp<Layer>& layer(layers[i]);
|
|
if (layer->isSecure()) {
|
|
mSecureLayerVisible = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
const Vector< sp<Layer> >& DisplayDevice::getVisibleLayersSortedByZ() const {
|
|
return mVisibleLayersSortedByZ;
|
|
}
|
|
|
|
bool DisplayDevice::getSecureLayerVisible() const {
|
|
return mSecureLayerVisible;
|
|
}
|
|
|
|
Region DisplayDevice::getDirtyRegion(bool repaintEverything) const {
|
|
Region dirty;
|
|
if (repaintEverything) {
|
|
dirty.set(getBounds());
|
|
} else {
|
|
const Transform& planeTransform(mGlobalTransform);
|
|
dirty = planeTransform.transform(this->dirtyRegion);
|
|
dirty.andSelf(getBounds());
|
|
}
|
|
return dirty;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool DisplayDevice::canDraw() const {
|
|
return mScreenAcquired;
|
|
}
|
|
|
|
void DisplayDevice::releaseScreen() const {
|
|
mScreenAcquired = false;
|
|
}
|
|
|
|
void DisplayDevice::acquireScreen() const {
|
|
mScreenAcquired = true;
|
|
}
|
|
|
|
bool DisplayDevice::isScreenAcquired() const {
|
|
return mScreenAcquired;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DisplayDevice::setLayerStack(uint32_t stack) {
|
|
mLayerStack = stack;
|
|
dirtyRegion.set(bounds());
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
status_t DisplayDevice::orientationToTransfrom(
|
|
int orientation, int w, int h, Transform* tr)
|
|
{
|
|
uint32_t flags = 0;
|
|
switch (orientation) {
|
|
case DisplayState::eOrientationDefault:
|
|
flags = Transform::ROT_0;
|
|
break;
|
|
case DisplayState::eOrientation90:
|
|
flags = Transform::ROT_90;
|
|
break;
|
|
case DisplayState::eOrientation180:
|
|
flags = Transform::ROT_180;
|
|
break;
|
|
case DisplayState::eOrientation270:
|
|
flags = Transform::ROT_270;
|
|
break;
|
|
default:
|
|
return BAD_VALUE;
|
|
}
|
|
tr->set(flags, w, h);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void DisplayDevice::setProjection(int orientation,
|
|
const Rect& newViewport, const Rect& newFrame) {
|
|
Rect viewport(newViewport);
|
|
Rect frame(newFrame);
|
|
|
|
const int w = mDisplayWidth;
|
|
const int h = mDisplayHeight;
|
|
|
|
Transform R;
|
|
DisplayDevice::orientationToTransfrom(orientation, w, h, &R);
|
|
|
|
if (!frame.isValid()) {
|
|
// the destination frame can be invalid if it has never been set,
|
|
// in that case we assume the whole display frame.
|
|
frame = Rect(w, h);
|
|
}
|
|
|
|
if (viewport.isEmpty()) {
|
|
// viewport can be invalid if it has never been set, in that case
|
|
// we assume the whole display size.
|
|
// it's also invalid to have an empty viewport, so we handle that
|
|
// case in the same way.
|
|
viewport = Rect(w, h);
|
|
if (R.getOrientation() & Transform::ROT_90) {
|
|
// viewport is always specified in the logical orientation
|
|
// of the display (ie: post-rotation).
|
|
swap(viewport.right, viewport.bottom);
|
|
}
|
|
}
|
|
|
|
dirtyRegion.set(getBounds());
|
|
|
|
Transform TL, TP, S;
|
|
float src_width = viewport.width();
|
|
float src_height = viewport.height();
|
|
float dst_width = frame.width();
|
|
float dst_height = frame.height();
|
|
if (src_width != dst_width || src_height != dst_height) {
|
|
float sx = dst_width / src_width;
|
|
float sy = dst_height / src_height;
|
|
S.set(sx, 0, 0, sy);
|
|
}
|
|
|
|
float src_x = viewport.left;
|
|
float src_y = viewport.top;
|
|
float dst_x = frame.left;
|
|
float dst_y = frame.top;
|
|
TL.set(-src_x, -src_y);
|
|
TP.set(dst_x, dst_y);
|
|
|
|
// The viewport and frame are both in the logical orientation.
|
|
// Apply the logical translation, scale to physical size, apply the
|
|
// physical translation and finally rotate to the physical orientation.
|
|
mGlobalTransform = R * TP * S * TL;
|
|
|
|
const uint8_t type = mGlobalTransform.getType();
|
|
mNeedsFiltering = (!mGlobalTransform.preserveRects() ||
|
|
(type >= Transform::SCALE));
|
|
|
|
mScissor = mGlobalTransform.transform(viewport);
|
|
if (mScissor.isEmpty()) {
|
|
mScissor = getBounds();
|
|
}
|
|
|
|
mOrientation = orientation;
|
|
mViewport = viewport;
|
|
mFrame = frame;
|
|
}
|
|
|
|
void DisplayDevice::dump(String8& result) const {
|
|
const Transform& tr(mGlobalTransform);
|
|
result.appendFormat(
|
|
"+ DisplayDevice: %s\n"
|
|
" type=%x, hwcId=%d, layerStack=%u, (%4dx%4d), ANativeWindow=%p, orient=%2d (type=%08x), "
|
|
"flips=%u, isSecure=%d, secureVis=%d, acquired=%d, numLayers=%u\n"
|
|
" v:[%d,%d,%d,%d], f:[%d,%d,%d,%d], s:[%d,%d,%d,%d],"
|
|
"transform:[[%0.3f,%0.3f,%0.3f][%0.3f,%0.3f,%0.3f][%0.3f,%0.3f,%0.3f]]\n",
|
|
mDisplayName.string(), mType, mHwcDisplayId,
|
|
mLayerStack, mDisplayWidth, mDisplayHeight, mNativeWindow.get(),
|
|
mOrientation, tr.getType(), getPageFlipCount(),
|
|
mIsSecure, mSecureLayerVisible, mScreenAcquired, mVisibleLayersSortedByZ.size(),
|
|
mViewport.left, mViewport.top, mViewport.right, mViewport.bottom,
|
|
mFrame.left, mFrame.top, mFrame.right, mFrame.bottom,
|
|
mScissor.left, mScissor.top, mScissor.right, mScissor.bottom,
|
|
tr[0][0], tr[1][0], tr[2][0],
|
|
tr[0][1], tr[1][1], tr[2][1],
|
|
tr[0][2], tr[1][2], tr[2][2]);
|
|
|
|
String8 surfaceDump;
|
|
mDisplaySurface->dump(surfaceDump);
|
|
result.append(surfaceDump);
|
|
}
|