cpp/surround_view/service-impl/SurroundView3dSessionTests.cpp - platform/packages/services/Car - Gitiles

 /*
  * Copyright 2020 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 "SurroundView3dSessionTests"

 #include "AnimationModule.h"
 #include "IOModule.h"
 #include "SurroundView3dSession.h"
 #include "VhalHandler.h"
 #include "mock-evs/MockEvsEnumerator.h"
 #include "mock-evs/MockSurroundViewCallback.h"

 #include <android-base/logging.h>
 #include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
 #include <android/hidl/allocator/1.0/IAllocator.h>
 #include <android/hidl/memory/1.0/IMemory.h>
 #include <gtest/gtest.h>
 #include <hidlmemory/mapping.h>

 #include <time.h>

 namespace android {
 namespace hardware {
 namespace automotive {
 namespace sv {
 namespace V1_0 {
 namespace implementation {
 namespace {

 using ::android::sp;
 using ::android::hardware::hidl_memory;
 using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
 using ::android::hardware::automotive::sv::V1_0::OverlayMemoryDesc;
 using ::android::hidl::allocator::V1_0::IAllocator;
 using ::android::hidl::memory::V1_0::IMemory;

 const char* kSvConfigFilename = "vendor/etc/automotive/sv/sv_sample_config.xml";

 // Sv 3D output height and width set by the config file.
 const int kSv3dWidth = 1920;
 const int kSv3dHeight = 1080;

 // Constants for overlays.
 const int kVertexByteSize = (3 * sizeof(float)) + 4;
 const int kIdByteSize = 2;

 class SurroundView3dSessionTests : public ::testing::Test {
 protected:
     // Setup sv3d session without vhal and animations.
     void SetupSv3dSession() {
         mFakeEvs = new MockEvsEnumerator();
         mIoModule = new IOModule(kSvConfigFilename);
         EXPECT_EQ(mIoModule->initialize(), IOStatus::OK);

         mIoModule->getConfig(&mIoModuleConfig);

         mSv3dSession = new SurroundView3dSession(mFakeEvs, nullptr,
                                                  nullptr,
                                                  &mIoModuleConfig);

         EXPECT_TRUE(mSv3dSession->initialize());
         mSv3dCallback = new MockSurroundViewCallback(mSv3dSession);
         vector<View3d> views = {
         {
             .viewId = 0,
             .pose = {
                 .rotation = {.x = 0, .y = 0, .z = 0, .w = 1.0f},
                 .translation = {.x = 0, .y = 0, .z = 0},
             },
             .horizontalFov = 90,
         }};
         mSv3dSession->setViews(views);
     }

     // Setup sv3d session with vhal and animations.
     void SetupSv3dSessionVhalAnimation() {
         mFakeEvs = new MockEvsEnumerator();
         mIoModule = new IOModule(kSvConfigFilename);
         EXPECT_EQ(mIoModule->initialize(), IOStatus::OK);

         mIoModule->getConfig(&mIoModuleConfig);

         mVhalHandler = new VhalHandler();
         ASSERT_TRUE(mVhalHandler->initialize(VhalHandler::UpdateMethod::GET, 10));

         mAnimationModule = new AnimationModule(mIoModuleConfig.carModelConfig.carModel.partsMap,
                                     mIoModuleConfig.carModelConfig.carModel.texturesMap,
                                     mIoModuleConfig.carModelConfig.animationConfig.animations);

         const std::vector<uint64_t> animationPropertiesToRead =
                 getAnimationPropertiesToRead(mIoModuleConfig.carModelConfig.animationConfig);
         ASSERT_TRUE(mVhalHandler->setPropertiesToRead(animationPropertiesToRead));

         mSv3dSessionAnimations = new SurroundView3dSession(mFakeEvs, mVhalHandler,
                                                  mAnimationModule,
                                                  &mIoModuleConfig);

         EXPECT_TRUE(mSv3dSessionAnimations->initialize());

         mSv3dCallbackAnimations = new MockSurroundViewCallback(mSv3dSessionAnimations);
         vector<View3d> views = {
         // View 0
         {
             .viewId = 0,
             .pose = {
                 .rotation = {.x = 0, .y = 0, .z = 0, .w = 1.0f},
                 .translation = {.x = 0, .y = 0, .z = 0},
             },
             .horizontalFov = 90,
         }};

         mSv3dSessionAnimations->setViews(views);
     }

     // Helper function to get list of vhal properties to read from car config file for animations.
     std::vector<uint64_t> getAnimationPropertiesToRead(const AnimationConfig& animationConfig) {
         std::set<uint64_t> propertiesSet;
         for (const auto& animation : animationConfig.animations) {
             for (const auto& opPair : animation.gammaOpsMap) {
                 propertiesSet.insert(opPair.first);
             }

             for (const auto& opPair : animation.textureOpsMap) {
                 propertiesSet.insert(opPair.first);
             }

             for (const auto& opPair : animation.rotationOpsMap) {
                 propertiesSet.insert(opPair.first);
             }

             for (const auto& opPair : animation.translationOpsMap) {
                 propertiesSet.insert(opPair.first);
             }
         }
         std::vector<uint64_t> propertiesToRead;
         propertiesToRead.assign(propertiesSet.begin(), propertiesSet.end());
         return propertiesToRead;
     }

     void TearDown() override {
         mSv3dSession = nullptr;
         mFakeEvs = nullptr;
         mSv3dCallback = nullptr;
         delete mVhalHandler;
         delete mAnimationModule;
         delete mIoModule;
     }

     sp<IEvsEnumerator> mFakeEvs;
     IOModule* mIoModule;
     IOModuleConfig mIoModuleConfig;
     sp<SurroundView3dSession> mSv3dSession;
     sp<MockSurroundViewCallback> mSv3dCallback;

     VhalHandler* mVhalHandler;
     AnimationModule* mAnimationModule;
     sp<SurroundView3dSession> mSv3dSessionAnimations;
     sp<MockSurroundViewCallback> mSv3dCallbackAnimations;
 };

 TEST_F(SurroundView3dSessionTests, startAndStop3dSession) {
     SetupSv3dSession();
     EXPECT_EQ(mSv3dSession->startStream(mSv3dCallback), SvResult::OK);
     sleep(5);
     mSv3dSession->stopStream();
     EXPECT_GT(mSv3dCallback->getReceivedFramesCount(), 0);
 }

 TEST_F(SurroundView3dSessionTests, get3dConfigSuccess) {
     SetupSv3dSession();
     Sv3dConfig sv3dConfig;
     mSv3dSession->get3dConfig([&sv3dConfig](const Sv3dConfig& config) { sv3dConfig = config; });

     EXPECT_EQ(sv3dConfig.width, kSv3dWidth);
     EXPECT_EQ(sv3dConfig.height, kSv3dHeight);
     EXPECT_EQ(sv3dConfig.carDetails, SvQuality::HIGH);
 }

 // Sets a different config and checks of the received config matches.
 TEST_F(SurroundView3dSessionTests, setAndGet3dConfigSuccess) {
     SetupSv3dSession();
     Sv3dConfig sv3dConfigSet = {kSv3dWidth / 2, kSv3dHeight / 2, SvQuality::LOW};

     EXPECT_EQ(mSv3dSession->set3dConfig(sv3dConfigSet), SvResult::OK);

     Sv3dConfig sv3dConfigReceived;
     mSv3dSession->get3dConfig(
             [&sv3dConfigReceived](const Sv3dConfig& config) { sv3dConfigReceived = config; });

     EXPECT_EQ(sv3dConfigReceived.width, sv3dConfigSet.width);
     EXPECT_EQ(sv3dConfigReceived.height, sv3dConfigSet.height);
     EXPECT_EQ(sv3dConfigReceived.carDetails, sv3dConfigSet.carDetails);
 }

 // Projects center of each cameras and checks if valid projected point is received.
 TEST_F(SurroundView3dSessionTests, projectPoints3dSuccess) {
     SetupSv3dSession();
     hidl_vec<Point2dInt> points2dCamera = {
             /*Center point*/ {.x = kSv3dWidth / 2, .y = kSv3dHeight / 2}};

     std::vector<hidl_string> cameraIds = {"/dev/video60", "/dev/video61", "/dev/video62",
                                           "/dev/video63"};

     for (int i = 0; i < cameraIds.size(); i++) {
         mSv3dSession
                 ->projectCameraPointsTo3dSurface(points2dCamera, cameraIds[i],
                                                  [](const hidl_vec<Point3dFloat>& projectedPoints) {
                                                      EXPECT_TRUE(projectedPoints[0].isValid);
                                                  });
     }
 }

 std::pair<hidl_memory, sp<IMemory>> GetMappedSharedMemory(int bytesSize) {
     const auto nullResult = std::make_pair(hidl_memory(), nullptr);

     sp<IAllocator> ashmemAllocator = IAllocator::getService("ashmem");
     if (ashmemAllocator.get() == nullptr) {
         return nullResult;
     }

     // Allocate shared memory.
     hidl_memory hidlMemory;
     bool allocateSuccess = false;
     Return<void> result =
             ashmemAllocator->allocate(bytesSize, [&](bool success, const hidl_memory& hidlMem) {
                 if (!success) {
                     return;
                 }
                 allocateSuccess = success;
                 hidlMemory = hidlMem;
             });

     // Check result of allocated memory.
     if (!result.isOk() || !allocateSuccess) {
         return nullResult;
     }

     // Map shared memory.
     sp<IMemory> pIMemory = mapMemory(hidlMemory);
     if (pIMemory.get() == nullptr) {
         return nullResult;
     }

     return std::make_pair(hidlMemory, pIMemory);
 }

 void SetIndexOfOverlaysMemory(const std::vector<OverlayMemoryDesc>& overlaysMemDesc,
                               sp<IMemory> pIMemory, int indexPosition, uint16_t indexValue) {
     // Count the number of vertices until the index.
     int totalVerticesCount = 0;
     for (int i = 0; i < indexPosition; i++) {
         totalVerticesCount += overlaysMemDesc[i].verticesCount;
     }

     const int indexBytePosition =
             (indexPosition * kIdByteSize) + (kVertexByteSize * totalVerticesCount);

     uint8_t* pSharedMemoryData = reinterpret_cast<uint8_t*>((void*)pIMemory->getPointer());
     pSharedMemoryData += indexBytePosition;
     uint16_t* pIndex16bit = reinterpret_cast<uint16_t*>(pSharedMemoryData);

     // Modify shared memory.
     pIMemory->update();
     *pIndex16bit = indexValue;
     pIMemory->commit();
 }

 std::pair<OverlaysData, sp<IMemory>> GetSampleOverlaysData() {
     OverlaysData overlaysData;
     overlaysData.overlaysMemoryDesc.resize(2);

     int sharedMemBytesSize = 0;
     OverlayMemoryDesc overlayMemDesc1, overlayMemDesc2;
     overlayMemDesc1.id = 0;
     overlayMemDesc1.verticesCount = 6;
     overlayMemDesc1.overlayPrimitive = OverlayPrimitive::TRIANGLES;
     overlaysData.overlaysMemoryDesc[0] = overlayMemDesc1;
     sharedMemBytesSize += kIdByteSize + kVertexByteSize * overlayMemDesc1.verticesCount;

     overlayMemDesc2.id = 1;
     overlayMemDesc2.verticesCount = 4;
     overlayMemDesc2.overlayPrimitive = OverlayPrimitive::TRIANGLES_STRIP;
     overlaysData.overlaysMemoryDesc[1] = overlayMemDesc2;
     sharedMemBytesSize += kIdByteSize + kVertexByteSize * overlayMemDesc2.verticesCount;

     std::pair<hidl_memory, sp<IMemory>> sharedMem = GetMappedSharedMemory(sharedMemBytesSize);
     sp<IMemory> pIMemory = sharedMem.second;
     if (pIMemory.get() == nullptr) {
         return std::make_pair(OverlaysData(), nullptr);
     }

     // Get pointer to shared memory data and set all bytes to 0.
     uint8_t* pSharedMemoryData = reinterpret_cast<uint8_t*>((void*)pIMemory->getPointer());
     pIMemory->update();
     memset(pSharedMemoryData, 0, sharedMemBytesSize);
     pIMemory->commit();

     std::vector<OverlayMemoryDesc> overlaysDesc = {overlayMemDesc1, overlayMemDesc2};

     // Set indexes in shared memory.
     SetIndexOfOverlaysMemory(overlaysDesc, pIMemory, 0, overlayMemDesc1.id);
     SetIndexOfOverlaysMemory(overlaysDesc, pIMemory, 1, overlayMemDesc2.id);

     overlaysData.overlaysMemoryDesc = overlaysDesc;
     overlaysData.overlaysMemory = sharedMem.first;

     return std::make_pair(overlaysData, pIMemory);
 }

 // Verifies a valid overlay can be updated while streaming.
 TEST_F(SurroundView3dSessionTests, updateOverlaysSuccess) {
     SetupSv3dSession();
     std::pair<OverlaysData, sp<IMemory>> overlaysData = GetSampleOverlaysData();
     ASSERT_NE(overlaysData.second, nullptr);
     EXPECT_EQ(mSv3dSession->startStream(mSv3dCallback), SvResult::OK);
     SvResult result = mSv3dSession->updateOverlays(overlaysData.first);
     mSv3dSession->stopStream();
     EXPECT_EQ(result, SvResult::OK);
 }

 // Setup sv 3d sessin with vhal and animations and verify frames are received successfully.
 TEST_F(SurroundView3dSessionTests, vhalAnimationSuccess) {
     SetupSv3dSessionVhalAnimation();
     EXPECT_EQ(mSv3dSessionAnimations->startStream(mSv3dCallbackAnimations), SvResult::OK);
     sleep(5);
     mSv3dSessionAnimations->stopStream();
     EXPECT_GT(mSv3dCallbackAnimations->getReceivedFramesCount(), 0);
 }

 }  // namespace
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace sv
 }  // namespace automotive
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright 2020 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 "SurroundView3dSessionTests"

	#include "AnimationModule.h"
	#include "IOModule.h"
	#include "SurroundView3dSession.h"
	#include "VhalHandler.h"
	#include "mock-evs/MockEvsEnumerator.h"
	#include "mock-evs/MockSurroundViewCallback.h"

	#include <android-base/logging.h>
	#include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
	#include <android/hidl/allocator/1.0/IAllocator.h>
	#include <android/hidl/memory/1.0/IMemory.h>
	#include <gtest/gtest.h>
	#include <hidlmemory/mapping.h>

	#include <time.h>

	namespace android {
	namespace hardware {
	namespace automotive {
	namespace sv {
	namespace V1_0 {
	namespace implementation {
	namespace {

	using ::android::sp;
	using ::android::hardware::hidl_memory;
	using ::android::hardware::hidl_string;
	using ::android::hardware::hidl_vec;
	using ::android::hardware::automotive::sv::V1_0::OverlayMemoryDesc;
	using ::android::hidl::allocator::V1_0::IAllocator;
	using ::android::hidl::memory::V1_0::IMemory;

	const char* kSvConfigFilename = "vendor/etc/automotive/sv/sv_sample_config.xml";

	// Sv 3D output height and width set by the config file.
	const int kSv3dWidth = 1920;
	const int kSv3dHeight = 1080;

	// Constants for overlays.
	const int kVertexByteSize = (3 * sizeof(float)) + 4;
	const int kIdByteSize = 2;

	class SurroundView3dSessionTests : public ::testing::Test {
	protected:
	// Setup sv3d session without vhal and animations.
	void SetupSv3dSession() {
	mFakeEvs = new MockEvsEnumerator();
	mIoModule = new IOModule(kSvConfigFilename);
	EXPECT_EQ(mIoModule->initialize(), IOStatus::OK);

	mIoModule->getConfig(&mIoModuleConfig);

	mSv3dSession = new SurroundView3dSession(mFakeEvs, nullptr,
	nullptr,
	&mIoModuleConfig);

	EXPECT_TRUE(mSv3dSession->initialize());
	mSv3dCallback = new MockSurroundViewCallback(mSv3dSession);
	vector<View3d> views = {
	{
	.viewId = 0,
	.pose = {
	.rotation = {.x = 0, .y = 0, .z = 0, .w = 1.0f},
	.translation = {.x = 0, .y = 0, .z = 0},
	},
	.horizontalFov = 90,
	}};
	mSv3dSession->setViews(views);
	}

	// Setup sv3d session with vhal and animations.
	void SetupSv3dSessionVhalAnimation() {
	mFakeEvs = new MockEvsEnumerator();
	mIoModule = new IOModule(kSvConfigFilename);
	EXPECT_EQ(mIoModule->initialize(), IOStatus::OK);

	mIoModule->getConfig(&mIoModuleConfig);

	mVhalHandler = new VhalHandler();
	ASSERT_TRUE(mVhalHandler->initialize(VhalHandler::UpdateMethod::GET, 10));

	mAnimationModule = new AnimationModule(mIoModuleConfig.carModelConfig.carModel.partsMap,
	mIoModuleConfig.carModelConfig.carModel.texturesMap,
	mIoModuleConfig.carModelConfig.animationConfig.animations);

	const std::vector<uint64_t> animationPropertiesToRead =
	getAnimationPropertiesToRead(mIoModuleConfig.carModelConfig.animationConfig);
	ASSERT_TRUE(mVhalHandler->setPropertiesToRead(animationPropertiesToRead));

	mSv3dSessionAnimations = new SurroundView3dSession(mFakeEvs, mVhalHandler,
	mAnimationModule,
	&mIoModuleConfig);

	EXPECT_TRUE(mSv3dSessionAnimations->initialize());

	mSv3dCallbackAnimations = new MockSurroundViewCallback(mSv3dSessionAnimations);
	vector<View3d> views = {
	// View 0
	{
	.viewId = 0,
	.pose = {
	.rotation = {.x = 0, .y = 0, .z = 0, .w = 1.0f},
	.translation = {.x = 0, .y = 0, .z = 0},
	},
	.horizontalFov = 90,
	}};

	mSv3dSessionAnimations->setViews(views);
	}

	// Helper function to get list of vhal properties to read from car config file for animations.
	std::vector<uint64_t> getAnimationPropertiesToRead(const AnimationConfig& animationConfig) {
	std::set<uint64_t> propertiesSet;
	for (const auto& animation : animationConfig.animations) {
	for (const auto& opPair : animation.gammaOpsMap) {
	propertiesSet.insert(opPair.first);
	}

	for (const auto& opPair : animation.textureOpsMap) {
	propertiesSet.insert(opPair.first);
	}

	for (const auto& opPair : animation.rotationOpsMap) {
	propertiesSet.insert(opPair.first);
	}

	for (const auto& opPair : animation.translationOpsMap) {
	propertiesSet.insert(opPair.first);
	}
	}
	std::vector<uint64_t> propertiesToRead;
	propertiesToRead.assign(propertiesSet.begin(), propertiesSet.end());
	return propertiesToRead;
	}

	void TearDown() override {
	mSv3dSession = nullptr;
	mFakeEvs = nullptr;
	mSv3dCallback = nullptr;
	delete mVhalHandler;
	delete mAnimationModule;
	delete mIoModule;
	}

	sp<IEvsEnumerator> mFakeEvs;
	IOModule* mIoModule;
	IOModuleConfig mIoModuleConfig;
	sp<SurroundView3dSession> mSv3dSession;
	sp<MockSurroundViewCallback> mSv3dCallback;

	VhalHandler* mVhalHandler;
	AnimationModule* mAnimationModule;
	sp<SurroundView3dSession> mSv3dSessionAnimations;
	sp<MockSurroundViewCallback> mSv3dCallbackAnimations;
	};

	TEST_F(SurroundView3dSessionTests, startAndStop3dSession) {
	SetupSv3dSession();
	EXPECT_EQ(mSv3dSession->startStream(mSv3dCallback), SvResult::OK);
	sleep(5);
	mSv3dSession->stopStream();
	EXPECT_GT(mSv3dCallback->getReceivedFramesCount(), 0);
	}

	TEST_F(SurroundView3dSessionTests, get3dConfigSuccess) {
	SetupSv3dSession();
	Sv3dConfig sv3dConfig;
	mSv3dSession->get3dConfig([&sv3dConfig](const Sv3dConfig& config) { sv3dConfig = config; });

	EXPECT_EQ(sv3dConfig.width, kSv3dWidth);
	EXPECT_EQ(sv3dConfig.height, kSv3dHeight);
	EXPECT_EQ(sv3dConfig.carDetails, SvQuality::HIGH);
	}

	// Sets a different config and checks of the received config matches.
	TEST_F(SurroundView3dSessionTests, setAndGet3dConfigSuccess) {
	SetupSv3dSession();
	Sv3dConfig sv3dConfigSet = {kSv3dWidth / 2, kSv3dHeight / 2, SvQuality::LOW};

	EXPECT_EQ(mSv3dSession->set3dConfig(sv3dConfigSet), SvResult::OK);

	Sv3dConfig sv3dConfigReceived;
	mSv3dSession->get3dConfig(
	[&sv3dConfigReceived](const Sv3dConfig& config) { sv3dConfigReceived = config; });

	EXPECT_EQ(sv3dConfigReceived.width, sv3dConfigSet.width);
	EXPECT_EQ(sv3dConfigReceived.height, sv3dConfigSet.height);
	EXPECT_EQ(sv3dConfigReceived.carDetails, sv3dConfigSet.carDetails);
	}

	// Projects center of each cameras and checks if valid projected point is received.
	TEST_F(SurroundView3dSessionTests, projectPoints3dSuccess) {
	SetupSv3dSession();
	hidl_vec<Point2dInt> points2dCamera = {
	/Center point/ {.x = kSv3dWidth / 2, .y = kSv3dHeight / 2}};

	std::vector<hidl_string> cameraIds = {"/dev/video60", "/dev/video61", "/dev/video62",
	"/dev/video63"};

	for (int i = 0; i < cameraIds.size(); i++) {
	mSv3dSession
	->projectCameraPointsTo3dSurface(points2dCamera, cameraIds[i],
	[](const hidl_vec<Point3dFloat>& projectedPoints) {
	EXPECT_TRUE(projectedPoints[0].isValid);
	});
	}
	}

	std::pair<hidl_memory, sp<IMemory>> GetMappedSharedMemory(int bytesSize) {
	const auto nullResult = std::make_pair(hidl_memory(), nullptr);

	sp<IAllocator> ashmemAllocator = IAllocator::getService("ashmem");
	if (ashmemAllocator.get() == nullptr) {
	return nullResult;
	}

	// Allocate shared memory.
	hidl_memory hidlMemory;
	bool allocateSuccess = false;
	Return<void> result =
	ashmemAllocator->allocate(bytesSize, [&](bool success, const hidl_memory& hidlMem) {
	if (!success) {
	return;
	}
	allocateSuccess = success;
	hidlMemory = hidlMem;
	});

	// Check result of allocated memory.
	if (!result.isOk() \|\| !allocateSuccess) {
	return nullResult;
	}

	// Map shared memory.
	sp<IMemory> pIMemory = mapMemory(hidlMemory);
	if (pIMemory.get() == nullptr) {
	return nullResult;
	}

	return std::make_pair(hidlMemory, pIMemory);
	}

	void SetIndexOfOverlaysMemory(const std::vector<OverlayMemoryDesc>& overlaysMemDesc,
	sp<IMemory> pIMemory, int indexPosition, uint16_t indexValue) {
	// Count the number of vertices until the index.
	int totalVerticesCount = 0;
	for (int i = 0; i < indexPosition; i++) {
	totalVerticesCount += overlaysMemDesc[i].verticesCount;
	}

	const int indexBytePosition =
	(indexPosition * kIdByteSize) + (kVertexByteSize * totalVerticesCount);

	uint8_t* pSharedMemoryData = reinterpret_cast<uint8_t>((void)pIMemory->getPointer());
	pSharedMemoryData += indexBytePosition;
	uint16_t* pIndex16bit = reinterpret_cast<uint16_t*>(pSharedMemoryData);

	// Modify shared memory.
	pIMemory->update();
	*pIndex16bit = indexValue;
	pIMemory->commit();
	}

	std::pair<OverlaysData, sp<IMemory>> GetSampleOverlaysData() {
	OverlaysData overlaysData;
	overlaysData.overlaysMemoryDesc.resize(2);

	int sharedMemBytesSize = 0;
	OverlayMemoryDesc overlayMemDesc1, overlayMemDesc2;
	overlayMemDesc1.id = 0;
	overlayMemDesc1.verticesCount = 6;
	overlayMemDesc1.overlayPrimitive = OverlayPrimitive::TRIANGLES;
	overlaysData.overlaysMemoryDesc[0] = overlayMemDesc1;
	sharedMemBytesSize += kIdByteSize + kVertexByteSize * overlayMemDesc1.verticesCount;

	overlayMemDesc2.id = 1;
	overlayMemDesc2.verticesCount = 4;
	overlayMemDesc2.overlayPrimitive = OverlayPrimitive::TRIANGLES_STRIP;
	overlaysData.overlaysMemoryDesc[1] = overlayMemDesc2;
	sharedMemBytesSize += kIdByteSize + kVertexByteSize * overlayMemDesc2.verticesCount;

	std::pair<hidl_memory, sp<IMemory>> sharedMem = GetMappedSharedMemory(sharedMemBytesSize);
	sp<IMemory> pIMemory = sharedMem.second;
	if (pIMemory.get() == nullptr) {
	return std::make_pair(OverlaysData(), nullptr);
	}

	// Get pointer to shared memory data and set all bytes to 0.
	uint8_t* pSharedMemoryData = reinterpret_cast<uint8_t>((void)pIMemory->getPointer());
	pIMemory->update();
	memset(pSharedMemoryData, 0, sharedMemBytesSize);
	pIMemory->commit();

	std::vector<OverlayMemoryDesc> overlaysDesc = {overlayMemDesc1, overlayMemDesc2};

	// Set indexes in shared memory.
	SetIndexOfOverlaysMemory(overlaysDesc, pIMemory, 0, overlayMemDesc1.id);
	SetIndexOfOverlaysMemory(overlaysDesc, pIMemory, 1, overlayMemDesc2.id);

	overlaysData.overlaysMemoryDesc = overlaysDesc;
	overlaysData.overlaysMemory = sharedMem.first;

	return std::make_pair(overlaysData, pIMemory);
	}

	// Verifies a valid overlay can be updated while streaming.
	TEST_F(SurroundView3dSessionTests, updateOverlaysSuccess) {
	SetupSv3dSession();
	std::pair<OverlaysData, sp<IMemory>> overlaysData = GetSampleOverlaysData();
	ASSERT_NE(overlaysData.second, nullptr);
	EXPECT_EQ(mSv3dSession->startStream(mSv3dCallback), SvResult::OK);
	SvResult result = mSv3dSession->updateOverlays(overlaysData.first);
	mSv3dSession->stopStream();
	EXPECT_EQ(result, SvResult::OK);
	}

	// Setup sv 3d sessin with vhal and animations and verify frames are received successfully.
	TEST_F(SurroundView3dSessionTests, vhalAnimationSuccess) {
	SetupSv3dSessionVhalAnimation();
	EXPECT_EQ(mSv3dSessionAnimations->startStream(mSv3dCallbackAnimations), SvResult::OK);
	sleep(5);
	mSv3dSessionAnimations->stopStream();
	EXPECT_GT(mSv3dCallbackAnimations->getReceivedFramesCount(), 0);
	}

	} // namespace
	} // namespace implementation
	} // namespace V1_0
	} // namespace sv
	} // namespace automotive
	} // namespace hardware
	} // namespace android