Merge changes from topic "blast" (b1a4e00a) · Commits · e / os / android_frameworks_native-old

cmds/surfacereplayer/replayer/Replayer.cpp

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -489,7 +489,7 @@ void Replayer::setCrop(SurfaceComposerClient::Transaction& t,

	Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),		Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),
	cc.rectangle().bottom());		cc.rectangle().bottom());
	t.setCrop(mLayers[id], r);		t.setCrop_legacy(mLayers[id], r);
	}		}

	void Replayer::setFinalCrop(SurfaceComposerClient::Transaction& t,		void Replayer::setFinalCrop(SurfaceComposerClient::Transaction& t,
	@@ -499,7 +499,7 @@ void Replayer::setFinalCrop(SurfaceComposerClient::Transaction& t,
	fcc.rectangle().bottom());		fcc.rectangle().bottom());
	Rect r = Rect(fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),		Rect r = Rect(fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),
	fcc.rectangle().bottom());		fcc.rectangle().bottom());
	t.setFinalCrop(mLayers[id], r);		t.setFinalCrop_legacy(mLayers[id], r);
	}		}

	void Replayer::setMatrix(SurfaceComposerClient::Transaction& t,		void Replayer::setMatrix(SurfaceComposerClient::Transaction& t,
	@@ -570,7 +570,7 @@ void Replayer::setDeferredTransaction(SurfaceComposerClient::Transaction& t,

	auto handle = mLayers[dtc.layer_id()]->getHandle();		auto handle = mLayers[dtc.layer_id()]->getHandle();

	t.deferTransactionUntil(mLayers[id], handle, dtc.frame_number());		t.deferTransactionUntil_legacy(mLayers[id], handle, dtc.frame_number());
	}		}

	void Replayer::setDisplaySurface(SurfaceComposerClient::Transaction& t,		void Replayer::setDisplaySurface(SurfaceComposerClient::Transaction& t,

libs/gui/LayerState.cpp

+106 −22

Original line number	Original line	Diff line number	Diff line
	@@ -37,19 +37,45 @@ status_t layer_state_t::write(Parcel& output) const
	output.writeUint32(mask);		output.writeUint32(mask);
	reinterpret_cast<layer_state_t::matrix22_t >(		reinterpret_cast<layer_state_t::matrix22_t >(
	output.writeInplace(sizeof(layer_state_t::matrix22_t))) = matrix;		output.writeInplace(sizeof(layer_state_t::matrix22_t))) = matrix;
	output.write(crop);		output.write(crop_legacy);
	output.write(finalCrop);		output.write(finalCrop_legacy);
	output.writeStrongBinder(barrierHandle);		output.writeStrongBinder(barrierHandle_legacy);
	output.writeStrongBinder(reparentHandle);		output.writeStrongBinder(reparentHandle);
	output.writeUint64(frameNumber);		output.writeUint64(frameNumber_legacy);
	output.writeInt32(overrideScalingMode);		output.writeInt32(overrideScalingMode);
	output.writeStrongBinder(IInterface::asBinder(barrierGbp));		output.writeStrongBinder(IInterface::asBinder(barrierGbp_legacy));
	output.writeStrongBinder(relativeLayerHandle);		output.writeStrongBinder(relativeLayerHandle);
	output.writeStrongBinder(parentHandleForChild);		output.writeStrongBinder(parentHandleForChild);
	output.writeFloat(color.r);		output.writeFloat(color.r);
	output.writeFloat(color.g);		output.writeFloat(color.g);
	output.writeFloat(color.b);		output.writeFloat(color.b);
	output.write(transparentRegion);		output.write(transparentRegion);
			output.writeUint32(transform);
			output.writeBool(transformToDisplayInverse);
			output.write(crop);
			if (buffer) {
			output.writeBool(true);
			output.write(*buffer);
			} else {
			output.writeBool(false);
			}
			if (acquireFence) {
			output.writeBool(true);
			output.write(*acquireFence);
			} else {
			output.writeBool(false);
			}
			output.writeUint32(static_cast<uint32_t>(dataspace));
			output.write(hdrMetadata);
			output.write(surfaceDamageRegion);
			output.writeInt32(api);
			if (sidebandStream) {
			output.writeBool(true);
			output.writeNativeHandle(sidebandStream->handle());
			} else {
			output.writeBool(false);
			}

	return NO_ERROR;		return NO_ERROR;
	}		}

	@@ -72,20 +98,38 @@ status_t layer_state_t::read(const Parcel& input)
	} else {		} else {
	return BAD_VALUE;		return BAD_VALUE;
	}		}
	input.read(crop);		input.read(crop_legacy);
	input.read(finalCrop);		input.read(finalCrop_legacy);
	barrierHandle = input.readStrongBinder();		barrierHandle_legacy = input.readStrongBinder();
	reparentHandle = input.readStrongBinder();		reparentHandle = input.readStrongBinder();
	frameNumber = input.readUint64();		frameNumber_legacy = input.readUint64();
	overrideScalingMode = input.readInt32();		overrideScalingMode = input.readInt32();
	barrierGbp =		barrierGbp_legacy = interface_cast<IGraphicBufferProducer>(input.readStrongBinder());
	interface_cast<IGraphicBufferProducer>(input.readStrongBinder());
	relativeLayerHandle = input.readStrongBinder();		relativeLayerHandle = input.readStrongBinder();
	parentHandleForChild = input.readStrongBinder();		parentHandleForChild = input.readStrongBinder();
	color.r = input.readFloat();		color.r = input.readFloat();
	color.g = input.readFloat();		color.g = input.readFloat();
	color.b = input.readFloat();		color.b = input.readFloat();
	input.read(transparentRegion);		input.read(transparentRegion);
			transform = input.readUint32();
			transformToDisplayInverse = input.readBool();
			input.read(crop);
			buffer = new GraphicBuffer();
			if (input.readBool()) {
			input.read(*buffer);
			}
			acquireFence = new Fence();
			if (input.readBool()) {
			input.read(*acquireFence);
			}
			dataspace = static_cast<ui::Dataspace>(input.readUint32());
			input.read(hdrMetadata);
			input.read(surfaceDamageRegion);
			api = input.readInt32();
			if (input.readBool()) {
			sidebandStream = NativeHandle::create(input.readNativeHandle(), true);
			}

	return NO_ERROR;		return NO_ERROR;
	}		}

	@@ -194,19 +238,19 @@ void layer_state_t::merge(const layer_state_t& other) {
	what \|= eLayerStackChanged;		what \|= eLayerStackChanged;
	layerStack = other.layerStack;		layerStack = other.layerStack;
	}		}
	if (other.what & eCropChanged) {		if (other.what & eCropChanged_legacy) {
	what \|= eCropChanged;		what \|= eCropChanged_legacy;
	crop = other.crop;		crop_legacy = other.crop_legacy;
	}		}
	if (other.what & eDeferTransaction) {		if (other.what & eDeferTransaction_legacy) {
	what \|= eDeferTransaction;		what \|= eDeferTransaction_legacy;
	barrierHandle = other.barrierHandle;		barrierHandle_legacy = other.barrierHandle_legacy;
	barrierGbp = other.barrierGbp;		barrierGbp_legacy = other.barrierGbp_legacy;
	frameNumber = other.frameNumber;		frameNumber_legacy = other.frameNumber_legacy;
	}		}
	if (other.what & eFinalCropChanged) {		if (other.what & eFinalCropChanged_legacy) {
	what \|= eFinalCropChanged;		what \|= eFinalCropChanged_legacy;
	finalCrop = other.finalCrop;		finalCrop_legacy = other.finalCrop_legacy;
	}		}
	if (other.what & eOverrideScalingModeChanged) {		if (other.what & eOverrideScalingModeChanged) {
	what \|= eOverrideScalingModeChanged;		what \|= eOverrideScalingModeChanged;
	@@ -234,6 +278,46 @@ void layer_state_t::merge(const layer_state_t& other) {
	if (other.what & eDestroySurface) {		if (other.what & eDestroySurface) {
	what \|= eDestroySurface;		what \|= eDestroySurface;
	}		}
			if (other.what & eTransformChanged) {
			what \|= eTransformChanged;
			transform = other.transform;
			}
			if (other.what & eTransformToDisplayInverseChanged) {
			what \|= eTransformToDisplayInverseChanged;
			transformToDisplayInverse = other.transformToDisplayInverse;
			}
			if (other.what & eCropChanged) {
			what \|= eCropChanged;
			crop = other.crop;
			}
			if (other.what & eBufferChanged) {
			what \|= eBufferChanged;
			buffer = other.buffer;
			}
			if (other.what & eAcquireFenceChanged) {
			what \|= eAcquireFenceChanged;
			acquireFence = other.acquireFence;
			}
			if (other.what & eDataspaceChanged) {
			what \|= eDataspaceChanged;
			dataspace = other.dataspace;
			}
			if (other.what & eHdrMetadataChanged) {
			what \|= eHdrMetadataChanged;
			hdrMetadata = other.hdrMetadata;
			}
			if (other.what & eSurfaceDamageRegionChanged) {
			what \|= eSurfaceDamageRegionChanged;
			surfaceDamageRegion = other.surfaceDamageRegion;
			}
			if (other.what & eApiChanged) {
			what \|= eApiChanged;
			api = other.api;
			}
			if (other.what & eSidebandStreamChanged) {
			what \|= eSidebandStreamChanged;
			sidebandStream = other.sidebandStream;
			}
	}		}

	}; // namespace android		}; // namespace android

