diff options
| -rw-r--r-- | include/media/SingleStateQueue.h | 97 | ||||
| -rw-r--r-- | include/private/media/StaticAudioTrackState.h | 35 | ||||
| -rw-r--r-- | media/libmedia/Android.mk | 7 | ||||
| -rw-r--r-- | media/libmedia/SingleStateQueue.cpp | 107 | ||||
| -rw-r--r-- | media/libmedia/SingleStateQueueInstantiations.cpp | 26 | ||||
| -rw-r--r-- | services/audioflinger/Android.mk | 1 |
6 files changed, 272 insertions, 1 deletions
diff --git a/include/media/SingleStateQueue.h b/include/media/SingleStateQueue.h new file mode 100644 index 0000000..04c5fd0 --- /dev/null +++ b/include/media/SingleStateQueue.h @@ -0,0 +1,97 @@ +/* + * 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. + */ + +#ifndef SINGLE_STATE_QUEUE_H +#define SINGLE_STATE_QUEUE_H + +// Non-blocking single element state queue, or +// Non-blocking single-reader / single-writer multi-word atomic load / store + +#include <stdint.h> + +namespace android { + +template<typename T> class SingleStateQueue { + +public: + + class Mutator; + class Observer; + + struct Shared { + // needs to be part of a union so don't define constructor or destructor + + friend class Mutator; + friend class Observer; + +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() { } + + // 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); + + // return true if most recent push has been observed + bool ack(); + + // return true if a push with specified sequence number or later has been observed + bool ack(int32_t sequence); + + private: + int32_t mSequence; + Shared * const mShared; + }; + + class Observer { + public: + Observer(Shared *shared); + /*virtual*/ ~Observer() { } + + // return true if value has changed + bool poll(T& value); + + private: + int32_t mSequence; + int mSeed; // for PRNG + Shared * const mShared; + }; + +#if 0 + SingleStateQueue(void /*Shared*/ *shared); + /*virtual*/ ~SingleStateQueue() { } + + static size_t size() { return sizeof(Shared); } +#endif + +}; + +} // namespace android + +#endif // SINGLE_STATE_QUEUE_H diff --git a/include/private/media/StaticAudioTrackState.h b/include/private/media/StaticAudioTrackState.h new file mode 100644 index 0000000..46a5946 --- /dev/null +++ b/include/private/media/StaticAudioTrackState.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +#ifndef STATIC_AUDIO_TRACK_STATE_H +#define STATIC_AUDIO_TRACK_STATE_H + +namespace android { + +// Represents a single state of an AudioTrack that was created in static mode (shared memory buffer +// supplied by the client). This state needs to be communicated from the client to server. As this +// state is too large to be updated atomically without a mutex, and mutexes aren't allowed here, the +// state is wrapped by a SingleStateQueue. +struct StaticAudioTrackState { + // do not define constructors, destructors, or virtual methods + size_t mLoopStart; + size_t mLoopEnd; + int mLoopCount; +}; + +} // namespace android + +#endif // STATIC_AUDIO_TRACK_STATE_H diff --git a/media/libmedia/Android.mk b/media/libmedia/Android.mk index 52fa3e1..6b48991 100644 --- a/media/libmedia/Android.mk +++ b/media/libmedia/Android.mk @@ -53,6 +53,13 @@ LOCAL_SRC_FILES:= \ SoundPool.cpp \ SoundPoolThread.cpp +LOCAL_SRC_FILES += ../libnbaio/roundup.c + +# for <cutils/atomic-inline.h> +LOCAL_CFLAGS += -DANDROID_SMP=$(if $(findstring true,$(TARGET_CPU_SMP)),1,0) +LOCAL_SRC_FILES += SingleStateQueue.cpp +LOCAL_CFLAGS += -DSINGLE_STATE_QUEUE_INSTANTIATIONS='"SingleStateQueueInstantiations.cpp"' + LOCAL_SHARED_LIBRARIES := \ libui libcutils libutils libbinder libsonivox libicuuc libexpat \ libcamera_client libstagefright_foundation \ diff --git a/media/libmedia/SingleStateQueue.cpp b/media/libmedia/SingleStateQueue.cpp new file mode 100644 index 0000000..3503baa --- /dev/null +++ b/media/libmedia/SingleStateQueue.cpp @@ -0,0 +1,107 @@ +/* + * 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 <cutils/atomic-inline.h> // for android_memory_barrier() +#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 diff --git a/media/libmedia/SingleStateQueueInstantiations.cpp b/media/libmedia/SingleStateQueueInstantiations.cpp new file mode 100644 index 0000000..2afebe9 --- /dev/null +++ b/media/libmedia/SingleStateQueueInstantiations.cpp @@ -0,0 +1,26 @@ +/* + * 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> + +// FIXME hack for gcc + +namespace android { + +template class SingleStateQueue<StaticAudioTrackState>; // typedef StaticAudioTrackSingleStateQueue + +} diff --git a/services/audioflinger/Android.mk b/services/audioflinger/Android.mk index 7daef99..7806f48 100644 --- a/services/audioflinger/Android.mk +++ b/services/audioflinger/Android.mk @@ -104,5 +104,4 @@ LOCAL_MODULE_TAGS := optional include $(BUILD_EXECUTABLE) - include $(call all-makefiles-under,$(LOCAL_PATH)) |