Remove experimental HWC virtual display support (e737c11c) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.mk

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -14,7 +14,6 @@ LOCAL_SRC_FILES:= \
	SurfaceFlingerConsumer.cpp \		SurfaceFlingerConsumer.cpp \
	SurfaceTextureLayer.cpp \		SurfaceTextureLayer.cpp \
	Transform.cpp \		Transform.cpp \
	DisplayHardware/BufferQueueInterposer.cpp \
	DisplayHardware/FramebufferSurface.cpp \		DisplayHardware/FramebufferSurface.cpp \
	DisplayHardware/HWComposer.cpp \		DisplayHardware/HWComposer.cpp \
	DisplayHardware/PowerHAL.cpp \		DisplayHardware/PowerHAL.cpp \

services/surfaceflinger/DisplayHardware/BufferQueueInterposer.cpp

deleted100644 → 0

+0 −226

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright 2013 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.
	*/

	#undef LOG_TAG
	#define LOG_TAG "BQInterposer"
	//#define LOG_NDEBUG 0

	#include "BufferQueueInterposer.h"

	// ---------------------------------------------------------------------------
	namespace android {
	// ---------------------------------------------------------------------------

	#define BQI_LOGV(x, ...) ALOGV("[%s] "x, mName.string(), ##__VA_ARGS__)
	#define BQI_LOGD(x, ...) ALOGD("[%s] "x, mName.string(), ##__VA_ARGS__)
	#define BQI_LOGI(x, ...) ALOGI("[%s] "x, mName.string(), ##__VA_ARGS__)
	#define BQI_LOGW(x, ...) ALOGW("[%s] "x, mName.string(), ##__VA_ARGS__)
	#define BQI_LOGE(x, ...) ALOGE("[%s] "x, mName.string(), ##__VA_ARGS__)

	// Get an ID that's unique within this process.
	static int32_t createProcessUniqueId() {
	static volatile int32_t globalCounter = 0;
	return android_atomic_inc(&globalCounter);
	}

	BufferQueueInterposer::BufferQueueInterposer(
	const sp<IGraphicBufferProducer>& sink, const String8& name)
	: mSink(sink),
	mName(name),
	mAcquired(false)
	{
	BQI_LOGV("BufferQueueInterposer sink=%p", sink.get());
	}

	BufferQueueInterposer::~BufferQueueInterposer() {
	Mutex::Autolock lock(mMutex);
	flushQueuedBuffersLocked();
	BQI_LOGV("~BufferQueueInterposer");
	}

	status_t BufferQueueInterposer::requestBuffer(int slot,
	sp<GraphicBuffer>* outBuf) {
	BQI_LOGV("requestBuffer slot=%d", slot);
	Mutex::Autolock lock(mMutex);

	if (size_t(slot) >= mBuffers.size()) {
	size_t size = mBuffers.size();
	mBuffers.insertAt(size, size - slot + 1);
	}
	sp<GraphicBuffer>& buf = mBuffers.editItemAt(slot);

	status_t result = mSink->requestBuffer(slot, &buf);
	*outBuf = buf;
	return result;
	}

	status_t BufferQueueInterposer::setBufferCount(int bufferCount) {
	BQI_LOGV("setBufferCount count=%d", bufferCount);
	Mutex::Autolock lock(mMutex);

	bufferCount += 1;

	status_t result = flushQueuedBuffersLocked();
	if (result != NO_ERROR)
	return result;

	result = mSink->setBufferCount(bufferCount);
	if (result != NO_ERROR)
	return result;

	for (size_t i = 0; i < mBuffers.size(); i++)
	mBuffers.editItemAt(i).clear();
	ssize_t n = mBuffers.resize(bufferCount);
	result = (n < 0) ? n : result;

	return result;
	}

	status_t BufferQueueInterposer::dequeueBuffer(int* slot, sp<Fence>* fence,
	uint32_t w, uint32_t h, uint32_t format, uint32_t usage) {
	BQI_LOGV("dequeueBuffer %ux%u fmt=%u usage=%#x", w, h, format, usage);
	return mSink->dequeueBuffer(slot, fence, w, h, format, usage);
	}

	status_t BufferQueueInterposer::queueBuffer(int slot,
	const QueueBufferInput& input, QueueBufferOutput* output) {
	BQI_LOGV("queueBuffer slot=%d", slot);
	Mutex::Autolock lock(mMutex);
	mQueue.push(QueuedBuffer(slot, input));
	*output = mQueueBufferOutput;
	return NO_ERROR;
	}

	void BufferQueueInterposer::cancelBuffer(int slot, const sp<Fence>& fence) {
	BQI_LOGV("cancelBuffer slot=%d", slot);
	mSink->cancelBuffer(slot, fence);
	}

	int BufferQueueInterposer::query(int what, int* value) {
	BQI_LOGV("query what=%d", what);
	return mSink->query(what, value);
	}

	status_t BufferQueueInterposer::setSynchronousMode(bool enabled) {
	BQI_LOGV("setSynchronousMode %s", enabled ? "true" : "false");
	return mSink->setSynchronousMode(enabled);
	}

	status_t BufferQueueInterposer::connect(int api, QueueBufferOutput* output) {
	BQI_LOGV("connect api=%d", api);
	Mutex::Autolock lock(mMutex);
	status_t result = mSink->connect(api, &mQueueBufferOutput);
	if (result == NO_ERROR) {
	*output = mQueueBufferOutput;
	}
	return result;
	}

	status_t BufferQueueInterposer::disconnect(int api) {
	BQI_LOGV("disconnect: api=%d", api);
	Mutex::Autolock lock(mMutex);
	flushQueuedBuffersLocked();
	return mSink->disconnect(api);
	}

	status_t BufferQueueInterposer::pullEmptyBuffer() {
	status_t result;

	int slot;
	sp<Fence> fence;
	result = dequeueBuffer(&slot, &fence, 0, 0, 0, 0);
	if (result == IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {
	sp<GraphicBuffer> buffer;
	result = requestBuffer(slot, &buffer);
	} else if (result != NO_ERROR) {
	return result;
	}

	uint32_t w, h, transformHint, numPendingBuffers;
	mQueueBufferOutput.deflate(&w, &h, &transformHint, &numPendingBuffers);

	IGraphicBufferProducer::QueueBufferInput qbi(0, Rect(w, h),
	NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, fence);
	IGraphicBufferProducer::QueueBufferOutput qbo;
	result = queueBuffer(slot, qbi, &qbo);
	if (result != NO_ERROR)
	return result;

	return NO_ERROR;
	}

	status_t BufferQueueInterposer::acquireBuffer(sp<GraphicBuffer>* buf,
	sp<Fence>* fence) {
	Mutex::Autolock lock(mMutex);
	if (mQueue.empty()) {
	BQI_LOGV("acquireBuffer: no buffers available");
	return NO_BUFFER_AVAILABLE;
	}
	if (mAcquired) {
	BQI_LOGE("acquireBuffer: buffer already acquired");
	return BUFFER_ALREADY_ACQUIRED;
	}
	BQI_LOGV("acquireBuffer: acquiring slot %d", mQueue[0].slot);

	*buf = mBuffers[mQueue[0].slot];
	*fence = mQueue[0].fence;
	mAcquired = true;
	return NO_ERROR;
	}

	status_t BufferQueueInterposer::releaseBuffer(const sp<Fence>& fence) {
	Mutex::Autolock lock(mMutex);
	if (!mAcquired) {
	BQI_LOGE("releaseBuffer: releasing a non-acquired buffer");
	return BUFFER_NOT_ACQUIRED;
	}
	BQI_LOGV("releaseBuffer: releasing slot %d to sink", mQueue[0].slot);

	const QueuedBuffer& b = mQueue[0];
	status_t result = mSink->queueBuffer(b.slot,
	QueueBufferInput(b.timestamp, b.crop, b.scalingMode,
	b.transform, b.fence),
	&mQueueBufferOutput);
	mQueue.removeAt(0);
	mAcquired = false;

	return result;
	}

	status_t BufferQueueInterposer::flushQueuedBuffersLocked() {
	if (mAcquired) {
	BQI_LOGE("flushQueuedBuffersLocked: buffer acquired, can't flush");
	return INVALID_OPERATION;
	}

	status_t result = NO_ERROR;
	for (size_t i = 0; i < mQueue.size(); i++) {
	const QueuedBuffer& b = mQueue[i];
	BQI_LOGV("flushing queued slot %d to sink", b.slot);
	status_t err = mSink->queueBuffer(b.slot,
	QueueBufferInput(b.timestamp, b.crop, b.scalingMode,
	b.transform, b.fence),
	&mQueueBufferOutput);
	if (err != NO_ERROR && result == NO_ERROR) // latch first error
	result = err;
	}
	mQueue.clear();
	return result;
	}

	// ---------------------------------------------------------------------------
	} // namespace android
	// ---------------------------------------------------------------------------

services/surfaceflinger/DisplayHardware/BufferQueueInterposer.h

deleted100644 → 0

+0 −152

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright 2013 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_BUFFERQUEUEINTERPOSER_H
	#define ANDROID_SF_BUFFERQUEUEINTERPOSER_H

	#include <gui/IGraphicBufferProducer.h>
	#include <utils/Mutex.h>
	#include <utils/Vector.h>

	// ---------------------------------------------------------------------------
	namespace android {
	// ---------------------------------------------------------------------------

	// BufferQueueInterposers introduce an extra stage between a buffer producer
	// (the source) and a buffer consumer (the sink), which communicate via the
	// IGraphicBufferProducer interface. It is designed to be as transparent as
	// possible to both endpoints, so that they can work the same whether an
	// interposer is present or not.
	//
	// When the interpose is present, the source queues buffers to the
	// IGraphicBufferProducer implemented by BufferQueueInterposer. A client of
	// the BufferQueueInterposer can acquire each buffer in turn and read or
	// modify it, releasing the buffer when finished. When the buffer is released,
	// the BufferQueueInterposer queues it to the original IGraphicBufferProducer
	// interface representing the sink.
	//
	// A BufferQueueInterposer can be used to do additional rendering to a buffer
	// before it is consumed -- essentially pipelining two producers. As an
	// example, SurfaceFlinger uses this to implement mixed GLES and HWC
	// compositing to the same buffer for virtual displays. If it used two separate
	// buffer queues, then in GLES-only or mixed GLES+HWC compositing, the HWC
	// would have to copy the GLES output buffer to the HWC output buffer, using
	// more bandwidth than having HWC do additional composition "in place" on the
	// GLES output buffer.
	//
	// The goal for this class is to be usable in a variety of situations and be
	// part of libgui. But both the interface and implementation need some
	// iteration before then, so for now it should only be used by
	// VirtualDisplaySurface, which is why it's currently in SurfaceFlinger.
	//
	// Some of the problems that still need to be solved are:
	//
	// - Refactor the interposer interface along with BufferQueue and ConsumerBase,
	// so that there is a common interface for the consumer end of a queue. The
	// existing interfaces have some problems when the implementation isn't the
	// final consumer.
	//
	// - The client of the interposer may need one or more buffers in addition to
	// those used by the source and sink. IGraphicBufferProducer will probably
	// need to change to allow the producer to specify how many buffers it needs
	// to dequeue at a time, and then the interposer can add its requirements to
	// those of the source.
	//
	// - Abandoning, disconnecting, and connecting need to pass through somehow.
	// There needs to be a way to tell the interposer client to release its
	// buffer immediately so it can be queued/released, e.g. when the source
	// calls disconnect().
	//
	// - Right now the source->BQI queue is synchronous even if the BQI->sink queue
	// is asynchronous. Need to figure out how asynchronous should behave and
	// implement that.

	class BufferQueueInterposer : public BnGraphicBufferProducer {
	public:
	BufferQueueInterposer(const sp<IGraphicBufferProducer>& sink,
	const String8& name);

	//
	// IGraphicBufferProducer interface
	//
	virtual status_t requestBuffer(int slot, sp<GraphicBuffer>* outBuf);
	virtual status_t setBufferCount(int bufferCount);
	virtual status_t dequeueBuffer(int* slot, sp<Fence>* fence,
	uint32_t w, uint32_t h, uint32_t format, uint32_t usage);
	virtual status_t queueBuffer(int slot,
	const QueueBufferInput& input, QueueBufferOutput* output);
	virtual void cancelBuffer(int slot, const sp<Fence>& fence);
	virtual int query(int what, int* value);
	virtual status_t setSynchronousMode(bool enabled);
	virtual status_t connect(int api, QueueBufferOutput* output);
	virtual status_t disconnect(int api);

	//
	// Interposer interface
	//

	enum {
	NO_BUFFER_AVAILABLE = 2, // matches BufferQueue
	BUFFER_NOT_ACQUIRED,
	BUFFER_ALREADY_ACQUIRED,
	};

	// Acquire the oldest queued buffer. If no buffers are pending, returns
	// NO_BUFFER_AVAILABLE. If a buffer is currently acquired, returns
	// BUFFER_ALREADY_ACQUIRED.
	status_t acquireBuffer(sp<GraphicBuffer>* buf, sp<Fence>* fence);

	// Release the currently acquired buffer, queueing it to the sink. If the
	// current buffer hasn't been acquired, returns BUFFER_NOT_ACQUIRED.
	status_t releaseBuffer(const sp<Fence>& fence);

	// pullEmptyBuffer dequeues a buffer from the sink, then immediately
	// queues it to the interposer. This makes a buffer available for the
	// client to acquire even if the source hasn't queued one.
	status_t pullEmptyBuffer();

	private:
	struct QueuedBuffer {
	QueuedBuffer(): slot(-1) {}
	QueuedBuffer(int slot, const QueueBufferInput& qbi): slot(slot) {
	qbi.deflate(&timestamp, &crop, &scalingMode, &transform, &fence);
	}
	int slot;
	int64_t timestamp;
	Rect crop;
	int scalingMode;
	uint32_t transform;
	sp<Fence> fence;
	};

	virtual ~BufferQueueInterposer();
	status_t flushQueuedBuffersLocked();

	const sp<IGraphicBufferProducer> mSink;
	String8 mName;

	Mutex mMutex;
	Vector<sp<GraphicBuffer> > mBuffers;
	Vector<QueuedBuffer> mQueue;
	bool mAcquired;
	QueueBufferOutput mQueueBufferOutput;
	};

	// ---------------------------------------------------------------------------
	} // namespace android
	// ---------------------------------------------------------------------------

	#endif // ANDROID_SF_BUFFERQUEUEINTERPOSER_H

services/surfaceflinger/DisplayHardware/HWComposer.cpp

+7 −3

Original line number	Original line	Diff line number	Diff line
	@@ -50,6 +50,10 @@

	namespace android {		namespace android {

			// This is not a real HWC version. It's used for in-development features that
			// haven't been committed to a specific real HWC version.
			#define HWC_DEVICE_API_VERSION_1_EXP HARDWARE_DEVICE_API_VERSION_2(1, 0xFF, HWC_HEADER_VERSION)

	#define MIN_HWC_HEADER_VERSION HWC_HEADER_VERSION		#define MIN_HWC_HEADER_VERSION HWC_HEADER_VERSION

	#define NUM_PHYSICAL_DISPLAYS HWC_NUM_DISPLAY_TYPES		#define NUM_PHYSICAL_DISPLAYS HWC_NUM_DISPLAY_TYPES
	@@ -152,8 +156,8 @@ HWComposer::HWComposer(

	// the number of displays we actually have depends on the		// the number of displays we actually have depends on the
	// hw composer version		// hw composer version
	if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_2)) {		if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_EXP)) {
	// 1.2 adds support for virtual displays		// 1.?? adds support for virtual displays
	mNumDisplays = MAX_DISPLAYS;		mNumDisplays = MAX_DISPLAYS;
	} else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {		} else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
	// 1.1 adds support for multiple displays		// 1.1 adds support for multiple displays
	@@ -581,7 +585,7 @@ status_t HWComposer::prepare() {
	}		}
	mLists[i] = disp.list;		mLists[i] = disp.list;
	if (mLists[i]) {		if (mLists[i]) {
	if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_2)) {		if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_EXP)) {
	mLists[i]->outbuf = NULL;		mLists[i]->outbuf = NULL;
	mLists[i]->outbufAcquireFenceFd = -1;		mLists[i]->outbufAcquireFenceFd = -1;
	} else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {		} else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {

services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp

+7 −67

Original line number	Original line	Diff line number	Diff line
	@@ -15,7 +15,9 @@
	*/		*/

	#include "VirtualDisplaySurface.h"		#include "VirtualDisplaySurface.h"
	#include "HWComposer.h"
			#include <cutils/log.h>
			#include <gui/IGraphicBufferProducer.h>

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------
	namespace android {		namespace android {
	@@ -23,28 +25,16 @@ namespace android {

	VirtualDisplaySurface::VirtualDisplaySurface(HWComposer& hwc, int32_t dispId,		VirtualDisplaySurface::VirtualDisplaySurface(HWComposer& hwc, int32_t dispId,
	const sp<IGraphicBufferProducer>& sink, const String8& name)		const sp<IGraphicBufferProducer>& sink, const String8& name)
	: mHwc(hwc),		: mSink(sink)
	mDisplayId(dispId),
	mName(name)
	{		{
	if (mDisplayId >= 0) {		LOG_ALWAYS_FATAL_IF(dispId >= 0);
	mInterposer = new BufferQueueInterposer(sink, name);
	mSourceProducer = mInterposer;
	} else {
	mSourceProducer = sink;
	}
	}		}

	VirtualDisplaySurface::~VirtualDisplaySurface() {		VirtualDisplaySurface::~VirtualDisplaySurface() {
	if (mAcquiredBuffer != NULL) {
	status_t result = mInterposer->releaseBuffer(Fence::NO_FENCE);
	ALOGE_IF(result != NO_ERROR, "VirtualDisplaySurface \"%s\": "
	"failed to release buffer: %d", mName.string(), result);
	}
	}		}

	sp<IGraphicBufferProducer> VirtualDisplaySurface::getIGraphicBufferProducer() const {		sp<IGraphicBufferProducer> VirtualDisplaySurface::getIGraphicBufferProducer() const {
	return mSourceProducer;		return mSink;
	}		}

	status_t VirtualDisplaySurface::compositionComplete() {		status_t VirtualDisplaySurface::compositionComplete() {
	@@ -52,60 +42,10 @@ status_t VirtualDisplaySurface::compositionComplete() {
	}		}

	status_t VirtualDisplaySurface::advanceFrame() {		status_t VirtualDisplaySurface::advanceFrame() {
	if (mInterposer == NULL)
	return NO_ERROR;		return NO_ERROR;

	Mutex::Autolock lock(mMutex);
	status_t result = NO_ERROR;

	if (mAcquiredBuffer != NULL) {
	ALOGE("VirtualDisplaySurface \"%s\": "
	"advanceFrame called twice without onFrameCommitted",
	mName.string());
	return INVALID_OPERATION;
	}

	sp<Fence> fence;
	result = mInterposer->acquireBuffer(&mAcquiredBuffer, &fence);
	if (result == BufferQueueInterposer::NO_BUFFER_AVAILABLE) {
	result = mInterposer->pullEmptyBuffer();
	if (result != NO_ERROR)
	return result;
	result = mInterposer->acquireBuffer(&mAcquiredBuffer, &fence);
	}
	if (result != NO_ERROR)
	return result;

	result = mHwc.fbPost(mDisplayId, fence, mAcquiredBuffer);
	if (result == NO_ERROR) {
	result = mHwc.setOutputBuffer(mDisplayId, fence, mAcquiredBuffer);
	}
	return result;
	}		}

	void VirtualDisplaySurface::onFrameCommitted() {		void VirtualDisplaySurface::onFrameCommitted() {
	if (mInterposer == NULL)
	return;

	Mutex::Autolock lock(mMutex);
	if (mAcquiredBuffer != NULL) {
	// fbFence signals when reads from the framebuffer are finished
	// outFence signals when writes to the output buffer are finished
	// It's unlikely that there will be an implementation where fbFence
	// signals after outFence (in fact they'll typically be the same
	// sync_pt), but just to be pedantic we merge them so the sink will
	// be sure to wait until both are complete.
	sp<Fence> fbFence = mHwc.getAndResetReleaseFence(mDisplayId);
	sp<Fence> outFence = mHwc.getLastRetireFence(mDisplayId);
	sp<Fence> fence = Fence::merge(
	String8::format("HWC done: %.21s", mName.string()),
	fbFence, outFence);

	status_t result = mInterposer->releaseBuffer(fence);
	ALOGE_IF(result != NO_ERROR, "VirtualDisplaySurface \"%s\": "
	"failed to release buffer: %d", mName.string(), result);
	mAcquiredBuffer.clear();
	}
	}		}

	void VirtualDisplaySurface::dump(String8& result) const {		void VirtualDisplaySurface::dump(String8& result) const {