Snap for 4498106 from f49c189d6b20a1c72d0079b418b7050e0a9a1ef2 to pi-release (b2b80cbb) · Commits · e / os / android_frameworks_native

libs/gui/BufferItemConsumer.cpp

+0 −10

Original line number	Original line	Diff line number	Diff line
	@@ -49,16 +49,6 @@ BufferItemConsumer::BufferItemConsumer(

	BufferItemConsumer::~BufferItemConsumer() {}		BufferItemConsumer::~BufferItemConsumer() {}

	void BufferItemConsumer::setName(const String8& name) {
	Mutex::Autolock _l(mMutex);
	if (mAbandoned) {
	BI_LOGE("setName: BufferItemConsumer is abandoned!");
	return;
	}
	mName = name;
	mConsumer->setConsumerName(name);
	}

	void BufferItemConsumer::setBufferFreedListener(		void BufferItemConsumer::setBufferFreedListener(
	const wp<BufferFreedListener>& listener) {		const wp<BufferFreedListener>& listener) {
	Mutex::Autolock _l(mMutex);		Mutex::Autolock _l(mMutex);

libs/gui/ConsumerBase.cpp

+54 −0

Original line number	Original line	Diff line number	Diff line
	@@ -182,6 +182,16 @@ bool ConsumerBase::isAbandoned() {
	return mAbandoned;		return mAbandoned;
	}		}

			void ConsumerBase::setName(const String8& name) {
			Mutex::Autolock _l(mMutex);
			if (mAbandoned) {
			CB_LOGE("setName: ConsumerBase is abandoned!");
			return;
			}
			mName = name;
			mConsumer->setConsumerName(name);
			}

	void ConsumerBase::setFrameAvailableListener(		void ConsumerBase::setFrameAvailableListener(
	const wp<FrameAvailableListener>& listener) {		const wp<FrameAvailableListener>& listener) {
	CB_LOGV("setFrameAvailableListener");		CB_LOGV("setFrameAvailableListener");
	@@ -237,6 +247,50 @@ status_t ConsumerBase::setDefaultBufferDataSpace(
	return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);		return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
	}		}

			status_t ConsumerBase::setConsumerUsageBits(uint64_t usage) {
			Mutex::Autolock lock(mMutex);
			if (mAbandoned) {
			CB_LOGE("setConsumerUsageBits: ConsumerBase is abandoned!");
			return NO_INIT;
			}
			return mConsumer->setConsumerUsageBits(usage);
			}

			status_t ConsumerBase::setTransformHint(uint32_t hint) {
			Mutex::Autolock lock(mMutex);
			if (mAbandoned) {
			CB_LOGE("setTransformHint: ConsumerBase is abandoned!");
			return NO_INIT;
			}
			return mConsumer->setTransformHint(hint);
			}

			status_t ConsumerBase::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
			Mutex::Autolock lock(mMutex);
			if (mAbandoned) {
			CB_LOGE("setMaxAcquiredBufferCount: ConsumerBase is abandoned!");
			return NO_INIT;
			}
			return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers);
			}

			sp<NativeHandle> ConsumerBase::getSidebandStream() const {
			Mutex::Autolock _l(mMutex);
			if (mAbandoned) {
			CB_LOGE("getSidebandStream: ConsumerBase is abandoned!");
			return nullptr;
			}

			sp<NativeHandle> stream;
			status_t err = mConsumer->getSidebandStream(&stream);
			if (err != NO_ERROR) {
			CB_LOGE("failed to get sideband stream: %d", err);
			return nullptr;
			}

			return stream;
			}

	status_t ConsumerBase::getOccupancyHistory(bool forceFlush,		status_t ConsumerBase::getOccupancyHistory(bool forceFlush,
	std::vector<OccupancyTracker::Segment>* outHistory) {		std::vector<OccupancyTracker::Segment>* outHistory) {
	Mutex::Autolock _l(mMutex);		Mutex::Autolock _l(mMutex);

libs/gui/CpuConsumer.cpp

+102 −139

Original line number	Original line	Diff line number	Diff line
	@@ -18,11 +18,11 @@
	#define LOG_TAG "CpuConsumer"		#define LOG_TAG "CpuConsumer"
	//#define ATRACE_TAG ATRACE_TAG_GRAPHICS		//#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include <cutils/compiler.h>
	#include <utils/Log.h>
	#include <gui/BufferItem.h>
	#include <gui/CpuConsumer.h>		#include <gui/CpuConsumer.h>

			#include <gui/BufferItem.h>
			#include <utils/Log.h>

	#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)		#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
	//#define CC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)		//#define CC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
	//#define CC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)		//#define CC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
	@@ -44,20 +44,19 @@ CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq,
	mConsumer->setMaxAcquiredBufferCount(static_cast<int32_t>(maxLockedBuffers));		mConsumer->setMaxAcquiredBufferCount(static_cast<int32_t>(maxLockedBuffers));
	}		}

	CpuConsumer::~CpuConsumer() {		size_t CpuConsumer::findAcquiredBufferLocked(uintptr_t id) const {
	// ConsumerBase destructor does all the work.		for (size_t i = 0; i < mMaxLockedBuffers; i++) {
			const auto& ab = mAcquiredBuffers[i];
			// note that this finds AcquiredBuffer::kUnusedId as well
			if (ab.mLockedBufferId == id) {
			return i;
	}		}



	void CpuConsumer::setName(const String8& name) {
	Mutex::Autolock _l(mMutex);
	if (mAbandoned) {
	CC_LOGE("setName: CpuConsumer is abandoned!");
	return;
	}		}
	mName = name;		return mMaxLockedBuffers; // an invalid index
	mConsumer->setConsumerName(name);		}

			static uintptr_t getLockedBufferId(const CpuConsumer::LockedBuffer& buffer) {
			return reinterpret_cast<uintptr_t>(buffer.data);
	}		}

	static bool isPossiblyYUV(PixelFormat format) {		static bool isPossiblyYUV(PixelFormat format) {
	@@ -88,10 +87,74 @@ static bool isPossiblyYUV(PixelFormat format) {
	}		}
	}		}

			status_t CpuConsumer::lockBufferItem(const BufferItem& item, LockedBuffer* outBuffer) const {
			android_ycbcr ycbcr = android_ycbcr();

			PixelFormat format = item.mGraphicBuffer->getPixelFormat();
			PixelFormat flexFormat = format;
			if (isPossiblyYUV(format)) {
			int fenceFd = item.mFence.get() ? item.mFence->dup() : -1;
			status_t err = item.mGraphicBuffer->lockAsyncYCbCr(GraphicBuffer::USAGE_SW_READ_OFTEN,
			item.mCrop, &ycbcr, fenceFd);
			if (err == OK) {
			flexFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;
			if (format != HAL_PIXEL_FORMAT_YCbCr_420_888) {
			CC_LOGV("locking buffer of format %#x as flex YUV", format);
			}
			} else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
			CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)", strerror(-err), err);
			return err;
			}
			}

			if (ycbcr.y != nullptr) {
			outBuffer->data = reinterpret_cast<uint8_t*>(ycbcr.y);
			outBuffer->stride = static_cast<uint32_t>(ycbcr.ystride);
			outBuffer->dataCb = reinterpret_cast<uint8_t*>(ycbcr.cb);
			outBuffer->dataCr = reinterpret_cast<uint8_t*>(ycbcr.cr);
			outBuffer->chromaStride = static_cast<uint32_t>(ycbcr.cstride);
			outBuffer->chromaStep = static_cast<uint32_t>(ycbcr.chroma_step);
			} else {
			// not flexible YUV; try lockAsync
			void* bufferPointer = nullptr;
			int fenceFd = item.mFence.get() ? item.mFence->dup() : -1;
			status_t err = item.mGraphicBuffer->lockAsync(GraphicBuffer::USAGE_SW_READ_OFTEN,
			item.mCrop, &bufferPointer, fenceFd);
			if (err != OK) {
			CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)", strerror(-err), err);
			return err;
			}

			outBuffer->data = reinterpret_cast<uint8_t*>(bufferPointer);
			outBuffer->stride = item.mGraphicBuffer->getStride();
			outBuffer->dataCb = nullptr;
			outBuffer->dataCr = nullptr;
			outBuffer->chromaStride = 0;
			outBuffer->chromaStep = 0;
			}

			outBuffer->width = item.mGraphicBuffer->getWidth();
			outBuffer->height = item.mGraphicBuffer->getHeight();
			outBuffer->format = format;
			outBuffer->flexFormat = flexFormat;

			outBuffer->crop = item.mCrop;
			outBuffer->transform = item.mTransform;
			outBuffer->scalingMode = item.mScalingMode;
			outBuffer->timestamp = item.mTimestamp;
			outBuffer->dataSpace = item.mDataSpace;
			outBuffer->frameNumber = item.mFrameNumber;

			return OK;
			}

	status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {		status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
	status_t err;		status_t err;

	if (!nativeBuffer) return BAD_VALUE;		if (!nativeBuffer) return BAD_VALUE;

			Mutex::Autolock _l(mMutex);

	if (mCurrentLockedBuffers == mMaxLockedBuffers) {		if (mCurrentLockedBuffers == mMaxLockedBuffers) {
	CC_LOGW("Max buffers have been locked (%zd), cannot lock anymore.",		CC_LOGW("Max buffers have been locked (%zd), cannot lock anymore.",
	mMaxLockedBuffers);		mMaxLockedBuffers);
	@@ -99,9 +162,6 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
	}		}

	BufferItem b;		BufferItem b;

	Mutex::Autolock _l(mMutex);

	err = acquireBufferLocked(&b, 0);		err = acquireBufferLocked(&b, 0);
	if (err != OK) {		if (err != OK) {
	if (err == BufferQueue::NO_BUFFER_AVAILABLE) {		if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
	@@ -112,94 +172,23 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
	}		}
	}		}

	int slot = b.mSlot;		if (b.mGraphicBuffer == nullptr) {
			b.mGraphicBuffer = mSlots[b.mSlot].mGraphicBuffer;
	void *bufferPointer = NULL;
	android_ycbcr ycbcr = android_ycbcr();

	PixelFormat format = mSlots[slot].mGraphicBuffer->getPixelFormat();
	PixelFormat flexFormat = format;
	if (isPossiblyYUV(format)) {
	if (b.mFence.get()) {
	err = mSlots[slot].mGraphicBuffer->lockAsyncYCbCr(
	GraphicBuffer::USAGE_SW_READ_OFTEN,
	b.mCrop,
	&ycbcr,
	b.mFence->dup());
	} else {
	err = mSlots[slot].mGraphicBuffer->lockYCbCr(
	GraphicBuffer::USAGE_SW_READ_OFTEN,
	b.mCrop,
	&ycbcr);
	}
	if (err == OK) {
	bufferPointer = ycbcr.y;
	flexFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;
	if (format != HAL_PIXEL_FORMAT_YCbCr_420_888) {
	CC_LOGV("locking buffer of format %#x as flex YUV", format);
	}
	} else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
	CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)",
	strerror(-err), err);
	return err;
	}
	}		}

	if (bufferPointer == NULL) { // not flexible YUV		err = lockBufferItem(b, nativeBuffer);
	if (b.mFence.get()) {
	err = mSlots[slot].mGraphicBuffer->lockAsync(
	GraphicBuffer::USAGE_SW_READ_OFTEN,
	b.mCrop,
	&bufferPointer,
	b.mFence->dup());
	} else {
	err = mSlots[slot].mGraphicBuffer->lock(
	GraphicBuffer::USAGE_SW_READ_OFTEN,
	b.mCrop,
	&bufferPointer);
	}
	if (err != OK) {		if (err != OK) {
	CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)",
	strerror(-err), err);
	return err;		return err;
	}		}
	}

	size_t lockedIdx = 0;
	for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {
	if (mAcquiredBuffers[lockedIdx].mSlot ==
	BufferQueue::INVALID_BUFFER_SLOT) {
	break;
	}
	}
	assert(lockedIdx < mMaxLockedBuffers);

			// find an unused AcquiredBuffer
			size_t lockedIdx = findAcquiredBufferLocked(AcquiredBuffer::kUnusedId);
			ALOG_ASSERT(lockedIdx < mMaxLockedBuffers);
	AcquiredBuffer& ab = mAcquiredBuffers.editItemAt(lockedIdx);		AcquiredBuffer& ab = mAcquiredBuffers.editItemAt(lockedIdx);
	ab.mSlot = slot;
	ab.mBufferPointer = bufferPointer;		ab.mSlot = b.mSlot;
	ab.mGraphicBuffer = mSlots[slot].mGraphicBuffer;		ab.mGraphicBuffer = b.mGraphicBuffer;
			ab.mLockedBufferId = getLockedBufferId(*nativeBuffer);
	nativeBuffer->data =
	reinterpret_cast<uint8_t*>(bufferPointer);
	nativeBuffer->width = mSlots[slot].mGraphicBuffer->getWidth();
	nativeBuffer->height = mSlots[slot].mGraphicBuffer->getHeight();
	nativeBuffer->format = format;
	nativeBuffer->flexFormat = flexFormat;
	nativeBuffer->stride = (ycbcr.y != NULL) ?
	static_cast<uint32_t>(ycbcr.ystride) :
	mSlots[slot].mGraphicBuffer->getStride();

	nativeBuffer->crop = b.mCrop;
	nativeBuffer->transform = b.mTransform;
	nativeBuffer->scalingMode = b.mScalingMode;
	nativeBuffer->timestamp = b.mTimestamp;
	nativeBuffer->dataSpace = b.mDataSpace;
	nativeBuffer->frameNumber = b.mFrameNumber;

	nativeBuffer->dataCb = reinterpret_cast<uint8_t*>(ycbcr.cb);
	nativeBuffer->dataCr = reinterpret_cast<uint8_t*>(ycbcr.cr);
	nativeBuffer->chromaStride = static_cast<uint32_t>(ycbcr.cstride);
	nativeBuffer->chromaStep = static_cast<uint32_t>(ycbcr.chroma_step);

	mCurrentLockedBuffers++;		mCurrentLockedBuffers++;

	@@ -208,60 +197,34 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {

	status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) {		status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) {
	Mutex::Autolock _l(mMutex);		Mutex::Autolock _l(mMutex);
	size_t lockedIdx = 0;

	void bufPtr = reinterpret_cast<void >(nativeBuffer.data);		uintptr_t id = getLockedBufferId(nativeBuffer);
	for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {		size_t lockedIdx =
	if (bufPtr == mAcquiredBuffers[lockedIdx].mBufferPointer) break;		(id != AcquiredBuffer::kUnusedId) ? findAcquiredBufferLocked(id) : mMaxLockedBuffers;
	}
	if (lockedIdx == mMaxLockedBuffers) {		if (lockedIdx == mMaxLockedBuffers) {
	CC_LOGE("%s: Can't find buffer to free", __FUNCTION__);		CC_LOGE("%s: Can't find buffer to free", __FUNCTION__);
	return BAD_VALUE;		return BAD_VALUE;
	}		}

	return releaseAcquiredBufferLocked(lockedIdx);		AcquiredBuffer& ab = mAcquiredBuffers.editItemAt(lockedIdx);
	}

	status_t CpuConsumer::releaseAcquiredBufferLocked(size_t lockedIdx) {
	status_t err;
	int fd = -1;

	err = mAcquiredBuffers[lockedIdx].mGraphicBuffer->unlockAsync(&fd);		int fenceFd = -1;
			status_t err = ab.mGraphicBuffer->unlockAsync(&fenceFd);
	if (err != OK) {		if (err != OK) {
	CC_LOGE("%s: Unable to unlock graphic buffer %zd", __FUNCTION__,		CC_LOGE("%s: Unable to unlock graphic buffer %zd", __FUNCTION__,
	lockedIdx);		lockedIdx);
	return err;		return err;
	}		}
	int buf = mAcquiredBuffers[lockedIdx].mSlot;
	if (CC_LIKELY(fd != -1)) {
	sp<Fence> fence(new Fence(fd));
	addReleaseFenceLocked(
	mAcquiredBuffers[lockedIdx].mSlot,
	mSlots[buf].mGraphicBuffer,
	fence);
	}

	// release the buffer if it hasn't already been freed by the BufferQueue.		sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
	// This can happen, for example, when the producer of this buffer		addReleaseFenceLocked(ab.mSlot, ab.mGraphicBuffer, fence);
	// disconnected after this buffer was acquired.		releaseBufferLocked(ab.mSlot, ab.mGraphicBuffer);
	if (CC_LIKELY(mAcquiredBuffers[lockedIdx].mGraphicBuffer ==
	mSlots[buf].mGraphicBuffer)) {
	releaseBufferLocked(
	buf, mAcquiredBuffers[lockedIdx].mGraphicBuffer,
	EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
	}

	AcquiredBuffer &ab = mAcquiredBuffers.editItemAt(lockedIdx);		ab.reset();
	ab.mSlot = BufferQueue::INVALID_BUFFER_SLOT;
	ab.mBufferPointer = NULL;
	ab.mGraphicBuffer.clear();

	mCurrentLockedBuffers--;		mCurrentLockedBuffers--;
	return OK;
	}

	void CpuConsumer::freeBufferLocked(int slotIndex) {		return OK;
	ConsumerBase::freeBufferLocked(slotIndex);
	}		}

	} // namespace android		} // namespace android

