services/surfaceflinger/DisplayHardware/HWComposer.h

   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