am f7db3e21: am 8e7515d9: Merge "get rid of our LayerVector implementation" into gingerbread (ebb7ae51) · Commits · e / os / android_frameworks_base

services/surfaceflinger/LayerBase.cpp

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -39,8 +39,11 @@ namespace android {

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

			int32_t LayerBase::sSequence = 1;

	LayerBase::LayerBase(SurfaceFlinger* flinger, DisplayID display)		LayerBase::LayerBase(SurfaceFlinger* flinger, DisplayID display)
	: dpy(display), contentDirty(false),		: dpy(display), contentDirty(false),
			sequence(uint32_t(android_atomic_inc(&sSequence))),
	mFlinger(flinger),		mFlinger(flinger),
	mNeedsFiltering(false),		mNeedsFiltering(false),
	mOrientation(0),		mOrientation(0),

services/surfaceflinger/LayerBase.h

+3 −6

Original line number	Original line	Diff line number	Diff line
	@@ -53,6 +53,8 @@ class Texture;

	class LayerBase : public RefBase		class LayerBase : public RefBase
	{		{
			static int32_t sSequence;

	public:		public:
	LayerBase(SurfaceFlinger* flinger, DisplayID display);		LayerBase(SurfaceFlinger* flinger, DisplayID display);

	@@ -61,6 +63,7 @@ public:
	Region visibleRegionScreen;		Region visibleRegionScreen;
	Region transparentRegionScreen;		Region transparentRegionScreen;
	Region coveredRegionScreen;		Region coveredRegionScreen;
			int32_t sequence;

	struct State {		struct State {
	uint32_t w;		uint32_t w;
	@@ -210,12 +213,6 @@ public:
	inline const State& currentState() const { return mCurrentState; }		inline const State& currentState() const { return mCurrentState; }
	inline State& currentState() { return mCurrentState; }		inline State& currentState() { return mCurrentState; }

	static int compareCurrentStateZ(
	sp<LayerBase> const * layerA,
	sp<LayerBase> const * layerB) {
	return layerA[0]->currentState().z - layerB[0]->currentState().z;
	}

	int32_t getOrientation() const { return mOrientation; }		int32_t getOrientation() const { return mOrientation; }
	int tx() const { return mLeft; }		int tx() const { return mLeft; }
	int ty() const { return mTop; }		int ty() const { return mTop; }

services/surfaceflinger/SurfaceFlinger.cpp

+4 −93

Original line number	Original line	Diff line number	Diff line
	@@ -65,95 +65,6 @@
	namespace android {		namespace android {
	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

	SurfaceFlinger::LayerVector::LayerVector(const SurfaceFlinger::LayerVector& rhs)
	: lookup(rhs.lookup), layers(rhs.layers)
	{
	}

	ssize_t SurfaceFlinger::LayerVector::indexOf(
	const sp<LayerBase>& key, size_t guess) const
	{
	if (guess<size() && lookup.keyAt(guess) == key)
	return guess;
	const ssize_t i = lookup.indexOfKey(key);
	if (i>=0) {
	const size_t idx = lookup.valueAt(i);
	LOGE_IF(layers[idx]!=key,
	"LayerVector[%p]: layers[%d]=%p, key=%p",
	this, int(idx), layers[idx].get(), key.get());
	return idx;
	}
	return i;
	}

	ssize_t SurfaceFlinger::LayerVector::add(
	const sp<LayerBase>& layer,
	Vector< sp<LayerBase> >::compar_t cmp)
	{
	size_t count = layers.size();
	ssize_t l = 0;
	ssize_t h = count-1;
	ssize_t mid;
	sp<LayerBase> const* a = layers.array();
	while (l <= h) {
	mid = l + (h - l)/2;
	const int c = cmp(a+mid, &layer);
	if (c == 0) { l = mid; break; }
	else if (c<0) { l = mid+1; }
	else { h = mid-1; }
	}
	size_t order = l;
	while (order<count && !cmp(&layer, a+order)) {
	order++;
	}
	count = lookup.size();
	for (size_t i=0 ; i<count ; i++) {
	if (lookup.valueAt(i) >= order) {
	lookup.editValueAt(i)++;
	}
	}
	layers.insertAt(layer, order);
	lookup.add(layer, order);
	return order;
	}

	ssize_t SurfaceFlinger::LayerVector::remove(const sp<LayerBase>& layer)
	{
	const ssize_t keyIndex = lookup.indexOfKey(layer);
	if (keyIndex >= 0) {
	const size_t index = lookup.valueAt(keyIndex);
	LOGE_IF(layers[index]!=layer,
	"LayerVector[%p]: layers[%u]=%p, layer=%p",
	this, int(index), layers[index].get(), layer.get());
	layers.removeItemsAt(index);
	lookup.removeItemsAt(keyIndex);
	const size_t count = lookup.size();
	for (size_t i=0 ; i<count ; i++) {
	if (lookup.valueAt(i) >= size_t(index)) {
	lookup.editValueAt(i)--;
	}
	}
	return index;
	}
	return NAME_NOT_FOUND;
	}

	ssize_t SurfaceFlinger::LayerVector::reorder(
	const sp<LayerBase>& layer,
	Vector< sp<LayerBase> >::compar_t cmp)
	{
	// XXX: it's a little lame. but oh well...
	ssize_t err = remove(layer);
	if (err >=0)
	err = add(layer, cmp);
	return err;
	}

	// ---------------------------------------------------------------------------
	#if 0
	#pragma mark -
	#endif

	SurfaceFlinger::SurfaceFlinger()		SurfaceFlinger::SurfaceFlinger()
	: BnSurfaceComposer(), Thread(false),		: BnSurfaceComposer(), Thread(false),
	mTransactionFlags(0),		mTransactionFlags(0),
	@@ -1045,8 +956,7 @@ status_t SurfaceFlinger::addLayer(const sp<LayerBase>& layer)

	status_t SurfaceFlinger::addLayer_l(const sp<LayerBase>& layer)		status_t SurfaceFlinger::addLayer_l(const sp<LayerBase>& layer)
	{		{
	ssize_t i = mCurrentState.layersSortedByZ.add(		ssize_t i = mCurrentState.layersSortedByZ.add(layer);
	layer, &LayerBase::compareCurrentStateZ);
	return (i < 0) ? status_t(i) : status_t(NO_ERROR);		return (i < 0) ? status_t(i) : status_t(NO_ERROR);
	}		}

	@@ -1388,9 +1298,10 @@ status_t SurfaceFlinger::setClientState(
	flags \|= eTraversalNeeded;		flags \|= eTraversalNeeded;
	}		}
	if (what & eLayerChanged) {		if (what & eLayerChanged) {
			ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
	if (layer->setLayer(s.z)) {		if (layer->setLayer(s.z)) {
	mCurrentState.layersSortedByZ.reorder(		mCurrentState.layersSortedByZ.removeAt(idx);
	layer, &Layer::compareCurrentStateZ);		mCurrentState.layersSortedByZ.add(layer);
	// we need traversal (state changed)		// we need traversal (state changed)
	// AND transaction (list changed)		// AND transaction (list changed)
	flags \|= eTransactionNeeded\|eTraversalNeeded;		flags \|= eTransactionNeeded\|eTraversalNeeded;

services/surfaceflinger/SurfaceFlinger.h

+12 −14

Original line number	Original line	Diff line number	Diff line
	@@ -243,21 +243,19 @@ private:
	status_t setClientState(const sp<Client>& client,		status_t setClientState(const sp<Client>& client,
	int32_t count, const layer_state_t* states);		int32_t count, const layer_state_t* states);

			class LayerVector : public SortedVector< sp<LayerBase> > {
	class LayerVector {
	public:		public:
	inline LayerVector() { }		LayerVector() { }
	LayerVector(const LayerVector&);		LayerVector(const LayerVector& rhs) : SortedVector< sp<LayerBase> >(rhs) { }
	inline size_t size() const { return layers.size(); }		virtual int do_compare(const void* lhs, const void* rhs) const {
	inline sp<LayerBase> const* array() const { return layers.array(); }		const sp<LayerBase>& l(reinterpret_cast<const sp<LayerBase>>(lhs));
	ssize_t add(const sp<LayerBase>&, Vector< sp<LayerBase> >::compar_t);		const sp<LayerBase>& r(reinterpret_cast<const sp<LayerBase>>(rhs));
	ssize_t remove(const sp<LayerBase>&);		// sort layers by Z order
	ssize_t reorder(const sp<LayerBase>&, Vector< sp<LayerBase> >::compar_t);		uint32_t lz = l->currentState().z;
	ssize_t indexOf(const sp<LayerBase>& key, size_t guess=0) const;		uint32_t rz = r->currentState().z;
	inline sp<LayerBase> operator [] (size_t i) const { return layers[i]; }		// then by sequence, so we get a stable ordering
	private:		return (lz != rz) ? (lz - rz) : (l->sequence - r->sequence);
	KeyedVector< sp<LayerBase> , size_t> lookup;		}
	Vector< sp<LayerBase> > layers;
	};		};

	struct State {		struct State {