HWComposer.h revision 921e6ac4b7610a178285898d191eb0e3afe906c0
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ANDROID_SF_HWCOMPOSER_H 18#define ANDROID_SF_HWCOMPOSER_H 19 20#include <stdint.h> 21#include <sys/types.h> 22 23#include <EGL/egl.h> 24 25#include <hardware/hwcomposer_defs.h> 26 27#include <utils/Condition.h> 28#include <utils/Mutex.h> 29#include <utils/StrongPointer.h> 30#include <utils/Thread.h> 31#include <utils/Timers.h> 32#include <utils/Vector.h> 33 34extern "C" int clock_nanosleep(clockid_t clock_id, int flags, 35 const struct timespec *request, 36 struct timespec *remain); 37 38struct hwc_composer_device_1; 39struct hwc_layer_list_1; 40struct hwc_procs; 41 42namespace android { 43// --------------------------------------------------------------------------- 44 45class GraphicBuffer; 46class LayerBase; 47class String8; 48class SurfaceFlinger; 49 50class HWComposer 51{ 52public: 53 class EventHandler { 54 friend class HWComposer; 55 virtual void onVSyncReceived(int dpy, nsecs_t timestamp) = 0; 56 protected: 57 virtual ~EventHandler() {} 58 }; 59 60 HWComposer(const sp<SurfaceFlinger>& flinger, 61 EventHandler& handler, nsecs_t refreshPeriod); 62 ~HWComposer(); 63 64 status_t initCheck() const; 65 66 // tells the HAL what the framebuffer is 67 void setFrameBuffer(EGLDisplay dpy, EGLSurface sur); 68 69 // Asks the HAL what it can do 70 status_t prepare() const; 71 72 // disable hwc until next createWorkList 73 status_t disable(); 74 75 // commits the list 76 status_t commit() const; 77 78 // release hardware resources and blank screen 79 status_t release() const; 80 81 // acquire hardware resources and unblank screen 82 status_t acquire() const; 83 84 // create a work list for numLayers layer. sets HWC_GEOMETRY_CHANGED. 85 status_t createWorkList(size_t numLayers); 86 87 // get the layer array created by createWorkList() 88 size_t getNumLayers() const; 89 90 // get number of layers of the given type as updated in prepare(). 91 // type is HWC_OVERLAY or HWC_FRAMEBUFFER 92 size_t getLayerCount(int type) const; 93 94 // needed forward declarations 95 class LayerListIterator; 96 97 /* 98 * Interface to hardware composer's layers functionality. 99 * This abstracts the HAL interface to layers which can evolve in 100 * incompatible ways from one release to another. 101 * The idea is that we could extend this interface as we add 102 * features to h/w composer. 103 */ 104 class HWCLayerInterface { 105 protected: 106 virtual ~HWCLayerInterface() { } 107 public: 108 virtual int32_t getCompositionType() const = 0; 109 virtual uint32_t getHints() const = 0; 110 virtual int getAndResetReleaseFenceFd() = 0; 111 virtual void setDefaultState() = 0; 112 virtual void setSkip(bool skip) = 0; 113 virtual void setBlending(uint32_t blending) = 0; 114 virtual void setTransform(uint32_t transform) = 0; 115 virtual void setFrame(const Rect& frame) = 0; 116 virtual void setCrop(const Rect& crop) = 0; 117 virtual void setVisibleRegionScreen(const Region& reg) = 0; 118 virtual void setBuffer(const sp<GraphicBuffer>& buffer) = 0; 119 virtual void setAcquireFenceFd(int fenceFd) = 0; 120 }; 121 122 /* 123 * Interface used to implement an iterator to a list 124 * of HWCLayer. 125 */ 126 class HWCLayer : public HWCLayerInterface { 127 friend class LayerListIterator; 128 // select the layer at the given index 129 virtual status_t setLayer(size_t index) = 0; 130 virtual HWCLayer* dup() = 0; 131 static HWCLayer* copy(HWCLayer *rhs) { 132 return rhs ? rhs->dup() : NULL; 133 } 134 protected: 135 virtual ~HWCLayer() { } 136 }; 137 138 /* 139 * Iterator through a HWCLayer list. 140 * This behaves more or less like a forward iterator. 141 */ 142 class LayerListIterator { 143 friend struct HWComposer; 144 HWCLayer* const mLayerList; 145 size_t mIndex; 146 147 LayerListIterator() : mLayerList(NULL), mIndex(0) { } 148 149 LayerListIterator(HWCLayer* layer, size_t index) 150 : mLayerList(layer), mIndex(index) { } 151 152 // we don't allow assignment, because we don't need it for now 153 LayerListIterator& operator = (const LayerListIterator& rhs); 154 155 public: 156 // copy operators 157 LayerListIterator(const LayerListIterator& rhs) 158 : mLayerList(HWCLayer::copy(rhs.mLayerList)), mIndex(rhs.mIndex) { 159 } 160 161 ~LayerListIterator() { delete mLayerList; } 162 163 // pre-increment 164 LayerListIterator& operator++() { 165 mLayerList->setLayer(++mIndex); 166 return *this; 167 } 168 169 // dereference 170 HWCLayerInterface& operator * () { return *mLayerList; } 171 HWCLayerInterface* operator -> () { return mLayerList; } 172 173 // comparison 174 bool operator == (const LayerListIterator& rhs) const { 175 return mIndex == rhs.mIndex; 176 } 177 bool operator != (const LayerListIterator& rhs) const { 178 return !operator==(rhs); 179 } 180 }; 181 182 // Returns an iterator to the beginning of the layer list 183 LayerListIterator begin(); 184 185 // Returns an iterator to the end of the layer list 186 LayerListIterator end(); 187 188 189 // Events handling --------------------------------------------------------- 190 191 enum { 192 EVENT_VSYNC = HWC_EVENT_VSYNC 193 }; 194 195 void eventControl(int event, int enabled); 196 197 // this class is only used to fake the VSync event on systems that don't 198 // have it. 199 class VSyncThread : public Thread { 200 HWComposer& mHwc; 201 mutable Mutex mLock; 202 Condition mCondition; 203 bool mEnabled; 204 mutable nsecs_t mNextFakeVSync; 205 nsecs_t mRefreshPeriod; 206 virtual void onFirstRef(); 207 virtual bool threadLoop(); 208 public: 209 VSyncThread(HWComposer& hwc); 210 void setEnabled(bool enabled); 211 }; 212 213 friend class VSyncThread; 214 215 // for debugging ---------------------------------------------------------- 216 void dump(String8& out, char* scratch, size_t SIZE, 217 const Vector< sp<LayerBase> >& visibleLayersSortedByZ) const; 218 219private: 220 LayerListIterator getLayerIterator(size_t index); 221 222 struct cb_context; 223 224 static void hook_invalidate(struct hwc_procs* procs); 225 static void hook_vsync(struct hwc_procs* procs, int dpy, int64_t timestamp); 226 227 inline void invalidate(); 228 inline void vsync(int dpy, int64_t timestamp); 229 230 sp<SurfaceFlinger> mFlinger; 231 hw_module_t const* mModule; 232 struct hwc_composer_device_1* mHwc; 233 struct hwc_layer_list_1* mList; 234 size_t mCapacity; 235 mutable size_t mNumOVLayers; 236 mutable size_t mNumFBLayers; 237 EGLDisplay mDpy; 238 EGLSurface mSur; 239 cb_context* mCBContext; 240 EventHandler& mEventHandler; 241 nsecs_t mRefreshPeriod; 242 size_t mVSyncCount; 243 sp<VSyncThread> mVSyncThread; 244 bool mDebugForceFakeVSync; 245}; 246 247// --------------------------------------------------------------------------- 248}; // namespace android 249 250#endif // ANDROID_SF_HWCOMPOSER_H 251