libs/gui/SurfaceComposerClient.cpp

+142 −18

Original line number	Original line	Diff line number	Diff line
	@@ -344,54 +344,57 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setMatri
	return *this;		return *this;
	}		}

	SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop(		SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop_legacy(
	const sp<SurfaceControl>& sc, const Rect& crop) {		const sp<SurfaceControl>& sc, const Rect& crop) {
	layer_state_t* s = getLayerState(sc);		layer_state_t* s = getLayerState(sc);
	if (!s) {		if (!s) {
	mStatus = BAD_INDEX;		mStatus = BAD_INDEX;
	return *this;		return *this;
	}		}
	s->what \|= layer_state_t::eCropChanged;		s->what \|= layer_state_t::eCropChanged_legacy;
	s->crop = crop;		s->crop_legacy = crop;
	return *this;		return *this;
	}		}

	SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFinalCrop(const sp<SurfaceControl>& sc, const Rect& crop) {		SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFinalCrop_legacy(
			const sp<SurfaceControl>& sc, const Rect& crop) {
	layer_state_t* s = getLayerState(sc);		layer_state_t* s = getLayerState(sc);
	if (!s) {		if (!s) {
	mStatus = BAD_INDEX;		mStatus = BAD_INDEX;
	return *this;		return *this;
	}		}
	s->what \|= layer_state_t::eFinalCropChanged;		s->what \|= layer_state_t::eFinalCropChanged_legacy;
	s->finalCrop = crop;		s->finalCrop_legacy = crop;
	return *this;		return *this;
	}		}

	SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::deferTransactionUntil(		SurfaceComposerClient::Transaction&
	const sp<SurfaceControl>& sc,		SurfaceComposerClient::Transaction::deferTransactionUntil_legacy(const sp<SurfaceControl>& sc,
	const sp<IBinder>& handle, uint64_t frameNumber) {		const sp<IBinder>& handle,
			uint64_t frameNumber) {
	layer_state_t* s = getLayerState(sc);		layer_state_t* s = getLayerState(sc);
	if (!s) {		if (!s) {
	mStatus = BAD_INDEX;		mStatus = BAD_INDEX;
	return *this;		return *this;
	}		}
	s->what \|= layer_state_t::eDeferTransaction;		s->what \|= layer_state_t::eDeferTransaction_legacy;
	s->barrierHandle = handle;		s->barrierHandle_legacy = handle;
	s->frameNumber = frameNumber;		s->frameNumber_legacy = frameNumber;
	return *this;		return *this;
	}		}

	SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::deferTransactionUntil(		SurfaceComposerClient::Transaction&
	const sp<SurfaceControl>& sc,		SurfaceComposerClient::Transaction::deferTransactionUntil_legacy(const sp<SurfaceControl>& sc,
	const sp<Surface>& barrierSurface, uint64_t frameNumber) {		const sp<Surface>& barrierSurface,
			uint64_t frameNumber) {
	layer_state_t* s = getLayerState(sc);		layer_state_t* s = getLayerState(sc);
	if (!s) {		if (!s) {
	mStatus = BAD_INDEX;		mStatus = BAD_INDEX;
	return *this;		return *this;
	}		}
	s->what \|= layer_state_t::eDeferTransaction;		s->what \|= layer_state_t::eDeferTransaction_legacy;
	s->barrierGbp = barrierSurface->getIGraphicBufferProducer();		s->barrierGbp_legacy = barrierSurface->getIGraphicBufferProducer();
	s->frameNumber = frameNumber;		s->frameNumber_legacy = frameNumber;
	return *this;		return *this;
	}		}

	@@ -434,6 +437,127 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setColor
	return *this;		return *this;
	}		}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setTransform(
			const sp<SurfaceControl>& sc, uint32_t transform) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eTransformChanged;
			s->transform = transform;
			return *this;
			}

			SurfaceComposerClient::Transaction&
			SurfaceComposerClient::Transaction::setTransformToDisplayInverse(const sp<SurfaceControl>& sc,
			bool transformToDisplayInverse) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eTransformToDisplayInverseChanged;
			s->transformToDisplayInverse = transformToDisplayInverse;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop(
			const sp<SurfaceControl>& sc, const Rect& crop) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eCropChanged;
			s->crop = crop;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBuffer(
			const sp<SurfaceControl>& sc, const sp<GraphicBuffer>& buffer) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eBufferChanged;
			s->buffer = buffer;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setAcquireFence(
			const sp<SurfaceControl>& sc, const sp<Fence>& fence) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eAcquireFenceChanged;
			s->acquireFence = fence;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDataspace(
			const sp<SurfaceControl>& sc, ui::Dataspace dataspace) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eDataspaceChanged;
			s->dataspace = dataspace;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setHdrMetadata(
			const sp<SurfaceControl>& sc, const HdrMetadata& hdrMetadata) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eHdrMetadataChanged;
			s->hdrMetadata = hdrMetadata;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setSurfaceDamageRegion(
			const sp<SurfaceControl>& sc, const Region& surfaceDamageRegion) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eSurfaceDamageRegionChanged;
			s->surfaceDamageRegion = surfaceDamageRegion;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setApi(
			const sp<SurfaceControl>& sc, int32_t api) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eApiChanged;
			s->api = api;
			return *this;
			}

			SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setSidebandStream(
			const sp<SurfaceControl>& sc, const sp<NativeHandle>& sidebandStream) {
			layer_state_t* s = getLayerState(sc);
			if (!s) {
			mStatus = BAD_INDEX;
			return *this;
			}
			s->what \|= layer_state_t::eSidebandStreamChanged;
			s->sidebandStream = sidebandStream;
			return *this;
			}

	SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::detachChildren(		SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::detachChildren(
	const sp<SurfaceControl>& sc) {		const sp<SurfaceControl>& sc) {
	layer_state_t* s = getLayerState(sc);		layer_state_t* s = getLayerState(sc);

libs/gui/include/gui/ISurfaceComposerClient.h

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -40,8 +40,9 @@ public:
	eProtectedByDRM = 0x00001000,		eProtectedByDRM = 0x00001000,
	eCursorWindow = 0x00002000,		eCursorWindow = 0x00002000,

	eFXSurfaceNormal = 0x00000000,		eFXSurfaceBufferQueue = 0x00000000,
	eFXSurfaceColor = 0x00020000,		eFXSurfaceColor = 0x00020000,
			eFXSurfaceBufferState = 0x00040000,
	eFXSurfaceMask = 0x000F0000,		eFXSurfaceMask = 0x000F0000,
	};		};

