Oboe FIFO: general purpose FIFO (fd911c1b) · Commits · e / os / android_frameworks_av

media/liboboe/src/fifo/FifoBuffer.cpp

0 → 100644

+186 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2015 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 <cstring>
		#include <unistd.h>

		#define LOG_TAG "FifoBuffer"
		//#define LOG_NDEBUG 0
		#include <utils/Log.h>

		#include "FifoControllerBase.h"
		#include "FifoController.h"
		#include "FifoControllerIndirect.h"
		#include "FifoBuffer.h"

		FifoBuffer::FifoBuffer(int32_t bytesPerFrame, fifo_frames_t capacityInFrames)
		: mFrameCapacity(capacityInFrames)
		, mBytesPerFrame(bytesPerFrame)
		, mStorage(nullptr)
		, mFramesReadCount(0)
		, mFramesUnderrunCount(0)
		, mUnderrunCount(0)
		{
		// TODO Handle possible failures to allocate. Move out of constructor?
		mFifo = new FifoController(capacityInFrames, capacityInFrames);
		// allocate buffer
		int32_t bytesPerBuffer = bytesPerFrame * capacityInFrames;
		mStorage = new uint8_t[bytesPerBuffer];
		mStorageOwned = true;
		ALOGD("FifoBuffer: capacityInFrames = %d, bytesPerFrame = %d",
		capacityInFrames, bytesPerFrame);
		}

		FifoBuffer::FifoBuffer( int32_t bytesPerFrame,
		fifo_frames_t capacityInFrames,
		fifo_counter_t * readIndexAddress,
		fifo_counter_t * writeIndexAddress,
		void * dataStorageAddress
		)
		: mFrameCapacity(capacityInFrames)
		, mBytesPerFrame(bytesPerFrame)
		, mStorage(static_cast<uint8_t *>(dataStorageAddress))
		, mFramesReadCount(0)
		, mFramesUnderrunCount(0)
		, mUnderrunCount(0)
		{
		// TODO Handle possible failures to allocate. Move out of constructor?
		mFifo = new FifoControllerIndirect(capacityInFrames,
		capacityInFrames,
		readIndexAddress,
		writeIndexAddress);
		mStorageOwned = false;
		ALOGD("FifoProcessor: capacityInFrames = %d, bytesPerFrame = %d",
		capacityInFrames, bytesPerFrame);
		}

		FifoBuffer::~FifoBuffer() {
		if (mStorageOwned) {
		delete[] mStorage;
		}
		delete mFifo;
		}


		int32_t FifoBuffer::convertFramesToBytes(fifo_frames_t frames) {
		return frames * mBytesPerFrame;
		}

		fifo_frames_t FifoBuffer::read(void *buffer, fifo_frames_t numFrames) {
		size_t numBytes;
		fifo_frames_t framesAvailable = mFifo->getFullFramesAvailable();
		fifo_frames_t framesToRead = numFrames;
		// Is there enough data in the FIFO
		if (framesToRead > framesAvailable) {
		framesToRead = framesAvailable;
		}
		if (framesToRead == 0) {
		return 0;
		}

		fifo_frames_t readIndex = mFifo->getReadIndex();
		uint8_t destination = (uint8_t ) buffer;
		uint8_t *source = &mStorage[convertFramesToBytes(readIndex)];
		if ((readIndex + framesToRead) > mFrameCapacity) {
		// read in two parts, first part here
		fifo_frames_t frames1 = mFrameCapacity - readIndex;
		int32_t numBytes = convertFramesToBytes(frames1);
		memcpy(destination, source, numBytes);
		destination += numBytes;
		// read second part
		source = &mStorage[0];
		fifo_frames_t frames2 = framesToRead - frames1;
		numBytes = convertFramesToBytes(frames2);
		memcpy(destination, source, numBytes);
		} else {
		// just read in one shot
		numBytes = convertFramesToBytes(framesToRead);
		memcpy(destination, source, numBytes);
		}
		mFifo->advanceReadIndex(framesToRead);

		return framesToRead;
		}

		fifo_frames_t FifoBuffer::write(const void *buffer, fifo_frames_t framesToWrite) {
		fifo_frames_t framesAvailable = mFifo->getEmptyFramesAvailable();
		// ALOGD("FifoBuffer::write() framesToWrite = %d, framesAvailable = %d",
		// framesToWrite, framesAvailable);
		if (framesToWrite > framesAvailable) {
		framesToWrite = framesAvailable;
		}
		if (framesToWrite <= 0) {
		return 0;
		}

		size_t numBytes;
		fifo_frames_t writeIndex = mFifo->getWriteIndex();
		int byteIndex = convertFramesToBytes(writeIndex);
		const uint8_t source = (const uint8_t ) buffer;
		uint8_t *destination = &mStorage[byteIndex];
		if ((writeIndex + framesToWrite) > mFrameCapacity) {
		// write in two parts, first part here
		fifo_frames_t frames1 = mFrameCapacity - writeIndex;
		numBytes = convertFramesToBytes(frames1);
		memcpy(destination, source, numBytes);
		// ALOGD("FifoBuffer::write(%p to %p, numBytes = %d", source, destination, numBytes);
		// read second part
		source += convertFramesToBytes(frames1);
		destination = &mStorage[0];
		fifo_frames_t framesLeft = framesToWrite - frames1;
		numBytes = convertFramesToBytes(framesLeft);
		// ALOGD("FifoBuffer::write(%p to %p, numBytes = %d", source, destination, numBytes);
		memcpy(destination, source, numBytes);
		} else {
		// just write in one shot
		numBytes = convertFramesToBytes(framesToWrite);
		// ALOGD("FifoBuffer::write(%p to %p, numBytes = %d", source, destination, numBytes);
		memcpy(destination, source, numBytes);
		}
		mFifo->advanceWriteIndex(framesToWrite);

		return framesToWrite;
		}

		fifo_frames_t FifoBuffer::readNow(void *buffer, fifo_frames_t numFrames) {
		mLastReadSize = numFrames;
		fifo_frames_t framesLeft = numFrames;
		fifo_frames_t framesRead = read(buffer, numFrames);
		framesLeft -= framesRead;
		mFramesReadCount += framesRead;
		mFramesUnderrunCount += framesLeft;
		// Zero out any samples we could not set.
		if (framesLeft > 0) {
		mUnderrunCount++;
		int32_t bytesToZero = convertFramesToBytes(framesLeft);
		memset(buffer, 0, bytesToZero);
		}

		return framesRead;
		}

		fifo_frames_t FifoBuffer::getThreshold() {
		return mFifo->getThreshold();
		}

		void FifoBuffer::setThreshold(fifo_frames_t threshold) {
		mFifo->setThreshold(threshold);
		}

		fifo_frames_t FifoBuffer::getBufferCapacityInFrames() {
		return mFifo->getCapacity();
		}

