Remove explicit instantiation of SingleStateQueue (9b82924c) · Commits · e / os / android_frameworks_av

include/media/SingleStateQueue.h

+66 −12

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		// Non-blocking single-reader / single-writer multi-word atomic load / store

		#include <stdint.h>
		#include <cutils/atomic.h>

		namespace android {

		@@ -41,28 +42,47 @@ private:
		void init() { mAck = 0; mSequence = 0; }

		volatile int32_t mAck;
		#if 0
		int mPad[7];
		// cache line boundary
		#endif
		volatile int32_t mSequence;
		T mValue;
		};

		class Mutator {
		public:
		Mutator(Shared *shared);
		/virtual/ ~Mutator() { }
		Mutator(Shared *shared)
		: mSequence(0), mShared(shared)
		{
		// exactly one of Mutator and Observer must initialize, currently it is Observer
		// shared->init();
		}

		// push new value onto state queue, overwriting previous value;
		// returns a sequence number which can be used with ack()
		int32_t push(const T& value);
		int32_t push(const T& value)
		{
		Shared *shared = mShared;
		int32_t sequence = mSequence;
		sequence++;
		android_atomic_acquire_store(sequence, &shared->mSequence);
		shared->mValue = value;
		sequence++;
		android_atomic_release_store(sequence, &shared->mSequence);
		mSequence = sequence;
		// consider signalling a futex here, if we know that observer is waiting
		return sequence;
		}

		// return true if most recent push has been observed
		bool ack();
		bool ack() const
		{
		return mShared->mAck - mSequence == 0;
		}

		// return true if a push with specified sequence number or later has been observed
		bool ack(int32_t sequence);
		bool ack(int32_t sequence) const
		{
		// this relies on 2's complement rollover to detect an ancient sequence number
		return mShared->mAck - sequence >= 0;
		}

		private:
		int32_t mSequence;
		@@ -71,11 +91,45 @@ private:

		class Observer {
		public:
		Observer(Shared *shared);
		/virtual/ ~Observer() { }
		Observer(Shared *shared)
		: mSequence(0), mSeed(1), mShared(shared)
		{
		// exactly one of Mutator and Observer must initialize, currently it is Observer
		shared->init();
		}

		// return true if value has changed
		bool poll(T& value);
		bool poll(T& value)
		{
		Shared *shared = mShared;
		int32_t before = shared->mSequence;
		if (before == mSequence) {
		return false;
		}
		for (int tries = 0; ; ) {
		const int MAX_TRIES = 5;
		if (before & 1) {
		if (++tries >= MAX_TRIES) {
		return false;
		}
		before = shared->mSequence;
		} else {
		android_memory_barrier();
		T temp = shared->mValue;
		int32_t after = android_atomic_release_load(&shared->mSequence);
		if (after == before) {
		value = temp;
		shared->mAck = before;
		mSequence = before;
		return true;
		}
		if (++tries >= MAX_TRIES) {
		return false;
		}
		before = after;
		}
		}
		}

		private:
		int32_t mSequence;

media/libmedia/Android.mk

+0 −11

Original line number	Diff line number	Diff line
		@@ -69,8 +69,6 @@ LOCAL_SHARED_LIBRARIES := \
		libcamera_client libstagefright_foundation \
		libgui libdl libaudioutils libnbaio

		LOCAL_STATIC_LIBRARIES += libinstantssq

		LOCAL_WHOLE_STATIC_LIBRARIES := libmedia_helper

		LOCAL_MODULE:= libmedia
		@@ -88,12 +86,3 @@ LOCAL_C_INCLUDES := \

		include $(BUILD_SHARED_LIBRARY)

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES += SingleStateQueue.cpp
		LOCAL_CFLAGS += -DSINGLE_STATE_QUEUE_INSTANTIATIONS='"SingleStateQueueInstantiations.cpp"'

		LOCAL_MODULE := libinstantssq
		LOCAL_MODULE_TAGS := optional

		include $(BUILD_STATIC_LIBRARY)

media/libmedia/SingleStateQueue.cpp

deleted100644 → 0

+0 −106

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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.
		*/

		#include <new>
		#include <cutils/atomic.h>
		#include <media/SingleStateQueue.h>

		namespace android {

		template<typename T> SingleStateQueue<T>::Mutator::Mutator(Shared *shared)
		: mSequence(0), mShared((Shared *) shared)
		{
		// exactly one of Mutator and Observer must initialize, currently it is Observer
		//shared->init();
		}

		template<typename T> int32_t SingleStateQueue<T>::Mutator::push(const T& value)
		{
		Shared *shared = mShared;
		int32_t sequence = mSequence;
		sequence++;
		android_atomic_acquire_store(sequence, &shared->mSequence);
		shared->mValue = value;
		sequence++;
		android_atomic_release_store(sequence, &shared->mSequence);
		mSequence = sequence;
		// consider signalling a futex here, if we know that observer is waiting
		return sequence;
		}

		template<typename T> bool SingleStateQueue<T>::Mutator::ack()
		{
		return mShared->mAck - mSequence == 0;
		}

		template<typename T> bool SingleStateQueue<T>::Mutator::ack(int32_t sequence)
		{
		// this relies on 2's complement rollover to detect an ancient sequence number
		return mShared->mAck - sequence >= 0;
		}

		template<typename T> SingleStateQueue<T>::Observer::Observer(Shared *shared)
		: mSequence(0), mSeed(1), mShared((Shared *) shared)
		{
		// exactly one of Mutator and Observer must initialize, currently it is Observer
		shared->init();
		}

		template<typename T> bool SingleStateQueue<T>::Observer::poll(T& value)
		{
		Shared *shared = mShared;
		int32_t before = shared->mSequence;
		if (before == mSequence) {
		return false;
		}
		for (int tries = 0; ; ) {
		const int MAX_TRIES = 5;
		if (before & 1) {
		if (++tries >= MAX_TRIES) {
		return false;
		}
		before = shared->mSequence;
		} else {
		android_memory_barrier();
		T temp = shared->mValue;
		int32_t after = android_atomic_release_load(&shared->mSequence);
		if (after == before) {
		value = temp;
		shared->mAck = before;
		mSequence = before;
		return true;
		}
		if (++tries >= MAX_TRIES) {
		return false;
		}
		before = after;
		}
		}
		}

		#if 0
		template<typename T> SingleStateQueue<T>::SingleStateQueue(void /Shared/ *shared)
		{
		((Shared *) shared)->init();
		}
		#endif

		} // namespace android

		// hack for gcc
		#ifdef SINGLE_STATE_QUEUE_INSTANTIATIONS
		#include SINGLE_STATE_QUEUE_INSTANTIATIONS
		#endif

media/libmedia/SingleStateQueueInstantiations.cpp

deleted100644 → 0

+0 −28

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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.
		*/

		#include <media/SingleStateQueue.h>
		#include <private/media/StaticAudioTrackState.h>
		#include <media/AudioTimestamp.h>

		// FIXME hack for gcc

		namespace android {

		template class SingleStateQueue<StaticAudioTrackState>; // typedef StaticAudioTrackSingleStateQueue
		template class SingleStateQueue<AudioTimestamp>; // typedef AudioTimestampSingleStateQueue

		}

media/libnbaio/Android.mk

+0 −2

Original line number	Diff line number	Diff line
		@@ -33,6 +33,4 @@ LOCAL_SHARED_LIBRARIES := \
		libutils \
		liblog

		LOCAL_STATIC_LIBRARIES += libinstantssq

		include $(BUILD_SHARED_LIBRARY)