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