Snap for 12265118 from 4deb197f2b1922e429143aec00d6a6d98c2e0286 to 24Q4-release (a0cf0547) · Commits · e / os / android_hardware_interfaces

audio/aidl/default/include/core-impl/StreamStub.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -44,6 +44,10 @@ class StreamStub : public StreamCommonImpl {
		const bool mIsInput;
		bool mIsInitialized = false; // Used for validating the state machine logic.
		bool mIsStandby = true; // Used for validating the state machine logic.

		// Used by the worker thread.
		int64_t mStartTimeNs = 0;
		long mFramesSinceStart = 0;
		};

		class StreamInStub final : public StreamIn, public StreamStub {

audio/aidl/default/stub/StreamStub.cpp

+16 −8

Original line number	Diff line number	Diff line
		@@ -83,7 +83,6 @@ StreamStub::~StreamStub() {
		if (!mIsInitialized) {
		LOG(FATAL) << __func__ << ": must not happen for an uninitialized driver";
		}
		usleep(500);
		mIsStandby = true;
		return ::android::OK;
		}
		@@ -92,8 +91,9 @@ StreamStub::~StreamStub() {
		if (!mIsInitialized) {
		LOG(FATAL) << __func__ << ": must not happen for an uninitialized driver";
		}
		usleep(500);
		mIsStandby = false;
		mStartTimeNs = ::android::uptimeNanos();
		mFramesSinceStart = 0;
		return ::android::OK;
		}

		@@ -105,14 +105,23 @@ StreamStub::~StreamStub() {
		if (mIsStandby) {
		LOG(FATAL) << __func__ << ": must not happen while in standby";
		}
		static constexpr float kMicrosPerSecond = MICROS_PER_SECOND;
		static constexpr float kScaleFactor = .8f;
		*actualFrameCount = frameCount;
		if (mIsAsynchronous) {
		usleep(500);
		} else {
		const size_t delayUs = static_cast<size_t>(
		std::roundf(kScaleFactor * frameCount * kMicrosPerSecond / mSampleRate));
		usleep(delayUs);
		mFramesSinceStart += *actualFrameCount;
		const long bufferDurationUs =
		(actualFrameCount) MICROS_PER_SECOND / mContext.getSampleRate();
		const auto totalDurationUs =
		(::android::uptimeNanos() - mStartTimeNs) / NANOS_PER_MICROSECOND;
		const long totalOffsetUs =
		mFramesSinceStart * MICROS_PER_SECOND / mContext.getSampleRate() - totalDurationUs;
		LOG(VERBOSE) << __func__ << ": totalOffsetUs " << totalOffsetUs;
		if (totalOffsetUs > 0) {
		const long sleepTimeUs = std::min(totalOffsetUs, bufferDurationUs);
		LOG(VERBOSE) << __func__ << ": sleeping for " << sleepTimeUs << " us";
		usleep(sleepTimeUs);
		}
		}
		if (mIsInput) {
		uint8_t* byteBuffer = static_cast<uint8_t*>(buffer);
		@@ -120,7 +129,6 @@ StreamStub::~StreamStub() {
		byteBuffer[i] = std::rand() % 255;
		}
		}
		*actualFrameCount = frameCount;
		return ::android::OK;
		}

compatibility_matrices/compatibility_matrix.202404.xml

+1 −1

Original line number	Diff line number	Diff line
		@@ -28,7 +28,7 @@
		</hal>
		<hal format="aidl">
		<name>android.hardware.audio.sounddose</name>
		<version>1-2</version>
		<version>1-3</version>
		<interface>
		<name>ISoundDoseFactory</name>
		<instance>default</instance>

graphics/composer/aidl/vts/ReadbackVts.cpp

+159 −47

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@

		#include "ReadbackVts.h"
		#include <aidl/android/hardware/graphics/common/BufferUsage.h>
		#include <cmath>
		#include "RenderEngineVts.h"
		#include "renderengine/ExternalTexture.h"
		#include "renderengine/impl/ExternalTexture.h"
		@@ -106,37 +107,72 @@ LayerSettings TestLayer::toRenderEngineLayerSettings() {
		return layerSettings;
		}

		int32_t ReadbackHelper::GetBytesPerPixel(common::PixelFormat pixelFormat) {
		int32_t ReadbackHelper::GetBitsPerChannel(common::PixelFormat pixelFormat) {
		switch (pixelFormat) {
		case common::PixelFormat::RGBA_1010102:
		return 10;
		case common::PixelFormat::RGBA_8888:
		return 4;
		case common::PixelFormat::RGB_888:
		return 3;
		return 8;
		default:
		return -1;
		}
		}

		void ReadbackHelper::fillBuffer(uint32_t width, uint32_t height, uint32_t stride, void* bufferData,
		int32_t ReadbackHelper::GetAlphaBits(common::PixelFormat pixelFormat) {
		switch (pixelFormat) {
		case common::PixelFormat::RGBA_8888:
		return 8;
		case common::PixelFormat::RGBA_1010102:
		return 2;
		case common::PixelFormat::RGB_888:
		return 0;
		default:
		return -1;
		}
		}

		void ReadbackHelper::fillBuffer(uint32_t width, uint32_t height, uint32_t stride,
		int32_t bytesPerPixel, void* bufferData,
		common::PixelFormat pixelFormat,
		std::vector<Color> desiredPixelColors) {
		ASSERT_TRUE(pixelFormat == common::PixelFormat::RGB_888 \|\|
		pixelFormat == common::PixelFormat::RGBA_8888);
		int32_t bytesPerPixel = GetBytesPerPixel(pixelFormat);
		pixelFormat == common::PixelFormat::RGBA_8888 \|\|
		pixelFormat == common::PixelFormat::RGBA_1010102);
		int32_t bitsPerChannel = GetBitsPerChannel(pixelFormat);
		int32_t alphaBits = GetAlphaBits(pixelFormat);
		ASSERT_NE(-1, alphaBits);
		ASSERT_NE(-1, bitsPerChannel);
		ASSERT_NE(-1, bytesPerPixel);
		for (int row = 0; row < height; row++) {
		for (int col = 0; col < width; col++) {
		auto pixel = row * static_cast<int32_t>(width) + col;

		uint32_t maxValue = (1 << bitsPerChannel) - 1;
		uint32_t maxAlphaValue = (1 << alphaBits) - 1;
		for (uint32_t row = 0; row < height; row++) {
		for (uint32_t col = 0; col < width; col++) {
		auto pixel = row * width + col;
		Color srcColor = desiredPixelColors[static_cast<size_t>(pixel)];

		int offset = (row * static_cast<int32_t>(stride) + col) * bytesPerPixel;
		uint8_t* pixelColor = (uint8_t*)bufferData + offset;
		pixelColor[0] = static_cast<uint8_t>(std::round(255.0f * srcColor.r));
		pixelColor[1] = static_cast<uint8_t>(std::round(255.0f * srcColor.g));
		pixelColor[2] = static_cast<uint8_t>(std::round(255.0f * srcColor.b));
		uint32_t offset = (row * stride + col) * static_cast<uint32_t>(bytesPerPixel);

		uint32_t* pixelStart = (uint32_t)((uint8_t)bufferData + offset);

		uint32_t red = static_cast<uint32_t>(std::round(maxValue * srcColor.r));
		uint32_t green = static_cast<uint32_t>(std::round(maxValue * srcColor.g));
		uint32_t blue = static_cast<uint32_t>(std::round(maxValue * srcColor.b));

		if (bytesPerPixel == 4) {
		pixelColor[3] = static_cast<uint8_t>(std::round(255.0f * srcColor.a));
		// Boo we're not word aligned so special case this.
		if (pixelFormat == common::PixelFormat::RGB_888) {
		uint8_t* pixelColor = (uint8_t*)pixelStart;
		pixelColor[0] = static_cast<uint8_t>(red);
		pixelColor[1] = static_cast<uint8_t>(green);
		pixelColor[2] = static_cast<uint8_t>(blue);
		} else {
		uint32_t alpha = static_cast<uint32_t>(std::round(maxAlphaValue * srcColor.a));
		uint32_t color = (alpha << (32 - alphaBits)) \|
		(blue << (32 - alphaBits - bitsPerChannel)) \|
		(green << (32 - alphaBits - bitsPerChannel * 2)) \|
		(red << (32 - alphaBits - bitsPerChannel * 3));
		*pixelStart = color;
		}
		}
		}
		@@ -165,7 +201,8 @@ void ReadbackHelper::fillColorsArea(std::vector<Color>& expectedColors, int32_t
		bool ReadbackHelper::readbackSupported(const common::PixelFormat& pixelFormat,
		const common::Dataspace& dataspace) {
		if (pixelFormat != common::PixelFormat::RGB_888 &&
		pixelFormat != common::PixelFormat::RGBA_8888) {
		pixelFormat != common::PixelFormat::RGBA_8888 &&
		pixelFormat != common::PixelFormat::RGBA_1010102) {
		return false;
		}
		if (std::find(dataspaces.begin(), dataspaces.end(), dataspace) == dataspaces.end()) {
		@@ -175,36 +212,110 @@ bool ReadbackHelper::readbackSupported(const common::PixelFormat& pixelFormat,
		}

		void ReadbackHelper::compareColorBuffers(const std::vector<Color>& expectedColors, void* bufferData,
		const uint32_t stride, const uint32_t width,
		const uint32_t height, common::PixelFormat pixelFormat) {
		const int32_t bytesPerPixel = ReadbackHelper::GetBytesPerPixel(pixelFormat);
		ASSERT_NE(-1, bytesPerPixel);
		for (int row = 0; row < height; row++) {
		for (int col = 0; col < width; col++) {
		auto pixel = row * static_cast<int32_t>(width) + col;
		int offset = (row * static_cast<int32_t>(stride) + col) * bytesPerPixel;
		uint8_t* pixelColor = (uint8_t*)bufferData + offset;
		const uint32_t stride, int32_t bytesPerPixel,
		const uint32_t width, const uint32_t height,
		common::PixelFormat pixelFormat) {
		int32_t bitsPerChannel = GetBitsPerChannel(pixelFormat);
		int32_t alphaBits = GetAlphaBits(pixelFormat);
		ASSERT_GT(bytesPerPixel, 0);
		ASSERT_NE(-1, alphaBits);
		ASSERT_NE(-1, bitsPerChannel);
		uint32_t maxValue = (1 << bitsPerChannel) - 1;
		uint32_t maxAlphaValue = (1 << alphaBits) - 1;
		for (uint32_t row = 0; row < height; row++) {
		for (uint32_t col = 0; col < width; col++) {
		auto pixel = row * width + col;
		const Color expectedColor = expectedColors[static_cast<size_t>(pixel)];
		ASSERT_EQ(std::round(255.0f * expectedColor.r), pixelColor[0]);
		ASSERT_EQ(std::round(255.0f * expectedColor.g), pixelColor[1]);
		ASSERT_EQ(std::round(255.0f * expectedColor.b), pixelColor[2]);

		uint32_t offset = (row * stride + col) * static_cast<uint32_t>(bytesPerPixel);
		uint32_t* pixelStart = (uint32_t)((uint8_t)bufferData + offset);

		uint32_t expectedRed = static_cast<uint32_t>(std::round(maxValue * expectedColor.r));
		uint32_t expectedGreen = static_cast<uint32_t>(std::round(maxValue * expectedColor.g));
		uint32_t expectedBlue = static_cast<uint32_t>(std::round(maxValue * expectedColor.b));

		// Boo we're not word aligned so special case this.
		if (pixelFormat == common::PixelFormat::RGB_888) {
		uint8_t* pixelColor = (uint8_t*)pixelStart;
		ASSERT_EQ(pixelColor[0], static_cast<uint8_t>(expectedRed))
		<< "Red channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(pixelColor[1], static_cast<uint8_t>(expectedGreen))
		<< "Green channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(pixelColor[2], static_cast<uint8_t>(expectedBlue))
		<< "Blue channel mismatch at (" << row << ", " << col << ")";
		} else {
		uint32_t expectedAlpha =
		static_cast<uint32_t>(std::round(maxAlphaValue * expectedColor.a));

		uint32_t actualRed =
		(pixelStart >> (32 - alphaBits - bitsPerChannel 3)) & maxValue;
		uint32_t actualGreen =
		(pixelStart >> (32 - alphaBits - bitsPerChannel 2)) & maxValue;
		uint32_t actualBlue = (*pixelStart >> (32 - alphaBits - bitsPerChannel)) & maxValue;
		uint32_t actualAlpha = (*pixelStart >> (32 - alphaBits)) & maxAlphaValue;

		ASSERT_EQ(expectedRed, actualRed)
		<< "Red channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(expectedGreen, actualGreen)
		<< "Green channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(expectedBlue, actualBlue)
		<< "Blue channel mismatch at (" << row << ", " << col << ")";
		}
		}
		}
		}

		void ReadbackHelper::compareColorBuffers(void* expectedBuffer, void* actualBuffer,
		const uint32_t stride, const uint32_t width,
		const uint32_t height, common::PixelFormat pixelFormat) {
		const int32_t bytesPerPixel = ReadbackHelper::GetBytesPerPixel(pixelFormat);
		ASSERT_NE(-1, bytesPerPixel);
		for (int row = 0; row < height; row++) {
		for (int col = 0; col < width; col++) {
		int offset = (row * static_cast<int32_t>(stride) + col) * bytesPerPixel;
		uint8_t* expectedColor = (uint8_t*)expectedBuffer + offset;
		uint8_t* actualColor = (uint8_t*)actualBuffer + offset;
		ASSERT_EQ(expectedColor[0], actualColor[0]);
		ASSERT_EQ(expectedColor[1], actualColor[1]);
		ASSERT_EQ(expectedColor[2], actualColor[2]);
		const uint32_t stride, int32_t bytesPerPixel,
		const uint32_t width, const uint32_t height,
		common::PixelFormat pixelFormat) {
		int32_t bitsPerChannel = GetBitsPerChannel(pixelFormat);
		int32_t alphaBits = GetAlphaBits(pixelFormat);
		ASSERT_GT(bytesPerPixel, 0);
		ASSERT_NE(-1, alphaBits);
		ASSERT_NE(-1, bitsPerChannel);
		uint32_t maxValue = (1 << bitsPerChannel) - 1;
		uint32_t maxAlphaValue = (1 << alphaBits) - 1;
		for (uint32_t row = 0; row < height; row++) {
		for (uint32_t col = 0; col < width; col++) {
		uint32_t offset = (row * stride + col) * static_cast<uint32_t>(bytesPerPixel);
		uint32_t* expectedStart = (uint32_t)((uint8_t)expectedBuffer + offset);
		uint32_t* actualStart = (uint32_t)((uint8_t)actualBuffer + offset);

		// Boo we're not word aligned so special case this.
		if (pixelFormat == common::PixelFormat::RGB_888) {
		uint8_t* expectedPixel = (uint8_t*)expectedStart;
		uint8_t* actualPixel = (uint8_t*)actualStart;
		ASSERT_EQ(actualPixel[0], expectedPixel[0])
		<< "Red channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(actualPixel[1], expectedPixel[1])
		<< "Green channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(actualPixel[2], expectedPixel[2])
		<< "Blue channel mismatch at (" << row << ", " << col << ")";
		} else {
		uint32_t expectedRed =
		(expectedStart >> (32 - alphaBits - bitsPerChannel 3)) & maxValue;
		uint32_t expectedGreen =
		(expectedStart >> (32 - alphaBits - bitsPerChannel 2)) & maxValue;
		uint32_t expectedBlue =
		(*expectedStart >> (32 - alphaBits - bitsPerChannel)) & maxValue;
		uint32_t expectedAlpha = (*expectedStart >> (32 - alphaBits)) & maxAlphaValue;

		uint32_t actualRed =
		(actualStart >> (32 - alphaBits - bitsPerChannel 3)) & maxValue;
		uint32_t actualGreen =
		(actualStart >> (32 - alphaBits - bitsPerChannel 2)) & maxValue;
		uint32_t actualBlue =
		(*actualStart >> (32 - alphaBits - bitsPerChannel)) & maxValue;
		uint32_t actualAlpha = (*actualStart >> (32 - alphaBits)) & maxAlphaValue;

		ASSERT_EQ(expectedRed, actualRed)
		<< "Red channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(expectedGreen, actualGreen)
		<< "Green channel mismatch at (" << row << ", " << col << ")";
		ASSERT_EQ(expectedBlue, actualBlue)
		<< "Blue channel mismatch at (" << row << ", " << col << ")";
		}
		}
		}
		}
		@@ -258,12 +369,13 @@ void ReadbackBuffer::checkReadbackBuffer(const std::vector<Color>& expectedColor
		auto status = mGraphicBuffer->lockAsync(mUsage, mAccessRegion, &bufData, dup(bufferFence.get()),
		&bytesPerPixel, &bytesPerStride);
		EXPECT_EQ(::android::OK, status);
		ASSERT_TRUE(mPixelFormat == PixelFormat::RGB_888 \|\| mPixelFormat == PixelFormat::RGBA_8888);
		ASSERT_TRUE(mPixelFormat == PixelFormat::RGB_888 \|\| mPixelFormat == PixelFormat::RGBA_8888 \|\|
		mPixelFormat == PixelFormat::RGBA_1010102);
		const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0)
		? static_cast<uint32_t>(bytesPerStride / bytesPerPixel)
		: mGraphicBuffer->getStride();
		ReadbackHelper::compareColorBuffers(expectedColors, bufData, stride, mWidth, mHeight,
		mPixelFormat);
		ReadbackHelper::compareColorBuffers(expectedColors, bufData, stride, bytesPerPixel, mWidth,
		mHeight, mPixelFormat);
		status = mGraphicBuffer->unlock();
		EXPECT_EQ(::android::OK, status);
		}
		@@ -353,8 +465,8 @@ void TestBufferLayer::fillBuffer(std::vector<Color>& expectedColors) {
		? static_cast<uint32_t>(bytesPerStride / bytesPerPixel)
		: mGraphicBuffer->getStride();
		EXPECT_EQ(::android::OK, status);
		ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(mWidth, mHeight, stride, bufData,
		mPixelFormat, expectedColors));
		ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(mWidth, mHeight, stride, bytesPerPixel,
		bufData, mPixelFormat, expectedColors));

		const auto unlockStatus = mGraphicBuffer->unlockAsync(&mFillFence);
		ASSERT_EQ(::android::OK, unlockStatus);

graphics/composer/aidl/vts/ReadbackVts.h

+9 −6

Original line number	Diff line number	Diff line
		@@ -172,10 +172,12 @@ class ReadbackHelper {

		static Dataspace getDataspaceForColorMode(ColorMode mode);

		static int32_t GetBytesPerPixel(PixelFormat pixelFormat);
		static int32_t GetBitsPerChannel(PixelFormat pixelFormat);
		static int32_t GetAlphaBits(PixelFormat pixelFormat);

		static void fillBuffer(uint32_t width, uint32_t height, uint32_t stride, void* bufferData,
		PixelFormat pixelFormat, std::vector<Color> desiredPixelColors);
		static void fillBuffer(uint32_t width, uint32_t height, uint32_t stride, int32_t bytesPerPixel,
		void* bufferData, PixelFormat pixelFormat,
		std::vector<Color> desiredPixelColors);

		static void clearColors(std::vector<Color>& expectedColors, int32_t width, int32_t height,
		int32_t displayWidth);
		@@ -189,11 +191,12 @@ class ReadbackHelper {
		static const std::vector<Dataspace> dataspaces;

		static void compareColorBuffers(const std::vector<Color>& expectedColors, void* bufferData,
		const uint32_t stride, const uint32_t width,
		const uint32_t height, PixelFormat pixelFormat);
		static void compareColorBuffers(void* expectedBuffer, void* actualBuffer, const uint32_t stride,
		const uint32_t stride, int32_t bytesPerPixel,
		const uint32_t width, const uint32_t height,
		PixelFormat pixelFormat);
		static void compareColorBuffers(void* expectedBuffer, void* actualBuffer, const uint32_t stride,
		int32_t bytesPerPixel, const uint32_t width,
		const uint32_t height, PixelFormat pixelFormat);
		};

		class ReadbackBuffer {