media/libaaudio/tests/test_atomic_fifo.cpp - third_party/android/platform/frameworks/av - Git at Google

 /*
  * Copyright (C) 2018 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 <iostream>

 #include <gtest/gtest.h>
 #include <stdlib.h>

 #include "fifo/FifoBuffer.h"
 #include "fifo/FifoController.h"

 using android::fifo_frames_t;
 using android::FifoController;
 using android::FifoBuffer;
 using android::WrappingBuffer;

 //void foo() {
 TEST(test_fifi_controller, fifo_indices) {
     // Values are arbitrary primes designed to trigger edge cases.
     constexpr int capacity = 83;
     constexpr int threshold = 47;
     FifoController   fifoController(capacity, threshold);
     ASSERT_EQ(capacity, fifoController.getCapacity());
     ASSERT_EQ(threshold, fifoController.getThreshold());

     ASSERT_EQ(0, fifoController.getReadCounter());
     ASSERT_EQ(0, fifoController.getWriteCounter());
     ASSERT_EQ(0, fifoController.getFullFramesAvailable());
     ASSERT_EQ(threshold, fifoController.getEmptyFramesAvailable());

     // Pretend to write some data.
     constexpr int advance1 = 23;
     fifoController.advanceWriteIndex(advance1);
     int advanced = advance1;
     ASSERT_EQ(0, fifoController.getReadCounter());
     ASSERT_EQ(0, fifoController.getReadIndex());
     ASSERT_EQ(advanced, fifoController.getWriteCounter());
     ASSERT_EQ(advanced, fifoController.getWriteIndex());
     ASSERT_EQ(advanced, fifoController.getFullFramesAvailable());
     ASSERT_EQ(threshold - advanced, fifoController.getEmptyFramesAvailable());

     // Pretend to read the data.
     fifoController.advanceReadIndex(advance1);
     ASSERT_EQ(advanced, fifoController.getReadCounter());
     ASSERT_EQ(advanced, fifoController.getReadIndex());
     ASSERT_EQ(advanced, fifoController.getWriteCounter());
     ASSERT_EQ(advanced, fifoController.getWriteIndex());
     ASSERT_EQ(0, fifoController.getFullFramesAvailable());
     ASSERT_EQ(threshold, fifoController.getEmptyFramesAvailable());

     // Write past end of buffer.
     constexpr int advance2 = 13 + capacity - advance1;
     fifoController.advanceWriteIndex(advance2);
     advanced += advance2;
     ASSERT_EQ(advance1, fifoController.getReadCounter());
     ASSERT_EQ(advance1, fifoController.getReadIndex());
     ASSERT_EQ(advanced, fifoController.getWriteCounter());
     ASSERT_EQ(advanced - capacity, fifoController.getWriteIndex());
     ASSERT_EQ(advance2, fifoController.getFullFramesAvailable());
     ASSERT_EQ(threshold - advance2, fifoController.getEmptyFramesAvailable());
 }

 // TODO consider using a template for other data types.
 class TestFifoBuffer {
 public:
     explicit TestFifoBuffer(fifo_frames_t capacity, fifo_frames_t threshold = 0)
         : mFifoBuffer(sizeof(int16_t), capacity) {
         // For reading and writing.
         mData = new int16_t[capacity];
         if (threshold <= 0) {
             threshold = capacity;
         }
         mFifoBuffer.setThreshold(threshold);
         mThreshold = threshold;
     }

     void checkMisc() {
         ASSERT_EQ((int32_t)(2 * sizeof(int16_t)), mFifoBuffer.convertFramesToBytes(2));
         ASSERT_EQ(mThreshold, mFifoBuffer.getThreshold());
     }

     // Verify that the available frames in each part add up correctly.
     void checkWrappingBuffer() {
         WrappingBuffer wrappingBuffer;
         fifo_frames_t framesAvailable =
                 mFifoBuffer.getFifoControllerBase()->getEmptyFramesAvailable();
         fifo_frames_t wrapAvailable = mFifoBuffer.getEmptyRoomAvailable(&wrappingBuffer);
         EXPECT_EQ(framesAvailable, wrapAvailable);
         fifo_frames_t bothAvailable = wrappingBuffer.numFrames[0] + wrappingBuffer.numFrames[1];
         EXPECT_EQ(framesAvailable, bothAvailable);

         framesAvailable =
                 mFifoBuffer.getFifoControllerBase()->getFullFramesAvailable();
         wrapAvailable = mFifoBuffer.getFullDataAvailable(&wrappingBuffer);
         EXPECT_EQ(framesAvailable, wrapAvailable);
         bothAvailable = wrappingBuffer.numFrames[0] + wrappingBuffer.numFrames[1];
         EXPECT_EQ(framesAvailable, bothAvailable);
     }

     // Write data but do not overflow.
     void writeData(fifo_frames_t numFrames) {
         fifo_frames_t framesAvailable =
                 mFifoBuffer.getFifoControllerBase()->getEmptyFramesAvailable();
         fifo_frames_t framesToWrite = std::min(framesAvailable, numFrames);
         for (int i = 0; i < framesToWrite; i++) {
             mData[i] = mNextWriteIndex++;
         }
         fifo_frames_t actual = mFifoBuffer.write(mData, framesToWrite);
         ASSERT_EQ(framesToWrite, actual);
     }

     // Read data but do not underflow.
     void verifyData(fifo_frames_t numFrames) {
         fifo_frames_t framesAvailable =
                 mFifoBuffer.getFifoControllerBase()->getFullFramesAvailable();
         fifo_frames_t framesToRead = std::min(framesAvailable, numFrames);
         fifo_frames_t actual = mFifoBuffer.read(mData, framesToRead);
         ASSERT_EQ(framesToRead, actual);
         for (int i = 0; i < framesToRead; i++) {
             ASSERT_EQ(mNextVerifyIndex++, mData[i]);
         }
     }

     // Wrap around the end of the buffer.
     void checkWrappingWriteRead() {
         constexpr int frames1 = 43;
         constexpr int frames2 = 15;

         writeData(frames1);
         checkWrappingBuffer();
         verifyData(frames1);
         checkWrappingBuffer();

         writeData(frames2);
         checkWrappingBuffer();
         verifyData(frames2);
         checkWrappingBuffer();
     }

     // Write and Read a specific amount of data.
     void checkWriteRead() {
         const fifo_frames_t capacity = mFifoBuffer.getBufferCapacityInFrames();
         // Wrap around with the smaller region in the second half.
         const int frames1 = capacity - 4;
         const int frames2 = 7; // arbitrary, small
         writeData(frames1);
         verifyData(frames1);
         writeData(frames2);
         verifyData(frames2);
     }

     // Write and Read a specific amount of data.
     void checkWriteReadSmallLarge() {
         const fifo_frames_t capacity = mFifoBuffer.getBufferCapacityInFrames();
         // Wrap around with the larger region in the second half.
         const int frames1 = capacity - 4;
         const int frames2 = capacity - 9; // arbitrary, large
         writeData(frames1);
         verifyData(frames1);
         writeData(frames2);
         verifyData(frames2);
     }

     // Randomly read or write up to the maximum amount of data.
     void checkRandomWriteRead() {
         for (int i = 0; i < 20; i++) {
             fifo_frames_t framesEmpty =
                     mFifoBuffer.getFifoControllerBase()->getEmptyFramesAvailable();
             fifo_frames_t numFrames = (fifo_frames_t)(drand48() * framesEmpty);
             writeData(numFrames);

             fifo_frames_t framesFull =
                     mFifoBuffer.getFifoControllerBase()->getFullFramesAvailable();
             numFrames = (fifo_frames_t)(drand48() * framesFull);
             verifyData(numFrames);
         }
     }

     FifoBuffer     mFifoBuffer;
     int16_t       *mData;
     fifo_frames_t  mNextWriteIndex = 0;
     fifo_frames_t  mNextVerifyIndex = 0;
     fifo_frames_t  mThreshold;
 };

 TEST(test_fifo_buffer, fifo_read_write) {
     constexpr int capacity = 51; // arbitrary
     TestFifoBuffer tester(capacity);
     tester.checkMisc();
     tester.checkWriteRead();
 }

 TEST(test_fifo_buffer, fifo_wrapping_read_write) {
     constexpr int capacity = 59; // arbitrary, a little bigger this time
     TestFifoBuffer tester(capacity);
     tester.checkWrappingWriteRead();
 }

 TEST(test_fifo_buffer, fifo_read_write_small_large) {
     constexpr int capacity = 51; // arbitrary
     TestFifoBuffer tester(capacity);
     tester.checkWriteReadSmallLarge();
 }

 TEST(test_fifo_buffer, fifo_random_read_write) {
     constexpr int capacity = 51; // arbitrary
     TestFifoBuffer tester(capacity);
     tester.checkRandomWriteRead();
 }

 TEST(test_fifo_buffer, fifo_random_threshold) {
     constexpr int capacity = 67; // arbitrary
     constexpr int threshold = 37; // arbitrary
     TestFifoBuffer tester(capacity, threshold);
     tester.checkRandomWriteRead();
 }
	/*
	* Copyright (C) 2018 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 <iostream>

	#include <gtest/gtest.h>
	#include <stdlib.h>

	#include "fifo/FifoBuffer.h"
	#include "fifo/FifoController.h"

	using android::fifo_frames_t;
	using android::FifoController;
	using android::FifoBuffer;
	using android::WrappingBuffer;

	//void foo() {
	TEST(test_fifi_controller, fifo_indices) {
	// Values are arbitrary primes designed to trigger edge cases.
	constexpr int capacity = 83;
	constexpr int threshold = 47;
	FifoController fifoController(capacity, threshold);
	ASSERT_EQ(capacity, fifoController.getCapacity());
	ASSERT_EQ(threshold, fifoController.getThreshold());

	ASSERT_EQ(0, fifoController.getReadCounter());
	ASSERT_EQ(0, fifoController.getWriteCounter());
	ASSERT_EQ(0, fifoController.getFullFramesAvailable());
	ASSERT_EQ(threshold, fifoController.getEmptyFramesAvailable());

	// Pretend to write some data.
	constexpr int advance1 = 23;
	fifoController.advanceWriteIndex(advance1);
	int advanced = advance1;
	ASSERT_EQ(0, fifoController.getReadCounter());
	ASSERT_EQ(0, fifoController.getReadIndex());
	ASSERT_EQ(advanced, fifoController.getWriteCounter());
	ASSERT_EQ(advanced, fifoController.getWriteIndex());
	ASSERT_EQ(advanced, fifoController.getFullFramesAvailable());
	ASSERT_EQ(threshold - advanced, fifoController.getEmptyFramesAvailable());

	// Pretend to read the data.
	fifoController.advanceReadIndex(advance1);
	ASSERT_EQ(advanced, fifoController.getReadCounter());
	ASSERT_EQ(advanced, fifoController.getReadIndex());
	ASSERT_EQ(advanced, fifoController.getWriteCounter());
	ASSERT_EQ(advanced, fifoController.getWriteIndex());
	ASSERT_EQ(0, fifoController.getFullFramesAvailable());
	ASSERT_EQ(threshold, fifoController.getEmptyFramesAvailable());

	// Write past end of buffer.
	constexpr int advance2 = 13 + capacity - advance1;
	fifoController.advanceWriteIndex(advance2);
	advanced += advance2;
	ASSERT_EQ(advance1, fifoController.getReadCounter());
	ASSERT_EQ(advance1, fifoController.getReadIndex());
	ASSERT_EQ(advanced, fifoController.getWriteCounter());
	ASSERT_EQ(advanced - capacity, fifoController.getWriteIndex());
	ASSERT_EQ(advance2, fifoController.getFullFramesAvailable());
	ASSERT_EQ(threshold - advance2, fifoController.getEmptyFramesAvailable());
	}

	// TODO consider using a template for other data types.
	class TestFifoBuffer {
	public:
	explicit TestFifoBuffer(fifo_frames_t capacity, fifo_frames_t threshold = 0)
	: mFifoBuffer(sizeof(int16_t), capacity) {
	// For reading and writing.
	mData = new int16_t[capacity];
	if (threshold <= 0) {
	threshold = capacity;
	}
	mFifoBuffer.setThreshold(threshold);
	mThreshold = threshold;
	}

	void checkMisc() {
	ASSERT_EQ((int32_t)(2 * sizeof(int16_t)), mFifoBuffer.convertFramesToBytes(2));
	ASSERT_EQ(mThreshold, mFifoBuffer.getThreshold());
	}

	// Verify that the available frames in each part add up correctly.
	void checkWrappingBuffer() {
	WrappingBuffer wrappingBuffer;
	fifo_frames_t framesAvailable =
	mFifoBuffer.getFifoControllerBase()->getEmptyFramesAvailable();
	fifo_frames_t wrapAvailable = mFifoBuffer.getEmptyRoomAvailable(&wrappingBuffer);
	EXPECT_EQ(framesAvailable, wrapAvailable);
	fifo_frames_t bothAvailable = wrappingBuffer.numFrames[0] + wrappingBuffer.numFrames[1];
	EXPECT_EQ(framesAvailable, bothAvailable);

	framesAvailable =
	mFifoBuffer.getFifoControllerBase()->getFullFramesAvailable();
	wrapAvailable = mFifoBuffer.getFullDataAvailable(&wrappingBuffer);
	EXPECT_EQ(framesAvailable, wrapAvailable);
	bothAvailable = wrappingBuffer.numFrames[0] + wrappingBuffer.numFrames[1];
	EXPECT_EQ(framesAvailable, bothAvailable);
	}

	// Write data but do not overflow.
	void writeData(fifo_frames_t numFrames) {
	fifo_frames_t framesAvailable =
	mFifoBuffer.getFifoControllerBase()->getEmptyFramesAvailable();
	fifo_frames_t framesToWrite = std::min(framesAvailable, numFrames);
	for (int i = 0; i < framesToWrite; i++) {
	mData[i] = mNextWriteIndex++;
	}
	fifo_frames_t actual = mFifoBuffer.write(mData, framesToWrite);
	ASSERT_EQ(framesToWrite, actual);
	}

	// Read data but do not underflow.
	void verifyData(fifo_frames_t numFrames) {
	fifo_frames_t framesAvailable =
	mFifoBuffer.getFifoControllerBase()->getFullFramesAvailable();
	fifo_frames_t framesToRead = std::min(framesAvailable, numFrames);
	fifo_frames_t actual = mFifoBuffer.read(mData, framesToRead);
	ASSERT_EQ(framesToRead, actual);
	for (int i = 0; i < framesToRead; i++) {
	ASSERT_EQ(mNextVerifyIndex++, mData[i]);
	}
	}

	// Wrap around the end of the buffer.
	void checkWrappingWriteRead() {
	constexpr int frames1 = 43;
	constexpr int frames2 = 15;

	writeData(frames1);
	checkWrappingBuffer();
	verifyData(frames1);
	checkWrappingBuffer();

	writeData(frames2);
	checkWrappingBuffer();
	verifyData(frames2);
	checkWrappingBuffer();
	}

	// Write and Read a specific amount of data.
	void checkWriteRead() {
	const fifo_frames_t capacity = mFifoBuffer.getBufferCapacityInFrames();
	// Wrap around with the smaller region in the second half.
	const int frames1 = capacity - 4;
	const int frames2 = 7; // arbitrary, small
	writeData(frames1);
	verifyData(frames1);
	writeData(frames2);
	verifyData(frames2);
	}

	// Write and Read a specific amount of data.
	void checkWriteReadSmallLarge() {
	const fifo_frames_t capacity = mFifoBuffer.getBufferCapacityInFrames();
	// Wrap around with the larger region in the second half.
	const int frames1 = capacity - 4;
	const int frames2 = capacity - 9; // arbitrary, large
	writeData(frames1);
	verifyData(frames1);
	writeData(frames2);
	verifyData(frames2);
	}

	// Randomly read or write up to the maximum amount of data.
	void checkRandomWriteRead() {
	for (int i = 0; i < 20; i++) {
	fifo_frames_t framesEmpty =
	mFifoBuffer.getFifoControllerBase()->getEmptyFramesAvailable();
	fifo_frames_t numFrames = (fifo_frames_t)(drand48() * framesEmpty);
	writeData(numFrames);

	fifo_frames_t framesFull =
	mFifoBuffer.getFifoControllerBase()->getFullFramesAvailable();
	numFrames = (fifo_frames_t)(drand48() * framesFull);
	verifyData(numFrames);
	}
	}

	FifoBuffer mFifoBuffer;
	int16_t *mData;
	fifo_frames_t mNextWriteIndex = 0;
	fifo_frames_t mNextVerifyIndex = 0;
	fifo_frames_t mThreshold;
	};

	TEST(test_fifo_buffer, fifo_read_write) {
	constexpr int capacity = 51; // arbitrary
	TestFifoBuffer tester(capacity);
	tester.checkMisc();
	tester.checkWriteRead();
	}

	TEST(test_fifo_buffer, fifo_wrapping_read_write) {
	constexpr int capacity = 59; // arbitrary, a little bigger this time
	TestFifoBuffer tester(capacity);
	tester.checkWrappingWriteRead();
	}

	TEST(test_fifo_buffer, fifo_read_write_small_large) {
	constexpr int capacity = 51; // arbitrary
	TestFifoBuffer tester(capacity);
	tester.checkWriteReadSmallLarge();
	}

	TEST(test_fifo_buffer, fifo_random_read_write) {
	constexpr int capacity = 51; // arbitrary
	TestFifoBuffer tester(capacity);
	tester.checkRandomWriteRead();
	}

	TEST(test_fifo_buffer, fifo_random_threshold) {
	constexpr int capacity = 67; // arbitrary
	constexpr int threshold = 37; // arbitrary
	TestFifoBuffer tester(capacity, threshold);
	tester.checkRandomWriteRead();
	}