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