HWComposer.h revision ee932d0ad1a16cc93b4bd9eaf9cb3cc756fb2dfc
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_layer_1; 40struct hwc_procs; 41struct framebuffer_device_t; 42 43namespace android { 44// --------------------------------------------------------------------------- 45 46class GraphicBuffer; 47class Fence; 48class LayerBase; 49class Region; 50class String8; 51class SurfaceFlinger; 52 53class HWComposer 54{ 55public: 56 class EventHandler { 57 friend class HWComposer; 58 virtual void onVSyncReceived(int disp, nsecs_t timestamp) = 0; 59 virtual void onHotplugReceived(int disp, bool connected) = 0; 60 protected: 61 virtual ~EventHandler() {} 62 }; 63 64 enum { 65 MAX_DISPLAYS = HWC_NUM_DISPLAY_TYPES + 1 66 }; 67 68 HWComposer( 69 const sp<SurfaceFlinger>& flinger, 70 EventHandler& handler); 71 72 ~HWComposer(); 73 74 status_t initCheck() const; 75 76 // returns a display ID starting at MAX_DISPLAYS, this ID 77 // is to be used with createWorkList (and all other 78 // methods requiring an ID below). 79 // IDs below MAX_DISPLAY are pre-defined and therefore are always valid. 80 // returns a negative error code if an ID cannot be allocated 81 int32_t allocateDisplayId(); 82 83 // recycles the given ID and frees the associated worklist. 84 // IDs below MAX_DISPLAYS are not recycled 85 status_t freeDisplayId(int32_t id); 86 87 88 // Asks the HAL what it can do 89 status_t prepare(); 90 91 // commits the list 92 status_t commit(); 93 94 // release hardware resources and blank screen 95 status_t release(int disp); 96 97 // acquire hardware resources and unblank screen 98 status_t acquire(int disp); 99 100 // reset state when an external, non-virtual display is disconnected 101 void disconnectDisplay(int disp); 102 103 // create a work list for numLayers layer. sets HWC_GEOMETRY_CHANGED. 104 status_t createWorkList(int32_t id, size_t numLayers); 105 106 bool supportsFramebufferTarget() const; 107 108 // does this display have layers handled by HWC 109 bool hasHwcComposition(int32_t id) const; 110 111 // does this display have layers handled by GLES 112 bool hasGlesComposition(int32_t id) const; 113 114 // get the releaseFence file descriptor for the given display 115 // the release fence is only valid after commit() 116 int getAndResetReleaseFenceFd(int32_t id); 117 118 // needed forward declarations 119 class LayerListIterator; 120 121 // return the visual id to be used to find a suitable EGLConfig for 122 // *ALL* displays. 123 int getVisualID() const; 124 125 // Forwarding to FB HAL for pre-HWC-1.1 code (see FramebufferSurface). 126 int fbPost(int32_t id, const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf); 127 int fbCompositionComplete(); 128 void fbDump(String8& result); 129 130 /* 131 * Interface to hardware composer's layers functionality. 132 * This abstracts the HAL interface to layers which can evolve in 133 * incompatible ways from one release to another. 134 * The idea is that we could extend this interface as we add 135 * features to h/w composer. 136 */ 137 class HWCLayerInterface { 138 protected: 139 virtual ~HWCLayerInterface() { } 140 public: 141 virtual int32_t getCompositionType() const = 0; 142 virtual uint32_t getHints() const = 0; 143 virtual int getAndResetReleaseFenceFd() = 0; 144 virtual void setPerFrameDefaultState() = 0; 145 virtual void setDefaultState() = 0; 146 virtual void setSkip(bool skip) = 0; 147 virtual void setBlending(uint32_t blending) = 0; 148 virtual void setTransform(uint32_t transform) = 0; 149 virtual void setFrame(const Rect& frame) = 0; 150 virtual void setCrop(const Rect& crop) = 0; 151 virtual void setVisibleRegionScreen(const Region& reg) = 0; 152 virtual void setBuffer(const sp<GraphicBuffer>& buffer) = 0; 153 virtual void setAcquireFenceFd(int fenceFd) = 0; 154 virtual void onDisplayed() = 0; 155 }; 156 157 /* 158 * Interface used to implement an iterator to a list 159 * of HWCLayer. 160 */ 161 class HWCLayer : public HWCLayerInterface { 162 friend class LayerListIterator; 163 // select the layer at the given index 164 virtual status_t setLayer(size_t index) = 0; 165 virtual HWCLayer* dup() = 0; 166 static HWCLayer* copy(HWCLayer *rhs) { 167 return rhs ? rhs->dup() : NULL; 168 } 169 protected: 170 virtual ~HWCLayer() { } 171 }; 172 173 /* 174 * Iterator through a HWCLayer list. 175 * This behaves more or less like a forward iterator. 176 */ 177 class LayerListIterator { 178 friend struct HWComposer; 179 HWCLayer* const mLayerList; 180 size_t mIndex; 181 182 LayerListIterator() : mLayerList(NULL), mIndex(0) { } 183 184 LayerListIterator(HWCLayer* layer, size_t index) 185 : mLayerList(layer), mIndex(index) { } 186 187 // we don't allow assignment, because we don't need it for now 188 LayerListIterator& operator = (const LayerListIterator& rhs); 189 190 public: 191 // copy operators 192 LayerListIterator(const LayerListIterator& rhs) 193 : mLayerList(HWCLayer::copy(rhs.mLayerList)), mIndex(rhs.mIndex) { 194 } 195 196 ~LayerListIterator() { delete mLayerList; } 197 198 // pre-increment 199 LayerListIterator& operator++() { 200 mLayerList->setLayer(++mIndex); 201 return *this; 202 } 203 204 // dereference 205 HWCLayerInterface& operator * () { return *mLayerList; } 206 HWCLayerInterface* operator -> () { return mLayerList; } 207 208 // comparison 209 bool operator == (const LayerListIterator& rhs) const { 210 return mIndex == rhs.mIndex; 211 } 212 bool operator != (const LayerListIterator& rhs) const { 213 return !operator==(rhs); 214 } 215 }; 216 217 // Returns an iterator to the beginning of the layer list 218 LayerListIterator begin(int32_t id); 219 220 // Returns an iterator to the end of the layer list 221 LayerListIterator end(int32_t id); 222 223 224 // Events handling --------------------------------------------------------- 225 226 enum { 227 EVENT_VSYNC = HWC_EVENT_VSYNC 228 }; 229 230 void eventControl(int disp, int event, int enabled); 231 232 // Query display parameters. Pass in a display index (e.g. 233 // HWC_DISPLAY_PRIMARY). 234 nsecs_t getRefreshPeriod(int disp) const; 235 nsecs_t getRefreshTimestamp(int disp) const; 236 uint32_t getWidth(int disp) const; 237 uint32_t getHeight(int disp) const; 238 uint32_t getFormat(int disp) const; 239 float getDpiX(int disp) const; 240 float getDpiY(int disp) const; 241 bool isConnected(int disp) const; 242 243 // this class is only used to fake the VSync event on systems that don't 244 // have it. 245 class VSyncThread : public Thread { 246 HWComposer& mHwc; 247 mutable Mutex mLock; 248 Condition mCondition; 249 bool mEnabled; 250 mutable nsecs_t mNextFakeVSync; 251 nsecs_t mRefreshPeriod; 252 virtual void onFirstRef(); 253 virtual bool threadLoop(); 254 public: 255 VSyncThread(HWComposer& hwc); 256 void setEnabled(bool enabled); 257 }; 258 259 friend class VSyncThread; 260 261 // for debugging ---------------------------------------------------------- 262 void dump(String8& out, char* scratch, size_t SIZE) const; 263 264private: 265 void loadHwcModule(); 266 void loadFbHalModule(); 267 268 LayerListIterator getLayerIterator(int32_t id, size_t index); 269 270 struct cb_context; 271 272 static void hook_invalidate(const struct hwc_procs* procs); 273 static void hook_vsync(const struct hwc_procs* procs, int disp, 274 int64_t timestamp); 275 static void hook_hotplug(const struct hwc_procs* procs, int disp, 276 int connected); 277 278 inline void invalidate(); 279 inline void vsync(int disp, int64_t timestamp); 280 inline void hotplug(int disp, int connected); 281 282 status_t queryDisplayProperties(int disp); 283 284 status_t setFramebufferTarget(int32_t id, 285 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf); 286 287 288 struct DisplayData { 289 DisplayData() : xdpi(0), ydpi(0), refresh(0), 290 connected(false), hasFbComp(false), hasOvComp(false), 291 capacity(0), list(NULL), 292 framebufferTarget(NULL), fbTargetHandle(NULL), events(0) { } 293 ~DisplayData() { 294 free(list); 295 } 296 uint32_t width; 297 uint32_t height; 298 uint32_t format; // pixel format from FB hal, for pre-hwc-1.1 299 float xdpi; 300 float ydpi; 301 nsecs_t refresh; 302 bool connected; 303 bool hasFbComp; 304 bool hasOvComp; 305 size_t capacity; 306 hwc_display_contents_1* list; 307 hwc_layer_1* framebufferTarget; 308 buffer_handle_t fbTargetHandle; 309 // protected by mEventControlLock 310 int32_t events; 311 }; 312 313 sp<SurfaceFlinger> mFlinger; 314 framebuffer_device_t* mFbDev; 315 struct hwc_composer_device_1* mHwc; 316 // invariant: mLists[0] != NULL iff mHwc != NULL 317 // mLists[i>0] can be NULL. that display is to be ignored 318 struct hwc_display_contents_1* mLists[MAX_DISPLAYS]; 319 DisplayData mDisplayData[MAX_DISPLAYS]; 320 size_t mNumDisplays; 321 322 cb_context* mCBContext; 323 EventHandler& mEventHandler; 324 size_t mVSyncCount; 325 sp<VSyncThread> mVSyncThread; 326 bool mDebugForceFakeVSync; 327 BitSet32 mAllocatedDisplayIDs; 328 329 // protected by mLock 330 mutable Mutex mLock; 331 mutable nsecs_t mLastHwVSync; 332 333 // thread-safe 334 mutable Mutex mEventControlLock; 335}; 336 337// --------------------------------------------------------------------------- 338}; // namespace android 339 340#endif // ANDROID_SF_HWCOMPOSER_H 341