Home | History | Annotate | Download | only in DisplayHardware 
      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 <EGL/egl.h>
     24 
     25 #include <hardware/hwcomposer.h>
     26 
     27 #include <utils/StrongPointer.h>
     28 #include <utils/Vector.h>
     29 
     30 extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
     31                            const struct timespec *request,
     32                            struct timespec *remain);
     33 
     34 namespace android {
     35 // ---------------------------------------------------------------------------
     36 
     37 class String8;
     38 class SurfaceFlinger;
     39 class LayerBase;
     40 
     41 class HWComposer
     42 {
     43 public:
     44     class EventHandler {
     45         friend class HWComposer;
     46         virtual void onVSyncReceived(int dpy, nsecs_t timestamp) = 0;
     47     protected:
     48         virtual ~EventHandler() {}
     49     };
     50 
     51     HWComposer(const sp<SurfaceFlinger>& flinger,
     52             EventHandler& handler, nsecs_t refreshPeriod);
     53     ~HWComposer();
     54 
     55     status_t initCheck() const;
     56 
     57     // tells the HAL what the framebuffer is
     58     void setFrameBuffer(EGLDisplay dpy, EGLSurface sur);
     59 
     60     // create a work list for numLayers layer. sets HWC_GEOMETRY_CHANGED.
     61     status_t createWorkList(size_t numLayers);
     62 
     63     // Asks the HAL what it can do
     64     status_t prepare() const;
     65 
     66     // disable hwc until next createWorkList
     67     status_t disable();
     68 
     69     // commits the list
     70     status_t commit() const;
     71 
     72     // release hardware resources
     73     status_t release() const;
     74 
     75     // get the layer array created by createWorkList()
     76     size_t getNumLayers() const;
     77     hwc_layer_t* getLayers() const;
     78 
     79     // get number of layers of the given type as updated in prepare().
     80     // type is HWC_OVERLAY or HWC_FRAMEBUFFER
     81     size_t getLayerCount(int type) const;
     82 
     83     // Events handling ---------------------------------------------------------
     84 
     85     enum {
     86         EVENT_VSYNC = HWC_EVENT_VSYNC
     87     };
     88 
     89     void eventControl(int event, int enabled);
     90 
     91     // this class is only used to fake the VSync event on systems that don't
     92     // have it.
     93     class VSyncThread : public Thread {
     94         HWComposer& mHwc;
     95         mutable Mutex mLock;
     96         Condition mCondition;
     97         bool mEnabled;
     98         mutable nsecs_t mNextFakeVSync;
     99         nsecs_t mRefreshPeriod;
    100         virtual void onFirstRef();
    101         virtual bool threadLoop();
    102     public:
    103         VSyncThread(HWComposer& hwc);
    104         void setEnabled(bool enabled);
    105     };
    106 
    107     friend class VSyncThread;
    108 
    109     // for debugging ----------------------------------------------------------
    110     void dump(String8& out, char* scratch, size_t SIZE,
    111             const Vector< sp<LayerBase> >& visibleLayersSortedByZ) const;
    112 
    113 private:
    114 
    115     struct callbacks : public hwc_procs_t {
    116         // these are here to facilitate the transition when adding
    117         // new callbacks (an implementation can check for NULL before
    118         // calling a new callback).
    119         void (*zero[4])(void);
    120     };
    121 
    122     struct cb_context {
    123         callbacks procs;
    124         HWComposer* hwc;
    125     };
    126 
    127     static void hook_invalidate(struct hwc_procs* procs);
    128     static void hook_vsync(struct hwc_procs* procs, int dpy, int64_t timestamp);
    129 
    130     inline void invalidate();
    131     inline void vsync(int dpy, int64_t timestamp);
    132 
    133     sp<SurfaceFlinger>      mFlinger;
    134     hw_module_t const*      mModule;
    135     hwc_composer_device_t*  mHwc;
    136     hwc_layer_list_t*       mList;
    137     size_t                  mCapacity;
    138     mutable size_t          mNumOVLayers;
    139     mutable size_t          mNumFBLayers;
    140     hwc_display_t           mDpy;
    141     hwc_surface_t           mSur;
    142     cb_context              mCBContext;
    143     EventHandler&           mEventHandler;
    144     nsecs_t                 mRefreshPeriod;
    145     size_t                  mVSyncCount;
    146     sp<VSyncThread>         mVSyncThread;
    147     bool                    mDebugForceFakeVSync;
    148 };
    149 
    150 
    151 // ---------------------------------------------------------------------------
    152 }; // namespace android
    153 
    154 #endif // ANDROID_SF_HWCOMPOSER_H
    155