libs/gui/include/gui/LayerState.h

+122 −91

Original line number	Original line	Diff line number	Diff line
	@@ -22,10 +22,11 @@

	#include <utils/Errors.h>		#include <utils/Errors.h>

	#include <ui/Region.h>
	#include <ui/Rect.h>
	#include <gui/IGraphicBufferProducer.h>		#include <gui/IGraphicBufferProducer.h>
	#include <math/vec3.h>		#include <math/vec3.h>
			#include <ui/GraphicTypes.h>
			#include <ui/Rect.h>
			#include <ui/Region.h>

	namespace android {		namespace android {

	@@ -36,8 +37,6 @@ class ISurfaceComposerClient;
	* Used to communicate layer information between SurfaceFlinger and its clients.		* Used to communicate layer information between SurfaceFlinger and its clients.
	*/		*/
	struct layer_state_t {		struct layer_state_t {


	enum {		enum {
	eLayerHidden = 0x01, // SURFACE_HIDDEN in SurfaceControl.java		eLayerHidden = 0x01, // SURFACE_HIDDEN in SurfaceControl.java
	eLayerOpaque = 0x02, // SURFACE_OPAQUE		eLayerOpaque = 0x02, // SURFACE_OPAQUE
	@@ -53,9 +52,9 @@ struct layer_state_t {
	eTransparentRegionChanged = 0x00000020,		eTransparentRegionChanged = 0x00000020,
	eFlagsChanged = 0x00000040,		eFlagsChanged = 0x00000040,
	eLayerStackChanged = 0x00000080,		eLayerStackChanged = 0x00000080,
	eCropChanged = 0x00000100,		eCropChanged_legacy = 0x00000100,
	eDeferTransaction = 0x00000200,		eDeferTransaction_legacy = 0x00000200,
	eFinalCropChanged = 0x00000400,		eFinalCropChanged_legacy = 0x00000400,
	eOverrideScalingModeChanged = 0x00000800,		eOverrideScalingModeChanged = 0x00000800,
	eGeometryAppliesWithResize = 0x00001000,		eGeometryAppliesWithResize = 0x00001000,
	eReparentChildren = 0x00002000,		eReparentChildren = 0x00002000,
	@@ -63,19 +62,44 @@ struct layer_state_t {
	eRelativeLayerChanged = 0x00008000,		eRelativeLayerChanged = 0x00008000,
	eReparent = 0x00010000,		eReparent = 0x00010000,
	eColorChanged = 0x00020000,		eColorChanged = 0x00020000,
	eDestroySurface = 0x00040000		eDestroySurface = 0x00040000,
			eTransformChanged = 0x00100000,
			eTransformToDisplayInverseChanged = 0x00200000,
			eCropChanged = 0x00400000,
			eBufferChanged = 0x00800000,
			eAcquireFenceChanged = 0x01000000,
			eDataspaceChanged = 0x02000000,
			eHdrMetadataChanged = 0x04000000,
			eSurfaceDamageRegionChanged = 0x08000000,
			eApiChanged = 0x10000000,
			eSidebandStreamChanged = 0x20000000,
	};		};

	layer_state_t()		layer_state_t()
	: what(0),		: what(0),
	x(0), y(0), z(0), w(0), h(0), layerStack(0),		x(0),
	alpha(0), flags(0), mask(0),		y(0),
	reserved(0), crop(Rect::INVALID_RECT),		z(0),
	finalCrop(Rect::INVALID_RECT), frameNumber(0),		w(0),
	overrideScalingMode(-1)		h(0),
	{		layerStack(0),
			alpha(0),
			flags(0),
			mask(0),
			reserved(0),
			crop_legacy(Rect::INVALID_RECT),
			finalCrop_legacy(Rect::INVALID_RECT),
			frameNumber_legacy(0),
			overrideScalingMode(-1),
			transform(0),
			transformToDisplayInverse(false),
			crop(Rect::INVALID_RECT),
			dataspace(ui::Dataspace::UNKNOWN),
			surfaceDamageRegion(),
			api(-1) {
	matrix.dsdx = matrix.dtdy = 1.0f;		matrix.dsdx = matrix.dtdy = 1.0f;
	matrix.dsdy = matrix.dtdx = 0.0f;		matrix.dsdy = matrix.dtdx = 0.0f;
			hdrMetadata.validTypes = 0;
	}		}

	void merge(const layer_state_t& other);		void merge(const layer_state_t& other);
	@@ -101,14 +125,14 @@ struct layer_state_t {
	uint8_t mask;		uint8_t mask;
	uint8_t reserved;		uint8_t reserved;
	matrix22_t matrix;		matrix22_t matrix;
	Rect crop;		Rect crop_legacy;
	Rect finalCrop;		Rect finalCrop_legacy;
	sp<IBinder> barrierHandle;		sp<IBinder> barrierHandle_legacy;
	sp<IBinder> reparentHandle;		sp<IBinder> reparentHandle;
	uint64_t frameNumber;		uint64_t frameNumber_legacy;
	int32_t overrideScalingMode;		int32_t overrideScalingMode;

	sp<IGraphicBufferProducer> barrierGbp;		sp<IGraphicBufferProducer> barrierGbp_legacy;

	sp<IBinder> relativeLayerHandle;		sp<IBinder> relativeLayerHandle;

	@@ -118,6 +142,17 @@ struct layer_state_t {

	// non POD must be last. see write/read		// non POD must be last. see write/read
	Region transparentRegion;		Region transparentRegion;

			uint32_t transform;
			bool transformToDisplayInverse;
			Rect crop;
			sp<GraphicBuffer> buffer;
			sp<Fence> acquireFence;
			ui::Dataspace dataspace;
			HdrMetadata hdrMetadata;
			Region surfaceDamageRegion;
			int32_t api;
			sp<NativeHandle> sidebandStream;
	};		};

	struct ComposerState {		struct ComposerState {
	@@ -128,7 +163,6 @@ struct ComposerState {
	};		};

	struct DisplayState {		struct DisplayState {

	enum {		enum {
	eOrientationDefault = 0,		eOrientationDefault = 0,
	eOrientation90 = 1,		eOrientation90 = 1,
	@@ -160,8 +194,7 @@ struct DisplayState {
	status_t read(const Parcel& input);		status_t read(const Parcel& input);
	};		};

	static inline		static inline int compare_type(const ComposerState& lhs, const ComposerState& rhs) {
	int compare_type(const ComposerState& lhs, const ComposerState& rhs) {
	if (lhs.client < rhs.client) return -1;		if (lhs.client < rhs.client) return -1;
	if (lhs.client > rhs.client) return 1;		if (lhs.client > rhs.client) return 1;
	if (lhs.state.surface < rhs.state.surface) return -1;		if (lhs.state.surface < rhs.state.surface) return -1;
	@@ -169,12 +202,10 @@ int compare_type(const ComposerState& lhs, const ComposerState& rhs) {
	return 0;		return 0;
	}		}

	static inline		static inline int compare_type(const DisplayState& lhs, const DisplayState& rhs) {
	int compare_type(const DisplayState& lhs, const DisplayState& rhs) {
	return compare_type(lhs.token, rhs.token);		return compare_type(lhs.token, rhs.token);
	}		}

	}; // namespace android		}; // namespace android

	#endif // ANDROID_SF_LAYER_STATE_H		#endif // ANDROID_SF_LAYER_STATE_H