1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/*
* 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/Timers.h>
#include <hardware/hwcomposer_defs.h>
#include "Transform.h"
struct ANativeWindow;
namespace android {
class DisplayInfo;
class FramebufferSurface;
class LayerBase;
class SurfaceFlinger;
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,
NUM_DISPLAY_TYPES = HWC_NUM_DISPLAY_TYPES,
DISPLAY_VIRTUAL = HWC_NUM_DISPLAY_TYPES
};
enum {
PARTIAL_UPDATES = 0x00020000, // video driver feature
SWAP_RECTANGLE = 0x00080000,
};
DisplayDevice(
const sp<SurfaceFlinger>& flinger,
DisplayType type, const wp<IBinder>& displayToken,
const sp<ANativeWindow>& nativeWindow,
const sp<FramebufferSurface>& framebufferSurface,
EGLConfig config);
~DisplayDevice();
// whether this is a valid object. An invalid DisplayDevice is returned
// when an non existing id is requested
bool isValid() const;
// 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<LayerBase> >& layers);
const Vector< sp<LayerBase> >& getVisibleLayersSortedByZ() const;
bool getSecureLayerVisible() const;
Region getDirtyRegion(bool repaintEverything) const;
status_t setOrientation(int orientation);
void setLayerStack(uint32_t stack);
int getOrientation() const { return mOrientation; }
const Transform& getTransform() const { return mGlobalTransform; }
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; }
status_t compositionComplete() const;
Rect getBounds() const {
return Rect(mDisplayWidth, mDisplayHeight);
}
inline Rect bounds() const { return getBounds(); }
static void makeCurrent(const sp<const DisplayDevice>& hw, EGLContext ctx);
/* ------------------------------------------------------------------------
* blank / unplank management
*/
void releaseScreen() const;
void acquireScreen() const;
bool isScreenAcquired() const;
bool canDraw() const;
/* ------------------------------------------------------------------------
* Debugging
*/
uint32_t getPageFlipCount() const;
void dump(String8& res) const;
private:
void init(EGLConfig config);
/*
* Constants, set during initialization
*/
sp<SurfaceFlinger> mFlinger;
DisplayType mType;
int32_t mHwcDisplayId;
wp<IBinder> mDisplayToken;
// ANativeWindow this display is rendering into
sp<ANativeWindow> mNativeWindow;
// set if mNativeWindow is a FramebufferSurface
sp<FramebufferSurface> mFramebufferSurface;
EGLDisplay mDisplay;
EGLSurface mSurface;
EGLContext mContext;
int mDisplayWidth;
int mDisplayHeight;
PixelFormat mFormat;
uint32_t mFlags;
mutable uint32_t mPageFlipCount;
/*
* Can only accessed from the main thread, these members
* don't need synchronization.
*/
// list of visible layers on that display
Vector< sp<LayerBase> > 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);
Transform mGlobalTransform;
int mOrientation;
uint32_t mLayerStack;
};
}; // namespace android
#endif // ANDROID_DISPLAY_DEVICE_H
|