libs/gui/GLConsumer.cpp

+81 −199

Original line number	Original line	Diff line number	Diff line
	@@ -31,6 +31,8 @@

	#include <hardware/hardware.h>		#include <hardware/hardware.h>

			#include <math/mat4.h>

	#include <gui/BufferItem.h>		#include <gui/BufferItem.h>
	#include <gui/GLConsumer.h>		#include <gui/GLConsumer.h>
	#include <gui/ISurfaceComposer.h>		#include <gui/ISurfaceComposer.h>
	@@ -75,33 +77,7 @@ static const struct {
	"_______________"		"_______________"
	};		};

	// Transform matrices		static const mat4 mtxIdentity;
	static float mtxIdentity[16] = {
	1, 0, 0, 0,
	0, 1, 0, 0,
	0, 0, 1, 0,
	0, 0, 0, 1,
	};
	static float mtxFlipH[16] = {
	-1, 0, 0, 0,
	0, 1, 0, 0,
	0, 0, 1, 0,
	1, 0, 0, 1,
	};
	static float mtxFlipV[16] = {
	1, 0, 0, 0,
	0, -1, 0, 0,
	0, 0, 1, 0,
	0, 1, 0, 1,
	};
	static float mtxRot90[16] = {
	0, 1, 0, 0,
	-1, 0, 0, 0,
	0, 0, 1, 0,
	1, 0, 0, 1,
	};

	static void mtxMul(float out[16], const float a[16], const float b[16]);

	Mutex GLConsumer::sStaticInitLock;		Mutex GLConsumer::sStaticInitLock;
	sp<GraphicBuffer> GLConsumer::sReleasedTexImageBuffer;		sp<GraphicBuffer> GLConsumer::sReleasedTexImageBuffer;
	@@ -173,7 +149,7 @@ GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t tex,
	{		{
	GLC_LOGV("GLConsumer");		GLC_LOGV("GLConsumer");

	memcpy(mCurrentTransformMatrix, mtxIdentity,		memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(),
	sizeof(mCurrentTransformMatrix));		sizeof(mCurrentTransformMatrix));

	mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);		mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
	@@ -202,7 +178,7 @@ GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t texTarget,
	{		{
	GLC_LOGV("GLConsumer");		GLC_LOGV("GLConsumer");

	memcpy(mCurrentTransformMatrix, mtxIdentity,		memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(),
	sizeof(mCurrentTransformMatrix));		sizeof(mCurrentTransformMatrix));

	mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);		mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
	@@ -758,25 +734,6 @@ status_t GLConsumer::syncForReleaseLocked(EGLDisplay dpy) {
	return OK;		return OK;
	}		}

	bool GLConsumer::isExternalFormat(PixelFormat format)
	{
	switch (format) {
	// supported YUV formats
	case HAL_PIXEL_FORMAT_YV12:
	// Legacy/deprecated YUV formats
	case HAL_PIXEL_FORMAT_YCbCr_422_SP:
	case HAL_PIXEL_FORMAT_YCrCb_420_SP:
	case HAL_PIXEL_FORMAT_YCbCr_422_I:
	return true;
	}

	// Any OEM format needs to be considered
	if (format>=0x100 && format<=0x1FF)
	return true;

	return false;
	}

	uint32_t GLConsumer::getCurrentTextureTarget() const {		uint32_t GLConsumer::getCurrentTextureTarget() const {
	return mTexTarget;		return mTexTarget;
	}		}
	@@ -820,34 +777,37 @@ void GLConsumer::computeCurrentTransformMatrixLocked() {
	void GLConsumer::computeTransformMatrix(float outTransform[16],		void GLConsumer::computeTransformMatrix(float outTransform[16],
	const sp<GraphicBuffer>& buf, const Rect& cropRect, uint32_t transform,		const sp<GraphicBuffer>& buf, const Rect& cropRect, uint32_t transform,
	bool filtering) {		bool filtering) {
			// Transform matrices
			static const mat4 mtxFlipH(
			-1, 0, 0, 0,
			0, 1, 0, 0,
			0, 0, 1, 0,
			1, 0, 0, 1
			);
			static const mat4 mtxFlipV(
			1, 0, 0, 0,
			0, -1, 0, 0,
			0, 0, 1, 0,
			0, 1, 0, 1
			);
			static const mat4 mtxRot90(
			0, 1, 0, 0,
			-1, 0, 0, 0,
			0, 0, 1, 0,
			1, 0, 0, 1
			);

	float xform[16];		mat4 xform;
	for (int i = 0; i < 16; i++) {
	xform[i] = mtxIdentity[i];
	}
	if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) {		if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) {
	float result[16];		xform *= mtxFlipH;
	mtxMul(result, xform, mtxFlipH);
	for (int i = 0; i < 16; i++) {
	xform[i] = result[i];
	}
	}		}
	if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) {		if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) {
	float result[16];		xform *= mtxFlipV;
	mtxMul(result, xform, mtxFlipV);
	for (int i = 0; i < 16; i++) {
	xform[i] = result[i];
	}
	}		}
	if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) {		if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
	float result[16];		xform *= mtxRot90;
	mtxMul(result, xform, mtxRot90);
	for (int i = 0; i < 16; i++) {
	xform[i] = result[i];
	}
	}		}

	float mtxBeforeFlipV[16];
	if (!cropRect.isEmpty()) {		if (!cropRect.isEmpty()) {
	float tx = 0.0f, ty = 0.0f, sx = 1.0f, sy = 1.0f;		float tx = 0.0f, ty = 0.0f, sx = 1.0f, sy = 1.0f;
	float bufferWidth = buf->getWidth();		float bufferWidth = buf->getWidth();
	@@ -893,25 +853,63 @@ void GLConsumer::computeTransformMatrix(float outTransform[16],
	sy = (float(cropRect.height()) - (2.0f * shrinkAmount)) /		sy = (float(cropRect.height()) - (2.0f * shrinkAmount)) /
	bufferHeight;		bufferHeight;
	}		}
	float crop[16] = {
			mat4 crop(
	sx, 0, 0, 0,		sx, 0, 0, 0,
	0, sy, 0, 0,		0, sy, 0, 0,
	0, 0, 1, 0,		0, 0, 1, 0,
	tx, ty, 0, 1,		tx, ty, 0, 1
	};		);
			xform = crop * xform;
	mtxMul(mtxBeforeFlipV, crop, xform);
	} else {
	for (int i = 0; i < 16; i++) {
	mtxBeforeFlipV[i] = xform[i];
	}
	}		}

	// SurfaceFlinger expects the top of its window textures to be at a Y		// SurfaceFlinger expects the top of its window textures to be at a Y
	// coordinate of 0, so GLConsumer must behave the same way. We don't		// coordinate of 0, so GLConsumer must behave the same way. We don't
	// want to expose this to applications, however, so we must add an		// want to expose this to applications, however, so we must add an
	// additional vertical flip to the transform after all the other transforms.		// additional vertical flip to the transform after all the other transforms.
	mtxMul(outTransform, mtxFlipV, mtxBeforeFlipV);		xform = mtxFlipV * xform;

			memcpy(outTransform, xform.asArray(), sizeof(xform));
			}

			Rect GLConsumer::scaleDownCrop(const Rect& crop, uint32_t bufferWidth, uint32_t bufferHeight) {
			Rect outCrop = crop;

			uint32_t newWidth = static_cast<uint32_t>(crop.width());
			uint32_t newHeight = static_cast<uint32_t>(crop.height());

			if (newWidth * bufferHeight > newHeight * bufferWidth) {
			newWidth = newHeight * bufferWidth / bufferHeight;
			ALOGV("too wide: newWidth = %d", newWidth);
			} else if (newWidth * bufferHeight < newHeight * bufferWidth) {
			newHeight = newWidth * bufferHeight / bufferWidth;
			ALOGV("too tall: newHeight = %d", newHeight);
			}

			uint32_t currentWidth = static_cast<uint32_t>(crop.width());
			uint32_t currentHeight = static_cast<uint32_t>(crop.height());

			// The crop is too wide
			if (newWidth < currentWidth) {
			uint32_t dw = currentWidth - newWidth;
			auto halfdw = dw / 2;
			outCrop.left += halfdw;
			// Not halfdw because it would subtract 1 too few when dw is odd
			outCrop.right -= (dw - halfdw);
			// The crop is too tall
			} else if (newHeight < currentHeight) {
			uint32_t dh = currentHeight - newHeight;
			auto halfdh = dh / 2;
			outCrop.top += halfdh;
			// Not halfdh because it would subtract 1 too few when dh is odd
			outCrop.bottom -= (dh - halfdh);
			}

			ALOGV("getCurrentCrop final crop [%d,%d,%d,%d]",
			outCrop.left, outCrop.top,
			outCrop.right,outCrop.bottom);

			return outCrop;
	}		}

	nsecs_t GLConsumer::getTimestamp() {		nsecs_t GLConsumer::getTimestamp() {
	@@ -945,45 +943,9 @@ sp<GraphicBuffer> GLConsumer::getCurrentBuffer(int* outSlot) const {

	Rect GLConsumer::getCurrentCrop() const {		Rect GLConsumer::getCurrentCrop() const {
	Mutex::Autolock lock(mMutex);		Mutex::Autolock lock(mMutex);
			return (mCurrentScalingMode == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP)
	Rect outCrop = mCurrentCrop;		? scaleDownCrop(mCurrentCrop, mDefaultWidth, mDefaultHeight)
	if (mCurrentScalingMode == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP) {		: mCurrentCrop;
	uint32_t newWidth = static_cast<uint32_t>(mCurrentCrop.width());
	uint32_t newHeight = static_cast<uint32_t>(mCurrentCrop.height());

	if (newWidth * mDefaultHeight > newHeight * mDefaultWidth) {
	newWidth = newHeight * mDefaultWidth / mDefaultHeight;
	GLC_LOGV("too wide: newWidth = %d", newWidth);
	} else if (newWidth * mDefaultHeight < newHeight * mDefaultWidth) {
	newHeight = newWidth * mDefaultHeight / mDefaultWidth;
	GLC_LOGV("too tall: newHeight = %d", newHeight);
	}

	uint32_t currentWidth = static_cast<uint32_t>(mCurrentCrop.width());
	uint32_t currentHeight = static_cast<uint32_t>(mCurrentCrop.height());

	// The crop is too wide
	if (newWidth < currentWidth) {
	uint32_t dw = currentWidth - newWidth;
	auto halfdw = dw / 2;
	outCrop.left += halfdw;
	// Not halfdw because it would subtract 1 too few when dw is odd
	outCrop.right -= (dw - halfdw);
	// The crop is too tall
	} else if (newHeight < currentHeight) {
	uint32_t dh = currentHeight - newHeight;
	auto halfdh = dh / 2;
	outCrop.top += halfdh;
	// Not halfdh because it would subtract 1 too few when dh is odd
	outCrop.bottom -= (dh - halfdh);
	}

	GLC_LOGV("getCurrentCrop final crop [%d,%d,%d,%d]",
	outCrop.left, outCrop.top,
	outCrop.right,outCrop.bottom);
	}

	return outCrop;
	}		}

	uint32_t GLConsumer::getCurrentTransform() const {		uint32_t GLConsumer::getCurrentTransform() const {
	@@ -1006,11 +968,6 @@ std::shared_ptr<FenceTime> GLConsumer::getCurrentFenceTime() const {
	return mCurrentFenceTime;		return mCurrentFenceTime;
	}		}

	status_t GLConsumer::doGLFenceWait() const {
	Mutex::Autolock lock(mMutex);
	return doGLFenceWaitLocked();
	}

	status_t GLConsumer::doGLFenceWaitLocked() const {		status_t GLConsumer::doGLFenceWaitLocked() const {

	EGLDisplay dpy = eglGetCurrentDisplay();		EGLDisplay dpy = eglGetCurrentDisplay();
	@@ -1086,61 +1043,8 @@ void GLConsumer::abandonLocked() {
	ConsumerBase::abandonLocked();		ConsumerBase::abandonLocked();
	}		}

	void GLConsumer::setName(const String8& name) {
	Mutex::Autolock _l(mMutex);
	if (mAbandoned) {
	GLC_LOGE("setName: GLConsumer is abandoned!");
	return;
	}
	mName = name;
	mConsumer->setConsumerName(name);
	}

	status_t GLConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) {
	Mutex::Autolock lock(mMutex);
	if (mAbandoned) {
	GLC_LOGE("setDefaultBufferFormat: GLConsumer is abandoned!");
	return NO_INIT;
	}
	return mConsumer->setDefaultBufferFormat(defaultFormat);
	}

	status_t GLConsumer::setDefaultBufferDataSpace(
	android_dataspace defaultDataSpace) {
	Mutex::Autolock lock(mMutex);
	if (mAbandoned) {
	GLC_LOGE("setDefaultBufferDataSpace: GLConsumer is abandoned!");
	return NO_INIT;
	}
	return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
	}

	status_t GLConsumer::setConsumerUsageBits(uint64_t usage) {		status_t GLConsumer::setConsumerUsageBits(uint64_t usage) {
	Mutex::Autolock lock(mMutex);		return ConsumerBase::setConsumerUsageBits(usage \| DEFAULT_USAGE_FLAGS);
	if (mAbandoned) {
	GLC_LOGE("setConsumerUsageBits: GLConsumer is abandoned!");
	return NO_INIT;
	}
	usage \|= DEFAULT_USAGE_FLAGS;
	return mConsumer->setConsumerUsageBits(usage);
	}

	status_t GLConsumer::setTransformHint(uint32_t hint) {
	Mutex::Autolock lock(mMutex);
	if (mAbandoned) {
	GLC_LOGE("setTransformHint: GLConsumer is abandoned!");
	return NO_INIT;
	}
	return mConsumer->setTransformHint(hint);
	}

	status_t GLConsumer::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
	Mutex::Autolock lock(mMutex);
	if (mAbandoned) {
	GLC_LOGE("setMaxAcquiredBufferCount: GLConsumer is abandoned!");
	return NO_INIT;
	}
	return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers);
	}		}

	void GLConsumer::dumpLocked(String8& result, const char* prefix) const		void GLConsumer::dumpLocked(String8& result, const char* prefix) const
	@@ -1155,28 +1059,6 @@ void GLConsumer::dumpLocked(String8& result, const char* prefix) const
	ConsumerBase::dumpLocked(result, prefix);		ConsumerBase::dumpLocked(result, prefix);
	}		}

	static void mtxMul(float out[16], const float a[16], const float b[16]) {
	out[0] = a[0]b[0] + a[4]b[1] + a[8]b[2] + a[12]b[3];
	out[1] = a[1]b[0] + a[5]b[1] + a[9]b[2] + a[13]b[3];
	out[2] = a[2]b[0] + a[6]b[1] + a[10]b[2] + a[14]b[3];
	out[3] = a[3]b[0] + a[7]b[1] + a[11]b[2] + a[15]b[3];

	out[4] = a[0]b[4] + a[4]b[5] + a[8]b[6] + a[12]b[7];
	out[5] = a[1]b[4] + a[5]b[5] + a[9]b[6] + a[13]b[7];
	out[6] = a[2]b[4] + a[6]b[5] + a[10]b[6] + a[14]b[7];
	out[7] = a[3]b[4] + a[7]b[5] + a[11]b[6] + a[15]b[7];

	out[8] = a[0]b[8] + a[4]b[9] + a[8]b[10] + a[12]b[11];
	out[9] = a[1]b[8] + a[5]b[9] + a[9]b[10] + a[13]b[11];
	out[10] = a[2]b[8] + a[6]b[9] + a[10]b[10] + a[14]b[11];
	out[11] = a[3]b[8] + a[7]b[9] + a[11]b[10] + a[15]b[11];

	out[12] = a[0]b[12] + a[4]b[13] + a[8]b[14] + a[12]b[15];
	out[13] = a[1]b[12] + a[5]b[13] + a[9]b[14] + a[13]b[15];
	out[14] = a[2]b[12] + a[6]b[13] + a[10]b[14] + a[14]b[15];
	out[15] = a[3]b[12] + a[7]b[13] + a[11]b[14] + a[15]b[15];
	}

	GLConsumer::EglImage::EglImage(sp<GraphicBuffer> graphicBuffer) :		GLConsumer::EglImage::EglImage(sp<GraphicBuffer> graphicBuffer) :
	mGraphicBuffer(graphicBuffer),		mGraphicBuffer(graphicBuffer),
	mEglImage(EGL_NO_IMAGE_KHR),		mEglImage(EGL_NO_IMAGE_KHR),

libs/gui/include/gui/BufferItemConsumer.h

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -57,10 +57,6 @@ class BufferItemConsumer: public ConsumerBase

	~BufferItemConsumer() override;		~BufferItemConsumer() override;

	// set the name of the BufferItemConsumer that will be used to identify it in
	// log messages.
	void setName(const String8& name);

	// setBufferFreedListener sets the listener object that will be notified		// setBufferFreedListener sets the listener object that will be notified
	// when an old buffer is being freed.		// when an old buffer is being freed.
	void setBufferFreedListener(const wp<BufferFreedListener>& listener);		void setBufferFreedListener(const wp<BufferFreedListener>& listener);