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