media/liboboe/src/fifo/FifoBuffer.h

0 → 100644

+87 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2015 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 FIFO_FIFO_BUFFER_H
		#define FIFO_FIFO_BUFFER_H

		#include <stdint.h>

		#include "FifoControllerBase.h"

		class FifoBuffer {
		public:
		FifoBuffer(int32_t bytesPerFrame, fifo_frames_t capacityInFrames);

		FifoBuffer(int32_t bytesPerFrame,
		fifo_frames_t capacityInFrames,
		fifo_counter_t * readCounterAddress,
		fifo_counter_t * writeCounterAddress,
		void * dataStorageAddress);

		~FifoBuffer();

		int32_t convertFramesToBytes(fifo_frames_t frames);

		fifo_frames_t read(void *destination, fifo_frames_t framesToRead);

		fifo_frames_t write(const void *source, fifo_frames_t framesToWrite);

		fifo_frames_t getThreshold();
		void setThreshold(fifo_frames_t threshold);

		fifo_frames_t getBufferCapacityInFrames();

		fifo_frames_t readNow(void *buffer, fifo_frames_t numFrames);

		int64_t getNextReadTime(int32_t frameRate);

		int32_t getUnderrunCount() const { return mUnderrunCount; }

		FifoControllerBase *getFifoControllerBase() { return mFifo; }

		int32_t getBytesPerFrame() {
		return mBytesPerFrame;
		}

		fifo_counter_t getReadCounter() {
		return mFifo->getReadCounter();
		}

		void setReadCounter(fifo_counter_t n) {
		mFifo->setReadCounter(n);
		}

		fifo_counter_t getWriteCounter() {
		return mFifo->getWriteCounter();
		}

		void setWriteCounter(fifo_counter_t n) {
		mFifo->setWriteCounter(n);
		}

		private:
		const fifo_frames_t mFrameCapacity;
		const int32_t mBytesPerFrame;
		uint8_t * mStorage;
		bool mStorageOwned; // did this object allocate the storage?
		FifoControllerBase *mFifo;
		fifo_counter_t mFramesReadCount;
		fifo_counter_t mFramesUnderrunCount;
		int32_t mUnderrunCount; // need? just use frames
		int32_t mLastReadSize;
		};

		#endif //FIFO_FIFO_BUFFER_H

media/liboboe/src/fifo/FifoController.h

0 → 100644

+59 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2015 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 FIFO_FIFO_CONTROLLER_H
		#define FIFO_FIFO_CONTROLLER_H

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

		#include "FifoControllerBase.h"

		/**
		* A FIFO with counters contained in the class.
		*/
		class FifoController : public FifoControllerBase
		{
		public:
		FifoController(fifo_counter_t bufferSize, fifo_counter_t threshold)
		: FifoControllerBase(bufferSize, threshold)
		, mReadCounter(0)
		, mWriteCounter(0)
		{}

		virtual ~FifoController() {}

		// TODO review use of memory barriers, probably incorrect
		virtual fifo_counter_t getReadCounter() override {
		return mReadCounter.load(std::memory_order_acquire);
		}
		virtual void setReadCounter(fifo_counter_t n) override {
		mReadCounter.store(n, std::memory_order_release);
		}
		virtual fifo_counter_t getWriteCounter() override {
		return mWriteCounter.load(std::memory_order_acquire);
		}
		virtual void setWriteCounter(fifo_counter_t n) override {
		mWriteCounter.store(n, std::memory_order_release);
		}

		private:
		std::atomic<fifo_counter_t> mReadCounter;
		std::atomic<fifo_counter_t> mWriteCounter;
		};


		#endif //FIFO_FIFO_CONTROLLER_H

