HWComposer.h revision c39736088398a9b4367b30fc307ed7de96ac342e
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 <hardware/hwcomposer_defs.h> 24 25#include <utils/Condition.h> 26#include <utils/Mutex.h> 27#include <utils/StrongPointer.h> 28#include <utils/Thread.h> 29#include <utils/Timers.h> 30#include <utils/Vector.h> 31#include <utils/BitSet.h> 32 33extern "C" int clock_nanosleep(clockid_t clock_id, int flags, 34 const struct timespec *request, 35 struct timespec *remain); 36 37struct hwc_composer_device_1; 38struct hwc_display_contents_1; 39struct hwc_procs; 40struct framebuffer_device_t; 41 42namespace android { 43// --------------------------------------------------------------------------- 44 45class GraphicBuffer; 46class LayerBase; 47class Region; 48class String8; 49class SurfaceFlinger; 50 51class HWComposer 52{ 53public: 54 class EventHandler { 55 friend class HWComposer; 56 virtual void onVSyncReceived(int disp, nsecs_t timestamp) = 0; 57 protected: 58 virtual ~EventHandler() {} 59 }; 60 61 enum { 62 MAX_DISPLAYS = HWC_NUM_DISPLAY_TYPES + 1 63 }; 64 65 HWComposer( 66 const sp<SurfaceFlinger>& flinger, 67 EventHandler& handler, 68 framebuffer_device_t const* fbDev); 69 70 ~HWComposer(); 71 72 status_t initCheck() const; 73 74 // returns a display ID starting at MAX_DISPLAYS, this ID 75 // is to be used with createWorkList (and all other 76 // methods requiring an ID below). 77 // IDs below MAX_DISPLAY are pre-defined and therefore are always valid. 78 // returns a negative error code if an ID cannot be allocated 79 int32_t allocateDisplayId(); 80 81 // recycles the given ID and frees the associated worklist. 82 // IDs below MAX_DISPLAYS are not recycled 83 status_t freeDisplayId(int32_t id); 84 85 86 // Asks the HAL what it can do 87 status_t prepare(); 88 89 // commits the list 90 status_t commit(); 91 92 // release hardware resources and blank screen 93 status_t release() const; 94 95 // acquire hardware resources and unblank screen 96 status_t acquire() const; 97 98 // create a work list for numLayers layer. sets HWC_GEOMETRY_CHANGED. 99 status_t createWorkList(int32_t id, size_t numLayers); 100 101 // does this display have layers handled by HWC 102 bool hasHwcComposition(int32_t id) const; 103 104 // does this display have layers handled by GLES 105 bool hasGlesComposition(int32_t id) const; 106 107 // needed forward declarations 108 class LayerListIterator; 109 110 /* 111 * Interface to hardware composer's layers functionality. 112 * This abstracts the HAL interface to layers which can evolve in 113 * incompatible ways from one release to another. 114 * The idea is that we could extend this interface as we add 115 * features to h/w composer. 116 */ 117 class HWCLayerInterface { 118 protected: 119 virtual ~HWCLayerInterface() { } 120 public: 121 virtual int32_t getCompositionType() const = 0; 122 virtual uint32_t getHints() const = 0; 123 virtual int getAndResetReleaseFenceFd() = 0; 124 virtual void setDefaultState() = 0; 125 virtual void setSkip(bool skip) = 0; 126 virtual void setBlending(uint32_t blending) = 0; 127 virtual void setTransform(uint32_t transform) = 0; 128 virtual void setFrame(const Rect& frame) = 0; 129 virtual void setCrop(const Rect& crop) = 0; 130 virtual void setVisibleRegionScreen(const Region& reg) = 0; 131 virtual void setBuffer(const sp<GraphicBuffer>& buffer) = 0; 132 virtual void setAcquireFenceFd(int fenceFd) = 0; 133 virtual void onDisplayed() = 0; 134 }; 135 136 /* 137 * Interface used to implement an iterator to a list 138 * of HWCLayer. 139 */ 140 class HWCLayer : public HWCLayerInterface { 141 friend class LayerListIterator; 142 // select the layer at the given index 143 virtual status_t setLayer(size_t index) = 0; 144 virtual HWCLayer* dup() = 0; 145 static HWCLayer* copy(HWCLayer *rhs) { 146 return rhs ? rhs->dup() : NULL; 147 } 148 protected: 149 virtual ~HWCLayer() { } 150 }; 151 152 /* 153 * Iterator through a HWCLayer list. 154 * This behaves more or less like a forward iterator. 155 */ 156 class LayerListIterator { 157 friend struct HWComposer; 158 HWCLayer* const mLayerList; 159 size_t mIndex; 160 161 LayerListIterator() : mLayerList(NULL), mIndex(0) { } 162 163 LayerListIterator(HWCLayer* layer, size_t index) 164 : mLayerList(layer), mIndex(index) { } 165 166 // we don't allow assignment, because we don't need it for now 167 LayerListIterator& operator = (const LayerListIterator& rhs); 168 169 public: 170 // copy operators 171 LayerListIterator(const LayerListIterator& rhs) 172 : mLayerList(HWCLayer::copy(rhs.mLayerList)), mIndex(rhs.mIndex) { 173 } 174 175 ~LayerListIterator() { delete mLayerList; } 176 177 // pre-increment 178 LayerListIterator& operator++() { 179 mLayerList->setLayer(++mIndex); 180 return *this; 181 } 182 183 // dereference 184 HWCLayerInterface& operator * () { return *mLayerList; } 185 HWCLayerInterface* operator -> () { return mLayerList; } 186 187 // comparison 188 bool operator == (const LayerListIterator& rhs) const { 189 return mIndex == rhs.mIndex; 190 } 191 bool operator != (const LayerListIterator& rhs) const { 192 return !operator==(rhs); 193 } 194 }; 195 196 // Returns an iterator to the beginning of the layer list 197 LayerListIterator begin(int32_t id); 198 199 // Returns an iterator to the end of the layer list 200 LayerListIterator end(int32_t id); 201 202 203 // Events handling --------------------------------------------------------- 204 205 enum { 206 EVENT_VSYNC = HWC_EVENT_VSYNC 207 }; 208 209 void eventControl(int event, int enabled); 210 211 nsecs_t getRefreshPeriod() const; 212 nsecs_t getRefreshTimestamp() const; 213 float getDpiX() const; 214 float getDpiY() const; 215 216 // this class is only used to fake the VSync event on systems that don't 217 // have it. 218 class VSyncThread : public Thread { 219 HWComposer& mHwc; 220 mutable Mutex mLock; 221 Condition mCondition; 222 bool mEnabled; 223 mutable nsecs_t mNextFakeVSync; 224 nsecs_t mRefreshPeriod; 225 virtual void onFirstRef(); 226 virtual bool threadLoop(); 227 public: 228 VSyncThread(HWComposer& hwc); 229 void setEnabled(bool enabled); 230 }; 231 232 friend class VSyncThread; 233 234 // for debugging ---------------------------------------------------------- 235 void dump(String8& out, char* scratch, size_t SIZE, 236 const Vector< sp<LayerBase> >& visibleLayersSortedByZ) const; 237 238private: 239 240 LayerListIterator getLayerIterator(int32_t id, size_t index); 241 size_t getNumLayers(int32_t id) const; 242 243 struct cb_context; 244 245 static void hook_invalidate(const struct hwc_procs* procs); 246 static void hook_vsync(const struct hwc_procs* procs, int disp, 247 int64_t timestamp); 248 static void hook_hotplug(const struct hwc_procs* procs, int disp, 249 int connected); 250 251 inline void invalidate(); 252 inline void vsync(int disp, int64_t timestamp); 253 inline void hotplug(int disp, int connected); 254 255 void queryDisplayProperties(int disp); 256 257 struct DisplayData { 258 DisplayData() : xdpi(0), ydpi(0), refresh(0), 259 hasFbComp(false), hasOvComp(false), 260 capacity(0), list(NULL) { } 261 ~DisplayData() { 262 free(list); 263 } 264 float xdpi; 265 float ydpi; 266 nsecs_t refresh; 267 bool hasFbComp; 268 bool hasOvComp; 269 size_t capacity; 270 hwc_display_contents_1* list; 271 }; 272 273 sp<SurfaceFlinger> mFlinger; 274 hw_module_t const* mModule; 275 struct hwc_composer_device_1* mHwc; 276 // invariant: mLists[0] != NULL iff mHwc != NULL 277 // mLists[i>0] can be NULL. that display is to be ignored 278 struct hwc_display_contents_1* mLists[MAX_DISPLAYS]; 279 DisplayData mDisplayData[MAX_DISPLAYS]; 280 size_t mNumDisplays; 281 282 cb_context* mCBContext; 283 EventHandler& mEventHandler; 284 size_t mVSyncCount; 285 sp<VSyncThread> mVSyncThread; 286 bool mDebugForceFakeVSync; 287 BitSet32 mAllocatedDisplayIDs; 288 289 // protected by mLock 290 mutable Mutex mLock; 291 mutable nsecs_t mLastHwVSync; 292}; 293 294// --------------------------------------------------------------------------- 295}; // namespace android 296 297#endif // ANDROID_SF_HWCOMPOSER_H 298