replicant-frameworks_native/services/surfaceflinger/DisplayDevice.h

225 lines
6.9 KiB
C
Raw Normal View History

/*
* 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.
*/
#ifndef ANDROID_DISPLAY_DEVICE_H
#define ANDROID_DISPLAY_DEVICE_H
#include <stdlib.h>
#include <ui/PixelFormat.h>
#include <ui/Region.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <utils/Mutex.h>
#include <utils/String8.h>
#include <utils/Timers.h>
#include <hardware/hwcomposer_defs.h>
#include "Transform.h"
struct ANativeWindow;
namespace android {
class DisplayInfo;
class DisplaySurface;
class IGraphicBufferProducer;
class Layer;
class SurfaceFlinger;
class HWComposer;
class DisplayDevice : public LightRefBase<DisplayDevice>
{
public:
// region in layer-stack space
mutable Region dirtyRegion;
// region in screen space
mutable Region swapRegion;
// region in screen space
Region undefinedRegion;
enum DisplayType {
DISPLAY_ID_INVALID = -1,
DISPLAY_PRIMARY = HWC_DISPLAY_PRIMARY,
DISPLAY_EXTERNAL = HWC_DISPLAY_EXTERNAL,
DISPLAY_VIRTUAL = HWC_DISPLAY_VIRTUAL,
NUM_BUILTIN_DISPLAY_TYPES = HWC_NUM_PHYSICAL_DISPLAY_TYPES,
};
enum {
PARTIAL_UPDATES = 0x00020000, // video driver feature
SWAP_RECTANGLE = 0x00080000,
};
enum {
NO_LAYER_STACK = 0xFFFFFFFF,
};
DisplayDevice(
const sp<SurfaceFlinger>& flinger,
DisplayType type,
int32_t hwcId, // negative for non-HWC-composited displays
int format,
bool isSecure,
const wp<IBinder>& displayToken,
const sp<DisplaySurface>& displaySurface,
const sp<IGraphicBufferProducer>& producer,
EGLConfig config);
~DisplayDevice();
// whether this is a valid object. An invalid DisplayDevice is returned
// when an non existing id is requested
bool isValid() const;
// isSecure indicates whether this display can be trusted to display
// secure surfaces.
bool isSecure() const { return mIsSecure; }
// Flip the front and back buffers if the back buffer is "dirty". Might
// be instantaneous, might involve copying the frame buffer around.
void flip(const Region& dirty) const;
int getWidth() const;
int getHeight() const;
PixelFormat getFormat() const;
uint32_t getFlags() const;
EGLSurface getEGLSurface() const;
void setVisibleLayersSortedByZ(const Vector< sp<Layer> >& layers);
const Vector< sp<Layer> >& getVisibleLayersSortedByZ() const;
bool getSecureLayerVisible() const;
Region getDirtyRegion(bool repaintEverything) const;
void setLayerStack(uint32_t stack);
void setProjection(int orientation, const Rect& viewport, const Rect& frame);
int getOrientation() const { return mOrientation; }
uint32_t getOrientationTransform() const;
const Transform& getTransform() const { return mGlobalTransform; }
const Rect getViewport() const { return mViewport; }
const Rect getFrame() const { return mFrame; }
const Rect& getScissor() const { return mScissor; }
bool needsFiltering() const { return mNeedsFiltering; }
uint32_t getLayerStack() const { return mLayerStack; }
int32_t getDisplayType() const { return mType; }
int32_t getHwcDisplayId() const { return mHwcDisplayId; }
const wp<IBinder>& getDisplayToken() const { return mDisplayToken; }
// We pass in mustRecompose so we can keep VirtualDisplaySurface's state
// machine happy without actually queueing a buffer if nothing has changed
status_t beginFrame(bool mustRecompose) const;
status_t prepareFrame(const HWComposer& hwc) const;
void swapBuffers(HWComposer& hwc) const;
status_t compositionComplete() const;
// called after h/w composer has completed its set() call
void onSwapBuffersCompleted(HWComposer& hwc) const;
Rect getBounds() const {
return Rect(mDisplayWidth, mDisplayHeight);
}
inline Rect bounds() const { return getBounds(); }
void setDisplayName(const String8& displayName);
const String8& getDisplayName() const { return mDisplayName; }
EGLBoolean makeCurrent(EGLDisplay dpy, EGLContext ctx) const;
void setViewportAndProjection() const;
/* ------------------------------------------------------------------------
* blank / unblank management
*/
void releaseScreen() const;
void acquireScreen() const;
bool isScreenAcquired() const;
bool canDraw() const;
// release HWC resources (if any) for removable displays
void disconnect(HWComposer& hwc);
/* ------------------------------------------------------------------------
* Debugging
*/
uint32_t getPageFlipCount() const;
void dump(String8& result) const;
private:
/*
* Constants, set during initialization
*/
sp<SurfaceFlinger> mFlinger;
DisplayType mType;
int32_t mHwcDisplayId;
wp<IBinder> mDisplayToken;
// ANativeWindow this display is rendering into
sp<ANativeWindow> mNativeWindow;
sp<DisplaySurface> mDisplaySurface;
EGLDisplay mDisplay;
EGLSurface mSurface;
int mDisplayWidth;
int mDisplayHeight;
PixelFormat mFormat;
uint32_t mFlags;
mutable uint32_t mPageFlipCount;
String8 mDisplayName;
bool mIsSecure;
/*
* Can only accessed from the main thread, these members
* don't need synchronization.
*/
// list of visible layers on that display
Vector< sp<Layer> > mVisibleLayersSortedByZ;
// Whether we have a visible secure layer on this display
bool mSecureLayerVisible;
// Whether the screen is blanked;
mutable int mScreenAcquired;
/*
* Transaction state
*/
static status_t orientationToTransfrom(int orientation,
int w, int h, Transform* tr);
uint32_t mLayerStack;
int mOrientation;
// user-provided visible area of the layer stack
Rect mViewport;
// user-provided rectangle where mViewport gets mapped to
Rect mFrame;
// pre-computed scissor to apply to the display
Rect mScissor;
Transform mGlobalTransform;
bool mNeedsFiltering;
};
}; // namespace android
#endif // ANDROID_DISPLAY_DEVICE_H