Switch SurfaceFlinger to HWC 2.0
Enables SurfaceFlinger to speak to version 2.0 of the Hardware Composer
HAL instead of version 1.x (also removing support for the framebuffer
HAL). By default, however, this functionality is disabled. In order to
enable it, USE_HWC2 must be set to true in Android.mk.
Change-Id: I4589e02ac2165236b10ff2f7cb772f87e0d3daab
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index 5e0b3d8..30c8f67 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -14,14 +14,18 @@
* limitations under the License.
*/
+#ifndef USE_HWC2
+#include "HWComposer_hwc1.h"
+#else
+
#ifndef ANDROID_SF_HWCOMPOSER_H
#define ANDROID_SF_HWCOMPOSER_H
+#include "HWC2.h"
+
#include <stdint.h>
#include <sys/types.h>
-#include <hardware/hwcomposer_defs.h>
-
#include <ui/Fence.h>
#include <utils/BitSet.h>
@@ -32,22 +36,29 @@
#include <utils/Timers.h>
#include <utils/Vector.h>
+#include <memory>
+#include <set>
+#include <vector>
+
extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
const struct timespec *request,
struct timespec *remain);
-struct hwc_composer_device_1;
-struct hwc_display_contents_1;
-struct hwc_layer_1;
-struct hwc_procs;
struct framebuffer_device_t;
+namespace HWC2 {
+ class Device;
+ class Display;
+}
+
namespace android {
// ---------------------------------------------------------------------------
+class DisplayDevice;
class Fence;
class FloatRect;
class GraphicBuffer;
+class HWC2On1Adapter;
class NativeHandle;
class Region;
class String8;
@@ -58,198 +69,70 @@
public:
class EventHandler {
friend class HWComposer;
- virtual void onVSyncReceived(int disp, nsecs_t timestamp) = 0;
- virtual void onHotplugReceived(int disp, bool connected) = 0;
+ virtual void onVSyncReceived(int32_t disp, nsecs_t timestamp) = 0;
+ virtual void onHotplugReceived(int32_t disp, bool connected) = 0;
protected:
virtual ~EventHandler() {}
};
- enum {
- NUM_BUILTIN_DISPLAYS = HWC_NUM_PHYSICAL_DISPLAY_TYPES,
- MAX_HWC_DISPLAYS = HWC_NUM_DISPLAY_TYPES,
- VIRTUAL_DISPLAY_ID_BASE = HWC_DISPLAY_VIRTUAL,
- };
-
- HWComposer(
- const sp<SurfaceFlinger>& flinger,
- EventHandler& handler);
+ HWComposer(const sp<SurfaceFlinger>& flinger);
~HWComposer();
- status_t initCheck() const;
+ void setEventHandler(EventHandler* handler);
- // Returns a display ID starting at VIRTUAL_DISPLAY_ID_BASE, this ID is to
- // be used with createWorkList (and all other methods requiring an ID
- // below).
- // IDs below NUM_BUILTIN_DISPLAYS are pre-defined and therefore are
- // always valid.
- // Returns -1 if an ID cannot be allocated
- int32_t allocateDisplayId();
+ // Attempts to allocate a virtual display. If the virtual display is created
+ // on the HWC device, outId will contain its HWC ID.
+ status_t allocateVirtualDisplay(uint32_t width, uint32_t height,
+ int32_t* outId);
- // Recycles the given virtual display ID and frees the associated worklist.
- // IDs below NUM_BUILTIN_DISPLAYS are not recycled.
- status_t freeDisplayId(int32_t id);
-
+ // Attempts to create a new layer on this display
+ std::shared_ptr<HWC2::Layer> createLayer(int32_t displayId);
// Asks the HAL what it can do
- status_t prepare();
+ status_t prepare(DisplayDevice& displayDevice);
- // commits the list
- status_t commit();
+ status_t setClientTarget(int32_t displayId, const sp<Fence>& acquireFence,
+ const sp<GraphicBuffer>& target, android_dataspace_t dataspace);
+
+ // Finalize the layers and present them
+ status_t commit(int32_t displayId);
// set power mode
- status_t setPowerMode(int disp, int mode);
+ status_t setPowerMode(int32_t displayId, int mode);
// set active config
- status_t setActiveConfig(int disp, int mode);
+ status_t setActiveConfig(int32_t displayId, size_t configId);
// reset state when an external, non-virtual display is disconnected
- void disconnectDisplay(int disp);
-
- // create a work list for numLayers layer. sets HWC_GEOMETRY_CHANGED.
- status_t createWorkList(int32_t id, size_t numLayers);
-
- bool supportsFramebufferTarget() const;
+ void disconnectDisplay(int32_t displayId);
// does this display have layers handled by HWC
- bool hasHwcComposition(int32_t id) const;
+ bool hasDeviceComposition(int32_t displayId) const;
// does this display have layers handled by GLES
- bool hasGlesComposition(int32_t id) const;
+ bool hasClientComposition(int32_t displayId) const;
- // get the releaseFence file descriptor for a display's framebuffer layer.
- // the release fence is only valid after commit()
- sp<Fence> getAndResetReleaseFence(int32_t id);
+ // get the retire fence for the previous frame (i.e., corresponding to the
+ // last call to presentDisplay
+ sp<Fence> getRetireFence(int32_t displayId) const;
- // needed forward declarations
- class LayerListIterator;
-
- // return the visual id to be used to find a suitable EGLConfig for
- // *ALL* displays.
- int getVisualID() const;
-
- // Forwarding to FB HAL for pre-HWC-1.1 code (see FramebufferSurface).
- int fbPost(int32_t id, const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf);
- int fbCompositionComplete();
- void fbDump(String8& result);
+ // Get last release fence for the given layer
+ sp<Fence> getLayerReleaseFence(int32_t displayId,
+ const std::shared_ptr<HWC2::Layer>& layer) const;
// Set the output buffer and acquire fence for a virtual display.
- // Returns INVALID_OPERATION if id is not a virtual display.
- status_t setOutputBuffer(int32_t id, const sp<Fence>& acquireFence,
+ // Returns INVALID_OPERATION if displayId is not a virtual display.
+ status_t setOutputBuffer(int32_t displayId, const sp<Fence>& acquireFence,
const sp<GraphicBuffer>& buf);
- // Get the retire fence for the last committed frame. This fence will
- // signal when the h/w composer is completely finished with the frame.
- // For physical displays, it is no longer being displayed. For virtual
- // displays, writes to the output buffer are complete.
- sp<Fence> getLastRetireFence(int32_t id) const;
-
- status_t setCursorPositionAsync(int32_t id, const Rect &pos);
-
- /*
- * Interface to hardware composer's layers functionality.
- * This abstracts the HAL interface to layers which can evolve in
- * incompatible ways from one release to another.
- * The idea is that we could extend this interface as we add
- * features to h/w composer.
- */
- class HWCLayerInterface {
- protected:
- virtual ~HWCLayerInterface() { }
- public:
- virtual int32_t getCompositionType() const = 0;
- virtual uint32_t getHints() const = 0;
- virtual sp<Fence> getAndResetReleaseFence() = 0;
- virtual void setDefaultState() = 0;
- virtual void setSkip(bool skip) = 0;
- virtual void setIsCursorLayerHint(bool isCursor = true) = 0;
- virtual void setBlending(uint32_t blending) = 0;
- virtual void setTransform(uint32_t transform) = 0;
- virtual void setFrame(const Rect& frame) = 0;
- virtual void setCrop(const FloatRect& crop) = 0;
- virtual void setVisibleRegionScreen(const Region& reg) = 0;
- virtual void setSurfaceDamage(const Region& reg) = 0;
- virtual void setSidebandStream(const sp<NativeHandle>& stream) = 0;
- virtual void setBuffer(const sp<GraphicBuffer>& buffer) = 0;
- virtual void setAcquireFenceFd(int fenceFd) = 0;
- virtual void setPlaneAlpha(uint8_t alpha) = 0;
- virtual void onDisplayed() = 0;
- };
-
- /*
- * Interface used to implement an iterator to a list
- * of HWCLayer.
- */
- class HWCLayer : public HWCLayerInterface {
- friend class LayerListIterator;
- // select the layer at the given index
- virtual status_t setLayer(size_t index) = 0;
- virtual HWCLayer* dup() = 0;
- static HWCLayer* copy(HWCLayer *rhs) {
- return rhs ? rhs->dup() : NULL;
- }
- protected:
- virtual ~HWCLayer() { }
- };
-
- /*
- * Iterator through a HWCLayer list.
- * This behaves more or less like a forward iterator.
- */
- class LayerListIterator {
- friend class HWComposer;
- HWCLayer* const mLayerList;
- size_t mIndex;
-
- LayerListIterator() : mLayerList(NULL), mIndex(0) { }
-
- LayerListIterator(HWCLayer* layer, size_t index)
- : mLayerList(layer), mIndex(index) { }
-
- // we don't allow assignment, because we don't need it for now
- LayerListIterator& operator = (const LayerListIterator& rhs);
-
- public:
- // copy operators
- LayerListIterator(const LayerListIterator& rhs)
- : mLayerList(HWCLayer::copy(rhs.mLayerList)), mIndex(rhs.mIndex) {
- }
-
- ~LayerListIterator() { delete mLayerList; }
-
- // pre-increment
- LayerListIterator& operator++() {
- mLayerList->setLayer(++mIndex);
- return *this;
- }
-
- // dereference
- HWCLayerInterface& operator * () { return *mLayerList; }
- HWCLayerInterface* operator -> () { return mLayerList; }
-
- // comparison
- bool operator == (const LayerListIterator& rhs) const {
- return mIndex == rhs.mIndex;
- }
- bool operator != (const LayerListIterator& rhs) const {
- return !operator==(rhs);
- }
- };
-
- // Returns an iterator to the beginning of the layer list
- LayerListIterator begin(int32_t id);
-
- // Returns an iterator to the end of the layer list
- LayerListIterator end(int32_t id);
-
+ // After SurfaceFlinger has retrieved the release fences for all the frames,
+ // it can call this to clear the shared pointers in the release fence map
+ void clearReleaseFences(int32_t displayId);
// Events handling ---------------------------------------------------------
- enum {
- EVENT_VSYNC = HWC_EVENT_VSYNC
- };
-
- void eventControl(int disp, int event, int enabled);
+ void setVsyncEnabled(int32_t disp, HWC2::Vsync enabled);
struct DisplayConfig {
uint32_t width;
@@ -262,119 +145,81 @@
// Query display parameters. Pass in a display index (e.g.
// HWC_DISPLAY_PRIMARY).
- nsecs_t getRefreshTimestamp(int disp) const;
- sp<Fence> getDisplayFence(int disp) const;
- uint32_t getFormat(int disp) const;
- bool isConnected(int disp) const;
+ nsecs_t getRefreshTimestamp(int32_t disp) const;
+ bool isConnected(int32_t disp) const;
- // These return the values for the current config of a given display index.
- // To get the values for all configs, use getConfigs below.
- uint32_t getWidth(int disp) const;
- uint32_t getHeight(int disp) const;
- float getDpiX(int disp) const;
- float getDpiY(int disp) const;
- nsecs_t getRefreshPeriod(int disp) const;
+ // Non-const because it can update configMap inside of mDisplayData
+ std::vector<std::shared_ptr<const HWC2::Display::Config>>
+ getConfigs(int32_t displayId) const;
- const Vector<DisplayConfig>& getConfigs(int disp) const;
- size_t getCurrentConfig(int disp) const;
-
- status_t setVirtualDisplayProperties(int32_t id, uint32_t w, uint32_t h,
- uint32_t format);
-
- // this class is only used to fake the VSync event on systems that don't
- // have it.
- class VSyncThread : public Thread {
- HWComposer& mHwc;
- mutable Mutex mLock;
- Condition mCondition;
- bool mEnabled;
- mutable nsecs_t mNextFakeVSync;
- nsecs_t mRefreshPeriod;
- virtual void onFirstRef();
- virtual bool threadLoop();
- public:
- VSyncThread(HWComposer& hwc);
- void setEnabled(bool enabled);
- };
-
- friend class VSyncThread;
+ std::shared_ptr<const HWC2::Display::Config>
+ getActiveConfig(int32_t displayId) const;
// for debugging ----------------------------------------------------------
void dump(String8& out) const;
private:
- void loadHwcModule();
- int loadFbHalModule();
+ static const int32_t VIRTUAL_DISPLAY_ID_BASE = 2;
- LayerListIterator getLayerIterator(int32_t id, size_t index);
+ void loadHwcModule();
+
+ bool isValidDisplay(int32_t displayId) const;
+ static void validateChange(HWC2::Composition from, HWC2::Composition to);
struct cb_context;
- static void hook_invalidate(const struct hwc_procs* procs);
- static void hook_vsync(const struct hwc_procs* procs, int disp,
+ void invalidate(const std::shared_ptr<HWC2::Display>& display);
+ void vsync(const std::shared_ptr<HWC2::Display>& display,
int64_t timestamp);
- static void hook_hotplug(const struct hwc_procs* procs, int disp,
- int connected);
-
- inline void invalidate();
- inline void vsync(int disp, int64_t timestamp);
- inline void hotplug(int disp, int connected);
-
- status_t queryDisplayProperties(int disp);
-
- status_t setFramebufferTarget(int32_t id,
- const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf);
+ void hotplug(const std::shared_ptr<HWC2::Display>& display,
+ HWC2::Connection connected);
struct DisplayData {
DisplayData();
~DisplayData();
- Vector<DisplayConfig> configs;
- size_t currentConfig;
- uint32_t format; // pixel format from FB hal, for pre-hwc-1.1
- bool connected;
- bool hasFbComp;
- bool hasOvComp;
- size_t capacity;
- hwc_display_contents_1* list;
- hwc_layer_1* framebufferTarget;
- buffer_handle_t fbTargetHandle;
+ void reset();
+
+ bool hasClientComposition;
+ bool hasDeviceComposition;
+ std::shared_ptr<HWC2::Display> hwcDisplay;
+ HWC2::DisplayRequest displayRequests;
sp<Fence> lastRetireFence; // signals when the last set op retires
- sp<Fence> lastDisplayFence; // signals when the last set op takes
- // effect on screen
+ std::unordered_map<std::shared_ptr<HWC2::Layer>, sp<Fence>>
+ releaseFences;
buffer_handle_t outbufHandle;
sp<Fence> outbufAcquireFence;
+ mutable std::unordered_map<int32_t,
+ std::shared_ptr<const HWC2::Display::Config>> configMap;
- // protected by mEventControlLock
- int32_t events;
+ // protected by mVsyncLock
+ HWC2::Vsync vsyncEnabled;
};
sp<SurfaceFlinger> mFlinger;
- framebuffer_device_t* mFbDev;
- struct hwc_composer_device_1* mHwc;
- // invariant: mLists[0] != NULL iff mHwc != NULL
- // mLists[i>0] can be NULL. that display is to be ignored
- struct hwc_display_contents_1* mLists[MAX_HWC_DISPLAYS];
- DisplayData mDisplayData[MAX_HWC_DISPLAYS];
+ std::unique_ptr<HWC2On1Adapter> mAdapter;
+ std::unique_ptr<HWC2::Device> mHwcDevice;
+ std::vector<DisplayData> mDisplayData;
+ std::set<size_t> mFreeDisplaySlots;
+ std::unordered_map<hwc2_display_t, int32_t> mHwcDisplaySlots;
// protect mDisplayData from races between prepare and dump
mutable Mutex mDisplayLock;
- size_t mNumDisplays;
cb_context* mCBContext;
- EventHandler& mEventHandler;
+ EventHandler* mEventHandler;
size_t mVSyncCounts[HWC_NUM_PHYSICAL_DISPLAY_TYPES];
- sp<VSyncThread> mVSyncThread;
- bool mDebugForceFakeVSync;
- BitSet32 mAllocatedDisplayIDs;
+ uint32_t mRemainingHwcVirtualDisplays;
// protected by mLock
mutable Mutex mLock;
- mutable nsecs_t mLastHwVSync[HWC_NUM_PHYSICAL_DISPLAY_TYPES];
+ mutable std::unordered_map<int32_t, nsecs_t> mLastHwVSync;
// thread-safe
- mutable Mutex mEventControlLock;
+ mutable Mutex mVsyncLock;
};
// ---------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_SF_HWCOMPOSER_H
+
+#endif // #ifdef USE_HWC2