media/liboboe/src/fifo/FifoControllerBase.cpp

0 → 100644

+61 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2015 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.
		*/

		#define LOG_TAG "FifoControllerBase"
		//#define LOG_NDEBUG 0
		#include <utils/Log.h>

		#include <stdint.h>
		#include "FifoControllerBase.h"

		FifoControllerBase::FifoControllerBase(fifo_frames_t capacity, fifo_frames_t threshold)
		: mCapacity(capacity)
		, mThreshold(threshold)
		{
		}

		FifoControllerBase::~FifoControllerBase() {
		}

		fifo_frames_t FifoControllerBase::getFullFramesAvailable() {
		return (fifo_frames_t) (getWriteCounter() - getReadCounter());
		}

		fifo_frames_t FifoControllerBase::getReadIndex() {
		// % works with non-power of two sizes
		return (fifo_frames_t) (getReadCounter() % mCapacity);
		}

		void FifoControllerBase::advanceReadIndex(fifo_frames_t numFrames) {
		setReadCounter(getReadCounter() + numFrames);
		}

		fifo_frames_t FifoControllerBase::getEmptyFramesAvailable() {
		return (int32_t)(mThreshold - getFullFramesAvailable());
		}

		fifo_frames_t FifoControllerBase::getWriteIndex() {
		// % works with non-power of two sizes
		return (fifo_frames_t) (getWriteCounter() % mCapacity);
		}

		void FifoControllerBase::advanceWriteIndex(fifo_frames_t numFrames) {
		setWriteCounter(getWriteCounter() + numFrames);
		}

		void FifoControllerBase::setThreshold(fifo_frames_t threshold) {
		mThreshold = threshold;
		}

media/liboboe/src/fifo/FifoControllerBase.h

0 → 100644

+121 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2015 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 FIFO_FIFO_CONTROLLER_BASE_H
		#define FIFO_FIFO_CONTROLLER_BASE_H

		#include <stdint.h>

		typedef int64_t fifo_counter_t;
		typedef int32_t fifo_frames_t;

		/**
		* Manage the read/write indices of a circular buffer.
		*
		* The caller is responsible for reading and writing the actual data.
		* Note that the span of available frames may not be contiguous. They
		* may wrap around from the end to the beginning of the buffer. In that
		* case the data must be read or written in at least two blocks of frames.
		*
		*/
		class FifoControllerBase {

		public:
		/**
		* Constructor for FifoControllerBase
		* @param capacity Total size of the circular buffer in frames.
		* @param threshold Number of frames to fill. Must be less than capacity.
		*/
		FifoControllerBase(fifo_frames_t capacity, fifo_frames_t threshold);

		virtual ~FifoControllerBase();

		// Abstract methods to be implemented in subclasses.
		/**
		* @return Counter used by the reader of the FIFO.
		*/
		virtual fifo_counter_t getReadCounter() = 0;

		/**
		* This is normally only used internally.
		* @param count Number of frames that have been read.
		*/
		virtual void setReadCounter(fifo_counter_t count) = 0;

		/**
		* @return Counter used by the reader of the FIFO.
		*/
		virtual fifo_counter_t getWriteCounter() = 0;

		/**
		* This is normally only used internally.
		* @param count Number of frames that have been read.
		*/
		virtual void setWriteCounter(fifo_counter_t count) = 0;

		/**
		* This may be negative if an unthrottled reader has read beyond the available data.
		* @return number of valid frames available to read. Never read more than this.
		*/
		fifo_frames_t getFullFramesAvailable();

		/**
		* The index in a circular buffer of the next frame to read.
		*/
		fifo_frames_t getReadIndex();

		/**
		* @param numFrames number of frames to advance the read index
		*/
		void advanceReadIndex(fifo_frames_t numFrames);

		/**
		* @return number of frames that can be written. Never write more than this.
		*/
		fifo_frames_t getEmptyFramesAvailable();

		/**
		* The index in a circular buffer of the next frame to write.
		*/
		fifo_frames_t getWriteIndex();

		/**
		* @param numFrames number of frames to advance the write index
		*/
		void advanceWriteIndex(fifo_frames_t numFrames);

		/**
		* You can request that the buffer not be filled above a maximum
		* number of frames.
		* @param threshold effective size of the buffer
		*/
		void setThreshold(fifo_frames_t threshold);

		fifo_frames_t getThreshold() const {
		return mThreshold;
		}

		fifo_frames_t getCapacity() const {
		return mCapacity;
		}


		private:
		fifo_frames_t mCapacity;
		fifo_frames_t mThreshold;
		};

		#endif // FIFO_FIFO_CONTROLLER_BASE_H