851cfe8342
HWComposer didn't allow the virtual display output buffer to be set directly, instead it always used the framebuffer target buffer. DisplayDevice was only providing the framebuffer release fence to DisplaySurfaces after a commit. This change fixes both of these, so both HWComposer and DisplayDevice should continue to work if VirtualDisplaySurface changes to use separate framebuffer and output buffers. It's also more correct since VirtualDisplaySurface uses the correct release fence when queueing the buffer to the sink. Bug: 8384764 Change-Id: I95c71e8d4f67705e23f122259ec8dd5dbce70dcf
355 lines
11 KiB
C++
355 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef ANDROID_SF_HWCOMPOSER_H
|
|
#define ANDROID_SF_HWCOMPOSER_H
|
|
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <hardware/hwcomposer_defs.h>
|
|
|
|
#include <ui/Fence.h>
|
|
|
|
#include <utils/BitSet.h>
|
|
#include <utils/Condition.h>
|
|
#include <utils/Mutex.h>
|
|
#include <utils/StrongPointer.h>
|
|
#include <utils/Thread.h>
|
|
#include <utils/Timers.h>
|
|
#include <utils/Vector.h>
|
|
|
|
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 android {
|
|
// ---------------------------------------------------------------------------
|
|
|
|
class GraphicBuffer;
|
|
class Fence;
|
|
class Region;
|
|
class String8;
|
|
class SurfaceFlinger;
|
|
|
|
class HWComposer
|
|
{
|
|
public:
|
|
class EventHandler {
|
|
friend class HWComposer;
|
|
virtual void onVSyncReceived(int disp, nsecs_t timestamp) = 0;
|
|
virtual void onHotplugReceived(int disp, bool connected) = 0;
|
|
protected:
|
|
virtual ~EventHandler() {}
|
|
};
|
|
|
|
enum {
|
|
MAX_DISPLAYS = HWC_NUM_DISPLAY_TYPES + 1
|
|
};
|
|
|
|
HWComposer(
|
|
const sp<SurfaceFlinger>& flinger,
|
|
EventHandler& handler);
|
|
|
|
~HWComposer();
|
|
|
|
status_t initCheck() const;
|
|
|
|
// returns a display ID starting at MAX_DISPLAYS, this ID
|
|
// is to be used with createWorkList (and all other
|
|
// methods requiring an ID below).
|
|
// IDs below MAX_DISPLAY are pre-defined and therefore are always valid.
|
|
// returns a negative error code if an ID cannot be allocated
|
|
int32_t allocateDisplayId();
|
|
|
|
// recycles the given ID and frees the associated worklist.
|
|
// IDs below MAX_DISPLAYS are not recycled
|
|
status_t freeDisplayId(int32_t id);
|
|
|
|
|
|
// Asks the HAL what it can do
|
|
status_t prepare();
|
|
|
|
// commits the list
|
|
status_t commit();
|
|
|
|
// release hardware resources and blank screen
|
|
status_t release(int disp);
|
|
|
|
// acquire hardware resources and unblank screen
|
|
status_t acquire(int disp);
|
|
|
|
// 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;
|
|
|
|
// does this display have layers handled by HWC
|
|
bool hasHwcComposition(int32_t id) const;
|
|
|
|
// does this display have layers handled by GLES
|
|
bool hasGlesComposition(int32_t id) 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);
|
|
|
|
// 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);
|
|
|
|
// 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,
|
|
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);
|
|
|
|
/*
|
|
* 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 setBlending(uint32_t blending) = 0;
|
|
virtual void setTransform(uint32_t transform) = 0;
|
|
virtual void setFrame(const Rect& frame) = 0;
|
|
virtual void setCrop(const Rect& crop) = 0;
|
|
virtual void setVisibleRegionScreen(const Region& reg) = 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 struct 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);
|
|
|
|
|
|
// Events handling ---------------------------------------------------------
|
|
|
|
enum {
|
|
EVENT_VSYNC = HWC_EVENT_VSYNC
|
|
};
|
|
|
|
void eventControl(int disp, int event, int enabled);
|
|
|
|
// Query display parameters. Pass in a display index (e.g.
|
|
// HWC_DISPLAY_PRIMARY).
|
|
nsecs_t getRefreshPeriod(int disp) const;
|
|
nsecs_t getRefreshTimestamp(int disp) const;
|
|
sp<Fence> getDisplayFence(int disp) const;
|
|
uint32_t getWidth(int disp) const;
|
|
uint32_t getHeight(int disp) const;
|
|
uint32_t getFormat(int disp) const;
|
|
float getDpiX(int disp) const;
|
|
float getDpiY(int disp) const;
|
|
bool isConnected(int disp) const;
|
|
|
|
// 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;
|
|
|
|
// for debugging ----------------------------------------------------------
|
|
void dump(String8& out, char* scratch, size_t SIZE) const;
|
|
|
|
private:
|
|
void loadHwcModule();
|
|
int loadFbHalModule();
|
|
|
|
LayerListIterator getLayerIterator(int32_t id, size_t index);
|
|
|
|
struct cb_context;
|
|
|
|
static void hook_invalidate(const struct hwc_procs* procs);
|
|
static void hook_vsync(const struct hwc_procs* procs, int disp,
|
|
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);
|
|
|
|
|
|
struct DisplayData {
|
|
DisplayData();
|
|
~DisplayData();
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t format; // pixel format from FB hal, for pre-hwc-1.1
|
|
float xdpi;
|
|
float ydpi;
|
|
nsecs_t refresh;
|
|
bool connected;
|
|
bool hasFbComp;
|
|
bool hasOvComp;
|
|
size_t capacity;
|
|
hwc_display_contents_1* list;
|
|
hwc_layer_1* framebufferTarget;
|
|
buffer_handle_t fbTargetHandle;
|
|
sp<Fence> lastRetireFence; // signals when the last set op retires
|
|
sp<Fence> lastDisplayFence; // signals when the last set op takes
|
|
// effect on screen
|
|
buffer_handle_t outbufHandle;
|
|
sp<Fence> outbufAcquireFence;
|
|
|
|
// protected by mEventControlLock
|
|
int32_t events;
|
|
};
|
|
|
|
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_DISPLAYS];
|
|
DisplayData mDisplayData[MAX_DISPLAYS];
|
|
size_t mNumDisplays;
|
|
|
|
cb_context* mCBContext;
|
|
EventHandler& mEventHandler;
|
|
size_t mVSyncCount;
|
|
sp<VSyncThread> mVSyncThread;
|
|
bool mDebugForceFakeVSync;
|
|
BitSet32 mAllocatedDisplayIDs;
|
|
|
|
// protected by mLock
|
|
mutable Mutex mLock;
|
|
mutable nsecs_t mLastHwVSync;
|
|
|
|
// thread-safe
|
|
mutable Mutex mEventControlLock;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
}; // namespace android
|
|
|
|
#endif // ANDROID_SF_HWCOMPOSER_H
|