Google Git
Sign in
android / platform / hardware / interfaces / bfaf79c9c6f0ea02656d2dab14f4d74949afe70e / . / automotive / evs / 1.1 / vts / functional / VtsHalEvsV1_1TargetTest.cpp
blob: 8b68fd6f0ad30bfb04301ab420dfa044a3128cc5 [file] [log] [blame]
/*
* Copyright (C) 2019 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 "VtsHalEvsTest"
// These values are called out in the EVS design doc (as of Mar 8, 2017)
static const int kMaxStreamStartMilliseconds = 500;
static const int kMinimumFramesPerSecond = 10;
static const int kSecondsToMilliseconds = 1000;
static const int kMillisecondsToMicroseconds = 1000;
static const float kNanoToMilliseconds = 0.000001f;
static const float kNanoToSeconds = 0.000000001f;
#include "FrameHandler.h"
#include "FrameHandlerUltrasonics.h"
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <thread>
#include <unordered_set>
#include <hidl/HidlTransportSupport.h>
#include <hwbinder/ProcessState.h>
#include <utils/Errors.h>
#include <utils/StrongPointer.h>
#include <android/hardware/automotive/evs/1.1/IEvsCamera.h>
#include <android/hardware/automotive/evs/1.1/IEvsCameraStream.h>
#include <android/hardware/automotive/evs/1.1/IEvsEnumerator.h>
#include <android/hardware/automotive/evs/1.1/IEvsDisplay.h>
#include <android/hardware/camera/device/3.2/ICameraDevice.h>
#include <android-base/logging.h>
#include <system/camera_metadata.h>
#include <ui/DisplayConfig.h>
#include <ui/DisplayState.h>
#include <ui/GraphicBuffer.h>
#include <ui/GraphicBufferAllocator.h>
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/ServiceManagement.h>
using namespace ::android::hardware::automotive::evs::V1_1;
using namespace std::chrono_literals;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::hidl_vec;
using ::android::hardware::hidl_handle;
using ::android::hardware::hidl_string;
using ::android::sp;
using ::android::wp;
using ::android::hardware::camera::device::V3_2::Stream;
using ::android::hardware::automotive::evs::V1_1::BufferDesc;
using ::android::hardware::automotive::evs::V1_0::DisplayDesc;
using ::android::hardware::automotive::evs::V1_0::DisplayState;
using ::android::hardware::graphics::common::V1_0::PixelFormat;
using IEvsCamera_1_0 = ::android::hardware::automotive::evs::V1_0::IEvsCamera;
using IEvsCamera_1_1 = ::android::hardware::automotive::evs::V1_1::IEvsCamera;
using IEvsDisplay_1_0 = ::android::hardware::automotive::evs::V1_0::IEvsDisplay;
using IEvsDisplay_1_1 = ::android::hardware::automotive::evs::V1_1::IEvsDisplay;
/*
* Plese note that this is different from what is defined in
* libhardware/modules/camera/3_4/metadata/types.h; this has one additional
* field to store a framerate.
*/
const size_t kStreamCfgSz = 5;
typedef struct {
int32_t width;
int32_t height;
int32_t format;
int32_t direction;
int32_t framerate;
} RawStreamConfig;
// The main test class for EVS
class EvsHidlTest : public ::testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
// Make sure we can connect to the enumerator
std::string service_name = GetParam();
pEnumerator = IEvsEnumerator::getService(service_name);
ASSERT_NE(pEnumerator.get(), nullptr);
LOG(INFO) << "Test target service: " << service_name;
mIsHwModule = pEnumerator->isHardware();
}
virtual void TearDown() override {
// Attempt to close any active camera
for (auto &&cam : activeCameras) {
if (cam != nullptr) {
pEnumerator->closeCamera(cam);
}
}
activeCameras.clear();
}
protected:
void loadCameraList() {
// SetUp() must run first!
assert(pEnumerator != nullptr);
// Get the camera list
pEnumerator->getCameraList_1_1(
[this](hidl_vec <CameraDesc> cameraList) {
LOG(INFO) << "Camera list callback received "
<< cameraList.size()
<< " cameras";
cameraInfo.reserve(cameraList.size());
for (auto&& cam: cameraList) {
LOG(INFO) << "Found camera " << cam.v1.cameraId;
cameraInfo.push_back(cam);
}
}
);
}
void loadUltrasonicsArrayList() {
// SetUp() must run first!
assert(pEnumerator != nullptr);
// Get the ultrasonics array list
pEnumerator->getUltrasonicsArrayList([this](hidl_vec<UltrasonicsArrayDesc> ultraList) {
LOG(INFO) << "Ultrasonics array list callback received "
<< ultraList.size()
<< " arrays";
ultrasonicsArraysInfo.reserve(ultraList.size());
for (auto&& ultraArray : ultraList) {
LOG(INFO) << "Found ultrasonics array " << ultraArray.ultrasonicsArrayId;
ultrasonicsArraysInfo.push_back(ultraArray);
}
});
}
bool isLogicalCamera(const camera_metadata_t *metadata) {
if (metadata == nullptr) {
// A logical camera device must have a valid camera metadata.
return false;
}
// Looking for LOGICAL_MULTI_CAMERA capability from metadata.
camera_metadata_ro_entry_t entry;
int rc = find_camera_metadata_ro_entry(metadata,
ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
&entry);
if (0 != rc) {
// No capabilities are found.
return false;
}
for (size_t i = 0; i < entry.count; ++i) {
uint8_t cap = entry.data.u8[i];
if (cap == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
return true;
}
}
return false;
}
std::unordered_set<std::string> getPhysicalCameraIds(const std::string& id,
bool& flag) {
std::unordered_set<std::string> physicalCameras;
auto it = cameraInfo.begin();
while (it != cameraInfo.end()) {
if (it->v1.cameraId == id) {
break;
}
++it;
}
if (it == cameraInfo.end()) {
// Unknown camera is requested. Return an empty list.
return physicalCameras;
}
const camera_metadata_t *metadata =
reinterpret_cast<camera_metadata_t *>(&it->metadata[0]);
flag = isLogicalCamera(metadata);
if (!flag) {
// EVS assumes that the device w/o a valid metadata is a physical
// device.
LOG(INFO) << id << " is not a logical camera device.";
physicalCameras.emplace(id);
return physicalCameras;
}
// Look for physical camera identifiers
camera_metadata_ro_entry entry;
int rc = find_camera_metadata_ro_entry(metadata,
ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS,
&entry);
if (rc != 0) {
LOG(ERROR) << "No physical camera ID is found for a logical camera device";
}
const uint8_t *ids = entry.data.u8;
size_t start = 0;
for (size_t i = 0; i < entry.count; ++i) {
if (ids[i] == '\0') {
if (start != i) {
std::string id(reinterpret_cast<const char *>(ids + start));
physicalCameras.emplace(id);
}
start = i + 1;
}
}
LOG(INFO) << id
<< " consists of "
<< physicalCameras.size()
<< " physical camera devices";
return physicalCameras;
}
sp<IEvsEnumerator> pEnumerator; // Every test needs access to the service
std::vector<CameraDesc> cameraInfo; // Empty unless/until loadCameraList() is called
bool mIsHwModule; // boolean to tell current module under testing
// is HW module implementation.
std::deque<sp<IEvsCamera_1_1>> activeCameras; // A list of active camera handles that are
// needed to be cleaned up.
std::vector<UltrasonicsArrayDesc>
ultrasonicsArraysInfo; // Empty unless/until
// loadUltrasonicsArrayList() is called
std::deque<wp<IEvsCamera_1_1>> activeUltrasonicsArrays; // A list of active ultrasonic array
// handles that are to be cleaned up.
};
// Test cases, their implementations, and corresponding requirements are
// documented at go/aae-evs-public-api-test.
/*
* CameraOpenClean:
* Opens each camera reported by the enumerator and then explicitly closes it via a
* call to closeCamera. Then repeats the test to ensure all cameras can be reopened.
*/
TEST_P(EvsHidlTest, CameraOpenClean) {
LOG(INFO) << "Starting CameraOpenClean test";
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Open and close each camera twice
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
auto devices = getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (mIsHwModule && isLogicalCam) {
LOG(INFO) << "Skip a logical device, " << cam.v1.cameraId << " for HW target.";
continue;
}
for (int pass = 0; pass < 2; pass++) {
sp<IEvsCamera_1_1> pCam = pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg);
ASSERT_NE(pCam, nullptr);
for (auto&& devName : devices) {
bool matched = false;
pCam->getPhysicalCameraInfo(devName,
[&devName, &matched](const CameraDesc& info) {
matched = devName == info.v1.cameraId;
});
ASSERT_TRUE(matched);
}
// Store a camera handle for a clean-up
activeCameras.push_back(pCam);
// Verify that this camera self-identifies correctly
pCam->getCameraInfo_1_1([&cam](CameraDesc desc) {
LOG(DEBUG) << "Found camera " << desc.v1.cameraId;
EXPECT_EQ(cam.v1.cameraId, desc.v1.cameraId);
}
);
// Verify methods for extended info
const auto id = 0xFFFFFFFF; // meaningless id
hidl_vec<uint8_t> values;
auto err = pCam->setExtendedInfo_1_1(id, values);
ASSERT_NE(EvsResult::INVALID_ARG, err);
pCam->getExtendedInfo_1_1(id, [](const auto& result, const auto& data) {
ASSERT_NE(EvsResult::INVALID_ARG, result);
ASSERT_EQ(0, data.size());
});
// Explicitly close the camera so resources are released right away
pEnumerator->closeCamera(pCam);
activeCameras.clear();
}
}
}
/*
* CameraOpenAggressive:
* Opens each camera reported by the enumerator twice in a row without an intervening closeCamera
* call. This ensures that the intended "aggressive open" behavior works. This is necessary for
* the system to be tolerant of shutdown/restart race conditions.
*/
TEST_P(EvsHidlTest, CameraOpenAggressive) {
LOG(INFO) << "Starting CameraOpenAggressive test";
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Open and close each camera twice
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (mIsHwModule && isLogicalCam) {
LOG(INFO) << "Skip a logical device, " << cam.v1.cameraId << " for HW target.";
continue;
}
activeCameras.clear();
sp<IEvsCamera_1_1> pCam =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam);
// Verify that this camera self-identifies correctly
pCam->getCameraInfo_1_1([&cam](CameraDesc desc) {
LOG(DEBUG) << "Found camera " << desc.v1.cameraId;
EXPECT_EQ(cam.v1.cameraId, desc.v1.cameraId);
}
);
sp<IEvsCamera_1_1> pCam2 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam2, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam2);
ASSERT_NE(pCam, pCam2);
Return<EvsResult> result = pCam->setMaxFramesInFlight(2);
if (mIsHwModule) {
// Verify that the old camera rejects calls via HW module.
EXPECT_EQ(EvsResult::OWNERSHIP_LOST, EvsResult(result));
} else {
// default implementation supports multiple clients.
EXPECT_EQ(EvsResult::OK, EvsResult(result));
}
// Close the superceded camera
pEnumerator->closeCamera(pCam);
activeCameras.pop_front();
// Verify that the second camera instance self-identifies correctly
pCam2->getCameraInfo_1_1([&cam](CameraDesc desc) {
LOG(DEBUG) << "Found camera " << desc.v1.cameraId;
EXPECT_EQ(cam.v1.cameraId, desc.v1.cameraId);
}
);
// Close the second camera instance
pEnumerator->closeCamera(pCam2);
activeCameras.pop_front();
}
// Sleep here to ensure the destructor cleanup has time to run so we don't break follow on tests
sleep(1); // I hate that this is an arbitrary time to wait. :( b/36122635
}
/*
* CameraStreamPerformance:
* Measure and qualify the stream start up time and streaming frame rate of each reported camera
*/
TEST_P(EvsHidlTest, CameraStreamPerformance) {
LOG(INFO) << "Starting CameraStreamPerformance test";
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Test each reported camera
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
auto devices = getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (mIsHwModule && isLogicalCam) {
LOG(INFO) << "Skip a logical device " << cam.v1.cameraId;
continue;
}
sp<IEvsCamera_1_1> pCam =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam);
// Set up a frame receiver object which will fire up its own thread
sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
nullptr,
FrameHandler::eAutoReturn);
// Start the camera's video stream
nsecs_t start = systemTime(SYSTEM_TIME_MONOTONIC);
bool startResult = frameHandler->startStream();
ASSERT_TRUE(startResult);
// Ensure the first frame arrived within the expected time
frameHandler->waitForFrameCount(1);
nsecs_t firstFrame = systemTime(SYSTEM_TIME_MONOTONIC);
nsecs_t timeToFirstFrame = systemTime(SYSTEM_TIME_MONOTONIC) - start;
// Extra delays are expected when we attempt to start a video stream on
// the logical camera device. The amount of delay is expected the
// number of physical camera devices multiplied by
// kMaxStreamStartMilliseconds at most.
EXPECT_LE(nanoseconds_to_milliseconds(timeToFirstFrame),
kMaxStreamStartMilliseconds * devices.size());
printf("%s: Measured time to first frame %0.2f ms\n",
cam.v1.cameraId.c_str(), timeToFirstFrame * kNanoToMilliseconds);
LOG(INFO) << cam.v1.cameraId
<< ": Measured time to first frame "
<< std::scientific << timeToFirstFrame * kNanoToMilliseconds
<< " ms.";
// Check aspect ratio
unsigned width = 0, height = 0;
frameHandler->getFrameDimension(&width, &height);
EXPECT_GE(width, height);
// Wait a bit, then ensure we get at least the required minimum number of frames
sleep(5);
nsecs_t end = systemTime(SYSTEM_TIME_MONOTONIC);
// Even when the camera pointer goes out of scope, the FrameHandler object will
// keep the stream alive unless we tell it to shutdown.
// Also note that the FrameHandle and the Camera have a mutual circular reference, so
// we have to break that cycle in order for either of them to get cleaned up.
frameHandler->shutdown();
unsigned framesReceived = 0;
frameHandler->getFramesCounters(&framesReceived, nullptr);
framesReceived = framesReceived - 1; // Back out the first frame we already waited for
nsecs_t runTime = end - firstFrame;
float framesPerSecond = framesReceived / (runTime * kNanoToSeconds);
printf("Measured camera rate %3.2f fps\n", framesPerSecond);
LOG(INFO) << "Measured camera rate "
<< std::scientific << framesPerSecond
<< " fps.";
EXPECT_GE(framesPerSecond, kMinimumFramesPerSecond);
// Explicitly release the camera
pEnumerator->closeCamera(pCam);
activeCameras.clear();
}
}
/*
* CameraStreamBuffering:
* Ensure the camera implementation behaves properly when the client holds onto buffers for more
* than one frame time. The camera must cleanly skip frames until the client is ready again.
*/
TEST_P(EvsHidlTest, CameraStreamBuffering) {
LOG(INFO) << "Starting CameraStreamBuffering test";
// Arbitrary constant (should be > 1 and less than crazy)
static const unsigned int kBuffersToHold = 6;
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Test each reported camera
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (mIsHwModule && isLogicalCam) {
LOG(INFO) << "Skip a logical device " << cam.v1.cameraId << " for HW target.";
continue;
}
sp<IEvsCamera_1_1> pCam =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam);
// Ask for a crazy number of buffers in flight to ensure it errors correctly
Return<EvsResult> badResult = pCam->setMaxFramesInFlight(0xFFFFFFFF);
EXPECT_EQ(EvsResult::BUFFER_NOT_AVAILABLE, badResult);
// Now ask for exactly two buffers in flight as we'll test behavior in that case
Return<EvsResult> goodResult = pCam->setMaxFramesInFlight(kBuffersToHold);
EXPECT_EQ(EvsResult::OK, goodResult);
// Set up a frame receiver object which will fire up its own thread.
sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
nullptr,
FrameHandler::eNoAutoReturn);
// Start the camera's video stream
bool startResult = frameHandler->startStream();
ASSERT_TRUE(startResult);
// Check that the video stream stalls once we've gotten exactly the number of buffers
// we requested since we told the frameHandler not to return them.
sleep(1); // 1 second should be enough for at least 5 frames to be delivered worst case
unsigned framesReceived = 0;
frameHandler->getFramesCounters(&framesReceived, nullptr);
ASSERT_EQ(kBuffersToHold, framesReceived) << "Stream didn't stall at expected buffer limit";
// Give back one buffer
bool didReturnBuffer = frameHandler->returnHeldBuffer();
EXPECT_TRUE(didReturnBuffer);
// Once we return a buffer, it shouldn't take more than 1/10 second to get a new one
// filled since we require 10fps minimum -- but give a 10% allowance just in case.
usleep(110 * kMillisecondsToMicroseconds);
frameHandler->getFramesCounters(&framesReceived, nullptr);
EXPECT_EQ(kBuffersToHold+1, framesReceived) << "Stream should've resumed";
// Even when the camera pointer goes out of scope, the FrameHandler object will
// keep the stream alive unless we tell it to shutdown.
// Also note that the FrameHandle and the Camera have a mutual circular reference, so
// we have to break that cycle in order for either of them to get cleaned up.
frameHandler->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam);
activeCameras.clear();
}
}
/*
* CameraToDisplayRoundTrip:
* End to end test of data flowing from the camera to the display. Each delivered frame of camera
* imagery is simply copied to the display buffer and presented on screen. This is the one test
* which a human could observe to see the operation of the system on the physical display.
*/
TEST_P(EvsHidlTest, CameraToDisplayRoundTrip) {
LOG(INFO) << "Starting CameraToDisplayRoundTrip test";
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Request available display IDs
uint8_t targetDisplayId = 0;
pEnumerator->getDisplayIdList([&targetDisplayId](auto ids) {
ASSERT_GT(ids.size(), 0);
targetDisplayId = ids[0];
});
// Request exclusive access to the first EVS display
sp<IEvsDisplay_1_1> pDisplay = pEnumerator->openDisplay_1_1(targetDisplayId);
ASSERT_NE(pDisplay, nullptr);
LOG(INFO) << "Display " << targetDisplayId << " is alreay in use.";
// Get the display descriptor
pDisplay->getDisplayInfo_1_1([](const auto& config, const auto& state) {
android::DisplayConfig* pConfig = (android::DisplayConfig*)config.data();
const auto width = pConfig->resolution.getWidth();
const auto height = pConfig->resolution.getHeight();
LOG(INFO) << " Resolution: " << width << "x" << height;
ASSERT_GT(width, 0);
ASSERT_GT(height, 0);
android::ui::DisplayState* pState = (android::ui::DisplayState*)state.data();
ASSERT_NE(pState->layerStack, -1);
});
// Test each reported camera
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (mIsHwModule && isLogicalCam) {
LOG(INFO) << "Skip a logical device " << cam.v1.cameraId << " for HW target.";
continue;
}
sp<IEvsCamera_1_1> pCam =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam);
// Set up a frame receiver object which will fire up its own thread.
sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
pDisplay,
FrameHandler::eAutoReturn);
// Activate the display
pDisplay->setDisplayState(DisplayState::VISIBLE_ON_NEXT_FRAME);
// Start the camera's video stream
bool startResult = frameHandler->startStream();
ASSERT_TRUE(startResult);
// Wait a while to let the data flow
static const int kSecondsToWait = 5;
const int streamTimeMs = kSecondsToWait * kSecondsToMilliseconds -
kMaxStreamStartMilliseconds;
const unsigned minimumFramesExpected = streamTimeMs * kMinimumFramesPerSecond /
kSecondsToMilliseconds;
sleep(kSecondsToWait);
unsigned framesReceived = 0;
unsigned framesDisplayed = 0;
frameHandler->getFramesCounters(&framesReceived, &framesDisplayed);
EXPECT_EQ(framesReceived, framesDisplayed);
EXPECT_GE(framesDisplayed, minimumFramesExpected);
// Turn off the display (yes, before the stream stops -- it should be handled)
pDisplay->setDisplayState(DisplayState::NOT_VISIBLE);
// Shut down the streamer
frameHandler->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam);
activeCameras.clear();
}
// Explicitly release the display
pEnumerator->closeDisplay(pDisplay);
}
/*
* MultiCameraStream:
* Verify that each client can start and stop video streams on the same
* underlying camera.
*/
TEST_P(EvsHidlTest, MultiCameraStream) {
LOG(INFO) << "Starting MultiCameraStream test";
if (mIsHwModule) {
// This test is not for HW module implementation.
return;
}
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Test each reported camera
for (auto&& cam: cameraInfo) {
// Create two camera clients.
sp<IEvsCamera_1_1> pCam0 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam0, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam0);
sp<IEvsCamera_1_1> pCam1 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam1, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam1);
// Set up per-client frame receiver objects which will fire up its own thread
sp<FrameHandler> frameHandler0 = new FrameHandler(pCam0, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandler0, nullptr);
sp<FrameHandler> frameHandler1 = new FrameHandler(pCam1, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandler1, nullptr);
// Start the camera's video stream via client 0
bool startResult = false;
startResult = frameHandler0->startStream() &&
frameHandler1->startStream();
ASSERT_TRUE(startResult);
// Ensure the stream starts
frameHandler0->waitForFrameCount(1);
frameHandler1->waitForFrameCount(1);
nsecs_t firstFrame = systemTime(SYSTEM_TIME_MONOTONIC);
// Wait a bit, then ensure both clients get at least the required minimum number of frames
sleep(5);
nsecs_t end = systemTime(SYSTEM_TIME_MONOTONIC);
unsigned framesReceived0 = 0, framesReceived1 = 0;
frameHandler0->getFramesCounters(&framesReceived0, nullptr);
frameHandler1->getFramesCounters(&framesReceived1, nullptr);
framesReceived0 = framesReceived0 - 1; // Back out the first frame we already waited for
framesReceived1 = framesReceived1 - 1; // Back out the first frame we already waited for
nsecs_t runTime = end - firstFrame;
float framesPerSecond0 = framesReceived0 / (runTime * kNanoToSeconds);
float framesPerSecond1 = framesReceived1 / (runTime * kNanoToSeconds);
LOG(INFO) << "Measured camera rate "
<< std::scientific << framesPerSecond0 << " fps and "
<< framesPerSecond1 << " fps";
EXPECT_GE(framesPerSecond0, kMinimumFramesPerSecond);
EXPECT_GE(framesPerSecond1, kMinimumFramesPerSecond);
// Shutdown one client
frameHandler0->shutdown();
// Read frame counters again
frameHandler0->getFramesCounters(&framesReceived0, nullptr);
frameHandler1->getFramesCounters(&framesReceived1, nullptr);
// Wait a bit again
sleep(5);
unsigned framesReceivedAfterStop0 = 0, framesReceivedAfterStop1 = 0;
frameHandler0->getFramesCounters(&framesReceivedAfterStop0, nullptr);
frameHandler1->getFramesCounters(&framesReceivedAfterStop1, nullptr);
EXPECT_EQ(framesReceived0, framesReceivedAfterStop0);
EXPECT_LT(framesReceived1, framesReceivedAfterStop1);
// Shutdown another
frameHandler1->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam0);
pEnumerator->closeCamera(pCam1);
activeCameras.clear();
// TODO(b/145459970, b/145457727): below sleep() is added to ensure the
// destruction of active camera objects; this may be related with two
// issues.
sleep(1);
}
}
/*
* CameraParameter:
* Verify that a client can adjust a camera parameter.
*/
TEST_P(EvsHidlTest, CameraParameter) {
LOG(INFO) << "Starting CameraParameter test";
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Test each reported camera
Return<EvsResult> result = EvsResult::OK;
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (isLogicalCam) {
// TODO(b/145465724): Support camera parameter programming on
// logical devices.
LOG(INFO) << "Skip a logical device " << cam.v1.cameraId;
continue;
}
// Create a camera client
sp<IEvsCamera_1_1> pCam =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam, nullptr);
// Store a camera
activeCameras.push_back(pCam);
// Get the parameter list
std::vector<CameraParam> cmds;
pCam->getParameterList([&cmds](hidl_vec<CameraParam> cmdList) {
cmds.reserve(cmdList.size());
for (auto &&cmd : cmdList) {
cmds.push_back(cmd);
}
}
);
if (cmds.size() < 1) {
continue;
}
// Set up per-client frame receiver objects which will fire up its own thread
sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandler, nullptr);
// Start the camera's video stream
bool startResult = frameHandler->startStream();
ASSERT_TRUE(startResult);
// Ensure the stream starts
frameHandler->waitForFrameCount(1);
result = pCam->setMaster();
ASSERT_EQ(EvsResult::OK, result);
for (auto &cmd : cmds) {
// Get a valid parameter value range
int32_t minVal, maxVal, step;
pCam->getIntParameterRange(
cmd,
[&minVal, &maxVal, &step](int32_t val0, int32_t val1, int32_t val2) {
minVal = val0;
maxVal = val1;
step = val2;
}
);
EvsResult result = EvsResult::OK;
if (cmd == CameraParam::ABSOLUTE_FOCUS) {
// Try to turn off auto-focus
std::vector<int32_t> values;
pCam->setIntParameter(CameraParam::AUTO_FOCUS, 0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(v, 0);
}
}
// Try to program a parameter with a random value [minVal, maxVal]
int32_t val0 = minVal + (std::rand() % (maxVal - minVal));
std::vector<int32_t> values;
// Rounding down
val0 = val0 - (val0 % step);
pCam->setIntParameter(cmd, val0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
values.clear();
pCam->getIntParameter(cmd,
[&result, &values](auto status, auto readValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : readValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(val0, v) << "Values are not matched.";
}
}
result = pCam->unsetMaster();
ASSERT_EQ(EvsResult::OK, result);
// Shutdown
frameHandler->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam);
activeCameras.clear();
}
}
/*
* CameraMasterRelease
* Verify that non-master client gets notified when the master client either
* terminates or releases a role.
*/
TEST_P(EvsHidlTest, CameraMasterRelease) {
LOG(INFO) << "Starting CameraMasterRelease test";
if (mIsHwModule) {
// This test is not for HW module implementation.
return;
}
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Test each reported camera
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (isLogicalCam) {
// TODO(b/145465724): Support camera parameter programming on
// logical devices.
LOG(INFO) << "Skip a logical device " << cam.v1.cameraId;
continue;
}
// Create two camera clients.
sp<IEvsCamera_1_1> pCamMaster =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCamMaster, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCamMaster);
sp<IEvsCamera_1_1> pCamNonMaster =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCamNonMaster, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCamNonMaster);
// Set up per-client frame receiver objects which will fire up its own thread
sp<FrameHandler> frameHandlerMaster =
new FrameHandler(pCamMaster, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandlerMaster, nullptr);
sp<FrameHandler> frameHandlerNonMaster =
new FrameHandler(pCamNonMaster, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandlerNonMaster, nullptr);
// Set one client as the master
EvsResult result = pCamMaster->setMaster();
ASSERT_TRUE(result == EvsResult::OK);
// Try to set another client as the master.
result = pCamNonMaster->setMaster();
ASSERT_TRUE(result == EvsResult::OWNERSHIP_LOST);
// Start the camera's video stream via a master client.
bool startResult = frameHandlerMaster->startStream();
ASSERT_TRUE(startResult);
// Ensure the stream starts
frameHandlerMaster->waitForFrameCount(1);
// Start the camera's video stream via another client
startResult = frameHandlerNonMaster->startStream();
ASSERT_TRUE(startResult);
// Ensure the stream starts
frameHandlerNonMaster->waitForFrameCount(1);
// Non-master client expects to receive a master role relesed
// notification.
EvsEventDesc aTargetEvent = {};
EvsEventDesc aNotification = {};
bool listening = false;
std::mutex eventLock;
std::condition_variable eventCond;
std::thread listener = std::thread(
[&aNotification, &frameHandlerNonMaster, &listening, &eventCond]() {
// Notify that a listening thread is running.
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::MASTER_RELEASED;
if (!frameHandlerNonMaster->waitForEvent(aTargetEvent, aNotification, true)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a listening thread starts.
std::unique_lock<std::mutex> lock(eventLock);
auto timer = std::chrono::system_clock::now();
while (!listening) {
timer += 1s;
eventCond.wait_until(lock, timer);
}
lock.unlock();
// Release a master role.
pCamMaster->unsetMaster();
// Join a listening thread.
if (listener.joinable()) {
listener.join();
}
// Verify change notifications.
ASSERT_EQ(EvsEventType::MASTER_RELEASED,
static_cast<EvsEventType>(aNotification.aType));
// Non-master becomes a master.
result = pCamNonMaster->setMaster();
ASSERT_TRUE(result == EvsResult::OK);
// Previous master client fails to become a master.
result = pCamMaster->setMaster();
ASSERT_TRUE(result == EvsResult::OWNERSHIP_LOST);
listening = false;
listener = std::thread(
[&aNotification, &frameHandlerMaster, &listening, &eventCond]() {
// Notify that a listening thread is running.
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::MASTER_RELEASED;
if (!frameHandlerMaster->waitForEvent(aTargetEvent, aNotification, true)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a listening thread starts.
timer = std::chrono::system_clock::now();
lock.lock();
while (!listening) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
// Closing current master client.
frameHandlerNonMaster->shutdown();
// Join a listening thread.
if (listener.joinable()) {
listener.join();
}
// Verify change notifications.
ASSERT_EQ(EvsEventType::MASTER_RELEASED,
static_cast<EvsEventType>(aNotification.aType));
// Closing streams.
frameHandlerMaster->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCamMaster);
pEnumerator->closeCamera(pCamNonMaster);
activeCameras.clear();
}
}
/*
* MultiCameraParameter:
* Verify that master and non-master clients behave as expected when they try to adjust
* camera parameters.
*/
TEST_P(EvsHidlTest, MultiCameraParameter) {
LOG(INFO) << "Starting MultiCameraParameter test";
if (mIsHwModule) {
// This test is not for HW module implementation.
return;
}
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Test each reported camera
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (isLogicalCam) {
// TODO(b/145465724): Support camera parameter programming on
// logical devices.
LOG(INFO) << "Skip a logical device " << cam.v1.cameraId;
continue;
}
// Create two camera clients.
sp<IEvsCamera_1_1> pCamMaster =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCamMaster, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCamMaster);
sp<IEvsCamera_1_1> pCamNonMaster =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCamNonMaster, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCamNonMaster);
// Get the parameter list
std::vector<CameraParam> camMasterCmds, camNonMasterCmds;
pCamMaster->getParameterList([&camMasterCmds](hidl_vec<CameraParam> cmdList) {
camMasterCmds.reserve(cmdList.size());
for (auto &&cmd : cmdList) {
camMasterCmds.push_back(cmd);
}
}
);
pCamNonMaster->getParameterList([&camNonMasterCmds](hidl_vec<CameraParam> cmdList) {
camNonMasterCmds.reserve(cmdList.size());
for (auto &&cmd : cmdList) {
camNonMasterCmds.push_back(cmd);
}
}
);
if (camMasterCmds.size() < 1 ||
camNonMasterCmds.size() < 1) {
// Skip a camera device if it does not support any parameter.
continue;
}
// Set up per-client frame receiver objects which will fire up its own thread
sp<FrameHandler> frameHandlerMaster =
new FrameHandler(pCamMaster, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandlerMaster, nullptr);
sp<FrameHandler> frameHandlerNonMaster =
new FrameHandler(pCamNonMaster, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandlerNonMaster, nullptr);
// Set one client as the master
EvsResult result = pCamMaster->setMaster();
ASSERT_EQ(EvsResult::OK, result);
// Try to set another client as the master.
result = pCamNonMaster->setMaster();
ASSERT_EQ(EvsResult::OWNERSHIP_LOST, result);
// Start the camera's video stream via a master client.
bool startResult = frameHandlerMaster->startStream();
ASSERT_TRUE(startResult);
// Ensure the stream starts
frameHandlerMaster->waitForFrameCount(1);
// Start the camera's video stream via another client
startResult = frameHandlerNonMaster->startStream();
ASSERT_TRUE(startResult);
// Ensure the stream starts
frameHandlerNonMaster->waitForFrameCount(1);
int32_t val0 = 0;
std::vector<int32_t> values;
EvsEventDesc aNotification0 = {};
EvsEventDesc aNotification1 = {};
for (auto &cmd : camMasterCmds) {
// Get a valid parameter value range
int32_t minVal, maxVal, step;
pCamMaster->getIntParameterRange(
cmd,
[&minVal, &maxVal, &step](int32_t val0, int32_t val1, int32_t val2) {
minVal = val0;
maxVal = val1;
step = val2;
}
);
EvsResult result = EvsResult::OK;
if (cmd == CameraParam::ABSOLUTE_FOCUS) {
// Try to turn off auto-focus
values.clear();
pCamMaster->setIntParameter(CameraParam::AUTO_FOCUS, 0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(v, 0);
}
}
// Calculate a parameter value to program.
val0 = minVal + (std::rand() % (maxVal - minVal));
val0 = val0 - (val0 % step);
// Prepare and start event listeners.
bool listening0 = false;
bool listening1 = false;
std::condition_variable eventCond;
std::thread listener0 = std::thread(
[cmd, val0,
&aNotification0, &frameHandlerMaster, &listening0, &listening1, &eventCond]() {
listening0 = true;
if (listening1) {
eventCond.notify_all();
}
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(cmd);
aTargetEvent.payload[1] = val0;
if (!frameHandlerMaster->waitForEvent(aTargetEvent, aNotification0)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
std::thread listener1 = std::thread(
[cmd, val0,
&aNotification1, &frameHandlerNonMaster, &listening0, &listening1, &eventCond]() {
listening1 = true;
if (listening0) {
eventCond.notify_all();
}
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(cmd);
aTargetEvent.payload[1] = val0;
if (!frameHandlerNonMaster->waitForEvent(aTargetEvent, aNotification1)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a listening thread starts.
std::mutex eventLock;
std::unique_lock<std::mutex> lock(eventLock);
auto timer = std::chrono::system_clock::now();
while (!listening0 || !listening1) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
// Try to program a parameter
values.clear();
pCamMaster->setIntParameter(cmd, val0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(val0, v) << "Values are not matched.";
}
// Join a listening thread.
if (listener0.joinable()) {
listener0.join();
}
if (listener1.joinable()) {
listener1.join();
}
// Verify a change notification
ASSERT_EQ(EvsEventType::PARAMETER_CHANGED,
static_cast<EvsEventType>(aNotification0.aType));
ASSERT_EQ(EvsEventType::PARAMETER_CHANGED,
static_cast<EvsEventType>(aNotification1.aType));
ASSERT_EQ(cmd,
static_cast<CameraParam>(aNotification0.payload[0]));
ASSERT_EQ(cmd,
static_cast<CameraParam>(aNotification1.payload[0]));
for (auto &&v : values) {
ASSERT_EQ(v,
static_cast<int32_t>(aNotification0.payload[1]));
ASSERT_EQ(v,
static_cast<int32_t>(aNotification1.payload[1]));
}
// Clients expects to receive a parameter change notification
// whenever a master client adjusts it.
values.clear();
pCamMaster->getIntParameter(cmd,
[&result, &values](auto status, auto readValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : readValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(val0, v) << "Values are not matched.";
}
}
// Try to adjust a parameter via non-master client
values.clear();
pCamNonMaster->setIntParameter(camNonMasterCmds[0], val0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::INVALID_ARG, result);
// Non-master client attemps to be a master
result = pCamNonMaster->setMaster();
ASSERT_EQ(EvsResult::OWNERSHIP_LOST, result);
// Master client retires from a master role
bool listening = false;
std::condition_variable eventCond;
std::thread listener = std::thread(
[&aNotification0, &frameHandlerNonMaster, &listening, &eventCond]() {
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::MASTER_RELEASED;
if (!frameHandlerNonMaster->waitForEvent(aTargetEvent, aNotification0, true)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
std::mutex eventLock;
auto timer = std::chrono::system_clock::now();
std::unique_lock<std::mutex> lock(eventLock);
while (!listening) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
result = pCamMaster->unsetMaster();
ASSERT_EQ(EvsResult::OK, result);
if (listener.joinable()) {
listener.join();
}
ASSERT_EQ(EvsEventType::MASTER_RELEASED,
static_cast<EvsEventType>(aNotification0.aType));
// Try to adjust a parameter after being retired
values.clear();
pCamMaster->setIntParameter(camMasterCmds[0], val0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::INVALID_ARG, result);
// Non-master client becomes a master
result = pCamNonMaster->setMaster();
ASSERT_EQ(EvsResult::OK, result);
// Try to adjust a parameter via new master client
for (auto &cmd : camNonMasterCmds) {
// Get a valid parameter value range
int32_t minVal, maxVal, step;
pCamNonMaster->getIntParameterRange(
cmd,
[&minVal, &maxVal, &step](int32_t val0, int32_t val1, int32_t val2) {
minVal = val0;
maxVal = val1;
step = val2;
}
);
EvsResult result = EvsResult::OK;
values.clear();
if (cmd == CameraParam::ABSOLUTE_FOCUS) {
// Try to turn off auto-focus
values.clear();
pCamNonMaster->setIntParameter(CameraParam::AUTO_FOCUS, 0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(v, 0);
}
}
// Calculate a parameter value to program. This is being rounding down.
val0 = minVal + (std::rand() % (maxVal - minVal));
val0 = val0 - (val0 % step);
// Prepare and start event listeners.
bool listening0 = false;
bool listening1 = false;
std::condition_variable eventCond;
std::thread listener0 = std::thread(
[&cmd, &val0, &aNotification0, &frameHandlerMaster, &listening0, &listening1, &eventCond]() {
listening0 = true;
if (listening1) {
eventCond.notify_all();
}
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(cmd);
aTargetEvent.payload[1] = val0;
if (!frameHandlerMaster->waitForEvent(aTargetEvent, aNotification0)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
std::thread listener1 = std::thread(
[&cmd, &val0, &aNotification1, &frameHandlerNonMaster, &listening0, &listening1, &eventCond]() {
listening1 = true;
if (listening0) {
eventCond.notify_all();
}
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(cmd);
aTargetEvent.payload[1] = val0;
if (!frameHandlerNonMaster->waitForEvent(aTargetEvent, aNotification1)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a listening thread starts.
std::mutex eventLock;
std::unique_lock<std::mutex> lock(eventLock);
auto timer = std::chrono::system_clock::now();
while (!listening0 || !listening1) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
// Try to program a parameter
values.clear();
pCamNonMaster->setIntParameter(cmd, val0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
// Clients expects to receive a parameter change notification
// whenever a master client adjusts it.
values.clear();
pCamNonMaster->getIntParameter(cmd,
[&result, &values](auto status, auto readValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : readValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(val0, v) << "Values are not matched.";
}
// Join a listening thread.
if (listener0.joinable()) {
listener0.join();
}
if (listener1.joinable()) {
listener1.join();
}
// Verify a change notification
ASSERT_EQ(EvsEventType::PARAMETER_CHANGED,
static_cast<EvsEventType>(aNotification0.aType));
ASSERT_EQ(EvsEventType::PARAMETER_CHANGED,
static_cast<EvsEventType>(aNotification1.aType));
ASSERT_EQ(cmd,
static_cast<CameraParam>(aNotification0.payload[0]));
ASSERT_EQ(cmd,
static_cast<CameraParam>(aNotification1.payload[0]));
for (auto &&v : values) {
ASSERT_EQ(v,
static_cast<int32_t>(aNotification0.payload[1]));
ASSERT_EQ(v,
static_cast<int32_t>(aNotification1.payload[1]));
}
}
// New master retires from a master role
result = pCamNonMaster->unsetMaster();
ASSERT_EQ(EvsResult::OK, result);
// Shutdown
frameHandlerMaster->shutdown();
frameHandlerNonMaster->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCamMaster);
pEnumerator->closeCamera(pCamNonMaster);
activeCameras.clear();
}
}
/*
* HighPriorityCameraClient:
* EVS client, which owns the display, is priortized and therefore can take over
* a master role from other EVS clients without the display.
*/
TEST_P(EvsHidlTest, HighPriorityCameraClient) {
LOG(INFO) << "Starting HighPriorityCameraClient test";
if (mIsHwModule) {
// This test is not for HW module implementation.
return;
}
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Request exclusive access to the EVS display
sp<IEvsDisplay_1_0> pDisplay = pEnumerator->openDisplay();
ASSERT_NE(pDisplay, nullptr);
// Test each reported camera
for (auto&& cam: cameraInfo) {
// Create two clients
sp<IEvsCamera_1_1> pCam0 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam0, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam0);
sp<IEvsCamera_1_1> pCam1 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam1, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam1);
// Get the parameter list; this test will use the first command in both
// lists.
std::vector<CameraParam> cam0Cmds, cam1Cmds;
pCam0->getParameterList([&cam0Cmds](hidl_vec<CameraParam> cmdList) {
cam0Cmds.reserve(cmdList.size());
for (auto &&cmd : cmdList) {
cam0Cmds.push_back(cmd);
}
}
);
pCam1->getParameterList([&cam1Cmds](hidl_vec<CameraParam> cmdList) {
cam1Cmds.reserve(cmdList.size());
for (auto &&cmd : cmdList) {
cam1Cmds.push_back(cmd);
}
}
);
if (cam0Cmds.size() < 1 || cam1Cmds.size() < 1) {
// Cannot execute this test.
return;
}
// Set up a frame receiver object which will fire up its own thread.
sp<FrameHandler> frameHandler0 = new FrameHandler(pCam0, cam,
pDisplay,
FrameHandler::eAutoReturn);
sp<FrameHandler> frameHandler1 = new FrameHandler(pCam1, cam,
nullptr,
FrameHandler::eAutoReturn);
// Activate the display
pDisplay->setDisplayState(DisplayState::VISIBLE_ON_NEXT_FRAME);
// Start the camera's video stream
ASSERT_TRUE(frameHandler0->startStream());
ASSERT_TRUE(frameHandler1->startStream());
// Ensure the stream starts
frameHandler0->waitForFrameCount(1);
frameHandler1->waitForFrameCount(1);
// Client 1 becomes a master and programs a parameter.
EvsResult result = EvsResult::OK;
// Get a valid parameter value range
int32_t minVal, maxVal, step;
pCam1->getIntParameterRange(
cam1Cmds[0],
[&minVal, &maxVal, &step](int32_t val0, int32_t val1, int32_t val2) {
minVal = val0;
maxVal = val1;
step = val2;
}
);
// Client1 becomes a master
result = pCam1->setMaster();
ASSERT_EQ(EvsResult::OK, result);
std::vector<int32_t> values;
EvsEventDesc aTargetEvent = {};
EvsEventDesc aNotification = {};
bool listening = false;
std::mutex eventLock;
std::condition_variable eventCond;
if (cam1Cmds[0] == CameraParam::ABSOLUTE_FOCUS) {
std::thread listener = std::thread(
[&frameHandler0, &aNotification, &listening, &eventCond] {
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(CameraParam::AUTO_FOCUS);
aTargetEvent.payload[1] = 0;
if (!frameHandler0->waitForEvent(aTargetEvent, aNotification)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a lister starts.
std::unique_lock<std::mutex> lock(eventLock);
auto timer = std::chrono::system_clock::now();
while (!listening) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
// Try to turn off auto-focus
pCam1->setIntParameter(CameraParam::AUTO_FOCUS, 0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(v, 0);
}
// Join a listener
if (listener.joinable()) {
listener.join();
}
// Make sure AUTO_FOCUS is off.
ASSERT_EQ(static_cast<EvsEventType>(aNotification.aType),
EvsEventType::PARAMETER_CHANGED);
}
// Try to program a parameter with a random value [minVal, maxVal] after
// rounding it down.
int32_t val0 = minVal + (std::rand() % (maxVal - minVal));
val0 = val0 - (val0 % step);
std::thread listener = std::thread(
[&frameHandler1, &aNotification, &listening, &eventCond, &cam1Cmds, val0] {
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(cam1Cmds[0]);
aTargetEvent.payload[1] = val0;
if (!frameHandler1->waitForEvent(aTargetEvent, aNotification)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a lister starts.
listening = false;
std::unique_lock<std::mutex> lock(eventLock);
auto timer = std::chrono::system_clock::now();
while (!listening) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
values.clear();
pCam1->setIntParameter(cam1Cmds[0], val0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(val0, v);
}
// Join a listener
if (listener.joinable()) {
listener.join();
}
// Verify a change notification
ASSERT_EQ(static_cast<EvsEventType>(aNotification.aType),
EvsEventType::PARAMETER_CHANGED);
ASSERT_EQ(static_cast<CameraParam>(aNotification.payload[0]),
cam1Cmds[0]);
for (auto &&v : values) {
ASSERT_EQ(v, static_cast<int32_t>(aNotification.payload[1]));
}
listener = std::thread(
[&frameHandler1, &aNotification, &listening, &eventCond] {
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::MASTER_RELEASED;
if (!frameHandler1->waitForEvent(aTargetEvent, aNotification, true)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a lister starts.
listening = false;
lock.lock();
timer = std::chrono::system_clock::now();
while (!listening) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
// Client 0 steals a master role
ASSERT_EQ(EvsResult::OK, pCam0->forceMaster(pDisplay));
// Join a listener
if (listener.joinable()) {
listener.join();
}
ASSERT_EQ(static_cast<EvsEventType>(aNotification.aType),
EvsEventType::MASTER_RELEASED);
// Client 0 programs a parameter
val0 = minVal + (std::rand() % (maxVal - minVal));
// Rounding down
val0 = val0 - (val0 % step);
if (cam0Cmds[0] == CameraParam::ABSOLUTE_FOCUS) {
std::thread listener = std::thread(
[&frameHandler1, &aNotification, &listening, &eventCond] {
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(CameraParam::AUTO_FOCUS);
aTargetEvent.payload[1] = 0;
if (!frameHandler1->waitForEvent(aTargetEvent, aNotification)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a lister starts.
std::unique_lock<std::mutex> lock(eventLock);
auto timer = std::chrono::system_clock::now();
while (!listening) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
// Try to turn off auto-focus
values.clear();
pCam0->setIntParameter(CameraParam::AUTO_FOCUS, 0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
for (auto &&v : values) {
ASSERT_EQ(v, 0);
}
// Join a listener
if (listener.joinable()) {
listener.join();
}
// Make sure AUTO_FOCUS is off.
ASSERT_EQ(static_cast<EvsEventType>(aNotification.aType),
EvsEventType::PARAMETER_CHANGED);
}
listener = std::thread(
[&frameHandler0, &aNotification, &listening, &eventCond, &cam0Cmds, val0] {
listening = true;
eventCond.notify_all();
EvsEventDesc aTargetEvent;
aTargetEvent.aType = EvsEventType::PARAMETER_CHANGED;
aTargetEvent.payload[0] = static_cast<uint32_t>(cam0Cmds[0]);
aTargetEvent.payload[1] = val0;
if (!frameHandler0->waitForEvent(aTargetEvent, aNotification)) {
LOG(WARNING) << "A timer is expired before a target event is fired.";
}
}
);
// Wait until a lister starts.
listening = false;
timer = std::chrono::system_clock::now();
lock.lock();
while (!listening) {
eventCond.wait_until(lock, timer + 1s);
}
lock.unlock();
values.clear();
pCam0->setIntParameter(cam0Cmds[0], val0,
[&result, &values](auto status, auto effectiveValues) {
result = status;
if (status == EvsResult::OK) {
for (auto &&v : effectiveValues) {
values.push_back(v);
}
}
});
ASSERT_EQ(EvsResult::OK, result);
// Join a listener
if (listener.joinable()) {
listener.join();
}
// Verify a change notification
ASSERT_EQ(static_cast<EvsEventType>(aNotification.aType),
EvsEventType::PARAMETER_CHANGED);
ASSERT_EQ(static_cast<CameraParam>(aNotification.payload[0]),
cam0Cmds[0]);
for (auto &&v : values) {
ASSERT_EQ(v, static_cast<int32_t>(aNotification.payload[1]));
}
// Turn off the display (yes, before the stream stops -- it should be handled)
pDisplay->setDisplayState(DisplayState::NOT_VISIBLE);
// Shut down the streamer
frameHandler0->shutdown();
frameHandler1->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam0);
pEnumerator->closeCamera(pCam1);
activeCameras.clear();
}
// Explicitly release the display
pEnumerator->closeDisplay(pDisplay);
}
/*
* CameraUseStreamConfigToDisplay:
* End to end test of data flowing from the camera to the display. Similar to
* CameraToDisplayRoundTrip test case but this case retrieves available stream
* configurations from EVS and uses one of them to start a video stream.
*/
TEST_P(EvsHidlTest, CameraUseStreamConfigToDisplay) {
LOG(INFO) << "Starting CameraUseStreamConfigToDisplay test";
// Get the camera list
loadCameraList();
// Request exclusive access to the EVS display
sp<IEvsDisplay_1_0> pDisplay = pEnumerator->openDisplay();
ASSERT_NE(pDisplay, nullptr);
// Test each reported camera
for (auto&& cam: cameraInfo) {
// choose a configuration that has a frame rate faster than minReqFps.
Stream targetCfg = {};
const int32_t minReqFps = 15;
int32_t maxArea = 0;
camera_metadata_entry_t streamCfgs;
bool foundCfg = false;
if (!find_camera_metadata_entry(
reinterpret_cast<camera_metadata_t *>(cam.metadata.data()),
ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
&streamCfgs)) {
// Stream configurations are found in metadata
RawStreamConfig *ptr = reinterpret_cast<RawStreamConfig *>(streamCfgs.data.i32);
for (unsigned idx = 0; idx < streamCfgs.count; idx += kStreamCfgSz) {
if (ptr->direction == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
ptr->format == HAL_PIXEL_FORMAT_RGBA_8888) {
if (ptr->width * ptr->height > maxArea &&
ptr->framerate >= minReqFps) {
targetCfg.width = ptr->width;
targetCfg.height = ptr->height;
maxArea = ptr->width * ptr->height;
foundCfg = true;
}
}
++ptr;
}
}
targetCfg.format =
static_cast<PixelFormat>(HAL_PIXEL_FORMAT_RGBA_8888);
if (!foundCfg) {
// Current EVS camera does not provide stream configurations in the
// metadata.
continue;
}
sp<IEvsCamera_1_1> pCam =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, targetCfg))
.withDefault(nullptr);
ASSERT_NE(pCam, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam);
// Set up a frame receiver object which will fire up its own thread.
sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
pDisplay,
FrameHandler::eAutoReturn);
// Activate the display
pDisplay->setDisplayState(DisplayState::VISIBLE_ON_NEXT_FRAME);
// Start the camera's video stream
bool startResult = frameHandler->startStream();
ASSERT_TRUE(startResult);
// Wait a while to let the data flow
static const int kSecondsToWait = 5;
const int streamTimeMs = kSecondsToWait * kSecondsToMilliseconds -
kMaxStreamStartMilliseconds;
const unsigned minimumFramesExpected = streamTimeMs * kMinimumFramesPerSecond /
kSecondsToMilliseconds;
sleep(kSecondsToWait);
unsigned framesReceived = 0;
unsigned framesDisplayed = 0;
frameHandler->getFramesCounters(&framesReceived, &framesDisplayed);
EXPECT_EQ(framesReceived, framesDisplayed);
EXPECT_GE(framesDisplayed, minimumFramesExpected);
// Turn off the display (yes, before the stream stops -- it should be handled)
pDisplay->setDisplayState(DisplayState::NOT_VISIBLE);
// Shut down the streamer
frameHandler->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam);
activeCameras.clear();
}
// Explicitly release the display
pEnumerator->closeDisplay(pDisplay);
}
/*
* MultiCameraStreamUseConfig:
* Verify that each client can start and stop video streams on the same
* underlying camera with same configuration.
*/
TEST_P(EvsHidlTest, MultiCameraStreamUseConfig) {
LOG(INFO) << "Starting MultiCameraStream test";
if (mIsHwModule) {
// This test is not for HW module implementation.
return;
}
// Get the camera list
loadCameraList();
// Test each reported camera
for (auto&& cam: cameraInfo) {
// choose a configuration that has a frame rate faster than minReqFps.
Stream targetCfg = {};
const int32_t minReqFps = 15;
int32_t maxArea = 0;
camera_metadata_entry_t streamCfgs;
bool foundCfg = false;
if (!find_camera_metadata_entry(
reinterpret_cast<camera_metadata_t *>(cam.metadata.data()),
ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
&streamCfgs)) {
// Stream configurations are found in metadata
RawStreamConfig *ptr = reinterpret_cast<RawStreamConfig *>(streamCfgs.data.i32);
for (unsigned idx = 0; idx < streamCfgs.count; idx += kStreamCfgSz) {
if (ptr->direction == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
ptr->format == HAL_PIXEL_FORMAT_RGBA_8888) {
if (ptr->width * ptr->height > maxArea &&
ptr->framerate >= minReqFps) {
targetCfg.width = ptr->width;
targetCfg.height = ptr->height;
maxArea = ptr->width * ptr->height;
foundCfg = true;
}
}
++ptr;
}
}
targetCfg.format =
static_cast<PixelFormat>(HAL_PIXEL_FORMAT_RGBA_8888);
if (!foundCfg) {
LOG(INFO) << "Device " << cam.v1.cameraId
<< " does not provide a list of supported stream configurations, skipped";
continue;
}
// Create the first camera client with a selected stream configuration.
sp<IEvsCamera_1_1> pCam0 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, targetCfg))
.withDefault(nullptr);
ASSERT_NE(pCam0, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam0);
// Try to create the second camera client with different stream
// configuration.
int32_t id = targetCfg.id;
targetCfg.id += 1; // EVS manager sees only the stream id.
sp<IEvsCamera_1_1> pCam1 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, targetCfg))
.withDefault(nullptr);
ASSERT_EQ(pCam1, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam0);
// Try again with same stream configuration.
targetCfg.id = id;
pCam1 =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, targetCfg))
.withDefault(nullptr);
ASSERT_NE(pCam1, nullptr);
// Set up per-client frame receiver objects which will fire up its own thread
sp<FrameHandler> frameHandler0 = new FrameHandler(pCam0, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandler0, nullptr);
sp<FrameHandler> frameHandler1 = new FrameHandler(pCam1, cam,
nullptr,
FrameHandler::eAutoReturn);
ASSERT_NE(frameHandler1, nullptr);
// Start the camera's video stream via client 0
bool startResult = false;
startResult = frameHandler0->startStream() &&
frameHandler1->startStream();
ASSERT_TRUE(startResult);
// Ensure the stream starts
frameHandler0->waitForFrameCount(1);
frameHandler1->waitForFrameCount(1);
nsecs_t firstFrame = systemTime(SYSTEM_TIME_MONOTONIC);
// Wait a bit, then ensure both clients get at least the required minimum number of frames
sleep(5);
nsecs_t end = systemTime(SYSTEM_TIME_MONOTONIC);
unsigned framesReceived0 = 0, framesReceived1 = 0;
frameHandler0->getFramesCounters(&framesReceived0, nullptr);
frameHandler1->getFramesCounters(&framesReceived1, nullptr);
framesReceived0 = framesReceived0 - 1; // Back out the first frame we already waited for
framesReceived1 = framesReceived1 - 1; // Back out the first frame we already waited for
nsecs_t runTime = end - firstFrame;
float framesPerSecond0 = framesReceived0 / (runTime * kNanoToSeconds);
float framesPerSecond1 = framesReceived1 / (runTime * kNanoToSeconds);
LOG(INFO) << "Measured camera rate "
<< std::scientific << framesPerSecond0 << " fps and "
<< framesPerSecond1 << " fps";
EXPECT_GE(framesPerSecond0, kMinimumFramesPerSecond);
EXPECT_GE(framesPerSecond1, kMinimumFramesPerSecond);
// Shutdown one client
frameHandler0->shutdown();
// Read frame counters again
frameHandler0->getFramesCounters(&framesReceived0, nullptr);
frameHandler1->getFramesCounters(&framesReceived1, nullptr);
// Wait a bit again
sleep(5);
unsigned framesReceivedAfterStop0 = 0, framesReceivedAfterStop1 = 0;
frameHandler0->getFramesCounters(&framesReceivedAfterStop0, nullptr);
frameHandler1->getFramesCounters(&framesReceivedAfterStop1, nullptr);
EXPECT_EQ(framesReceived0, framesReceivedAfterStop0);
EXPECT_LT(framesReceived1, framesReceivedAfterStop1);
// Shutdown another
frameHandler1->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam0);
pEnumerator->closeCamera(pCam1);
activeCameras.clear();
}
}
/*
* LogicalCameraMetadata:
* Opens logical camera reported by the enumerator and validate its metadata by
* checking its capability and locating supporting physical camera device
* identifiers.
*/
TEST_P(EvsHidlTest, LogicalCameraMetadata) {
LOG(INFO) << "Starting LogicalCameraMetadata test";
// Get the camera list
loadCameraList();
// Open and close each camera twice
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
auto devices = getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
if (isLogicalCam) {
ASSERT_GE(devices.size(), 1) <<
"Logical camera device must have at least one physical camera device ID in its metadata.";
}
}
}
/*
* CameraStreamExternalBuffering:
* This is same with CameraStreamBuffering except frame buffers are allocated by
* the test client and then imported by EVS framework.
*/
TEST_P(EvsHidlTest, CameraStreamExternalBuffering) {
LOG(INFO) << "Starting CameraStreamExternalBuffering test";
// Arbitrary constant (should be > 1 and less than crazy)
static const unsigned int kBuffersToHold = 6;
// Get the camera list
loadCameraList();
// Using null stream configuration makes EVS uses the default resolution and
// output format.
Stream nullCfg = {};
// Acquire the graphics buffer allocator
android::GraphicBufferAllocator& alloc(android::GraphicBufferAllocator::get());
const auto usage = GRALLOC_USAGE_HW_TEXTURE |
GRALLOC_USAGE_SW_READ_RARELY |
GRALLOC_USAGE_SW_WRITE_OFTEN;
const auto format = HAL_PIXEL_FORMAT_RGBA_8888;
const auto width = 640;
const auto height = 360;
// Allocate buffers to use
hidl_vec<BufferDesc> buffers;
buffers.resize(kBuffersToHold);
for (auto i = 0; i < kBuffersToHold; ++i) {
unsigned pixelsPerLine;
buffer_handle_t memHandle = nullptr;
android::status_t result = alloc.allocate(width,
height,
format,
1,
usage,
&memHandle,
&pixelsPerLine,
0,
"EvsApp");
if (result != android::NO_ERROR) {
LOG(ERROR) << __FUNCTION__ << " failed to allocate memory.";
} else {
BufferDesc buf;
AHardwareBuffer_Desc* pDesc =
reinterpret_cast<AHardwareBuffer_Desc *>(&buf.buffer.description);
pDesc->width = width;
pDesc->height = height;
pDesc->layers = 1;
pDesc->format = format;
pDesc->usage = usage;
pDesc->stride = pixelsPerLine;
buf.buffer.nativeHandle = memHandle;
buf.bufferId = i; // Unique number to identify this buffer
buffers[i] = buf;
}
}
// Test each reported camera
for (auto&& cam: cameraInfo) {
bool isLogicalCam = false;
getPhysicalCameraIds(cam.v1.cameraId, isLogicalCam);
sp<IEvsCamera_1_1> pCam =
IEvsCamera_1_1::castFrom(pEnumerator->openCamera_1_1(cam.v1.cameraId, nullCfg))
.withDefault(nullptr);
ASSERT_NE(pCam, nullptr);
// Store a camera handle for a clean-up
activeCameras.push_back(pCam);
// Request to import buffers
EvsResult result = EvsResult::OK;
int delta = 0;
pCam->importExternalBuffers(buffers,
[&] (auto _result, auto _delta) {
result = _result;
delta = _delta;
});
if (isLogicalCam) {
EXPECT_EQ(result, EvsResult::UNDERLYING_SERVICE_ERROR);
continue;
}
EXPECT_EQ(result, EvsResult::OK);
EXPECT_GE(delta, 0);
// Set up a frame receiver object which will fire up its own thread.
sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
nullptr,
FrameHandler::eNoAutoReturn);
// Start the camera's video stream
bool startResult = frameHandler->startStream();
ASSERT_TRUE(startResult);
// Check that the video stream stalls once we've gotten exactly the number of buffers
// we requested since we told the frameHandler not to return them.
sleep(1); // 1 second should be enough for at least 5 frames to be delivered worst case
unsigned framesReceived = 0;
frameHandler->getFramesCounters(&framesReceived, nullptr);
ASSERT_EQ(kBuffersToHold, framesReceived) << "Stream didn't stall at expected buffer limit";
// Give back one buffer
bool didReturnBuffer = frameHandler->returnHeldBuffer();
EXPECT_TRUE(didReturnBuffer);
// Once we return a buffer, it shouldn't take more than 1/10 second to get a new one
// filled since we require 10fps minimum -- but give a 10% allowance just in case.
usleep(110 * kMillisecondsToMicroseconds);
frameHandler->getFramesCounters(&framesReceived, nullptr);
EXPECT_EQ(kBuffersToHold+1, framesReceived) << "Stream should've resumed";
// Even when the camera pointer goes out of scope, the FrameHandler object will
// keep the stream alive unless we tell it to shutdown.
// Also note that the FrameHandle and the Camera have a mutual circular reference, so
// we have to break that cycle in order for either of them to get cleaned up.
frameHandler->shutdown();
// Explicitly release the camera
pEnumerator->closeCamera(pCam);
activeCameras.clear();
}
// Release buffers
for (auto& b : buffers) {
alloc.free(b.buffer.nativeHandle);
}
buffers.resize(0);
}
/*
* UltrasonicsArrayOpenClean:
* Opens each ultrasonics arrays reported by the enumerator and then explicitly closes it via a
* call to closeUltrasonicsArray. Then repeats the test to ensure all ultrasonics arrays
* can be reopened.
*/
TEST_P(EvsHidlTest, UltrasonicsArrayOpenClean) {
LOG(INFO) << "Starting UltrasonicsArrayOpenClean test";
// Get the ultrasonics array list
loadUltrasonicsArrayList();
// Open and close each ultrasonics array twice
for (auto&& ultraInfo : ultrasonicsArraysInfo) {
for (int pass = 0; pass < 2; pass++) {
sp<IEvsUltrasonicsArray> pUltrasonicsArray =
pEnumerator->openUltrasonicsArray(ultraInfo.ultrasonicsArrayId);
ASSERT_NE(pUltrasonicsArray, nullptr);
// Verify that this ultrasonics array self-identifies correctly
pUltrasonicsArray->getUltrasonicArrayInfo([&ultraInfo](UltrasonicsArrayDesc desc) {
LOG(DEBUG) << "Found ultrasonics array " << ultraInfo.ultrasonicsArrayId;
EXPECT_EQ(ultraInfo.ultrasonicsArrayId, desc.ultrasonicsArrayId);
});
// Explicitly close the ultrasonics array so resources are released right away
pEnumerator->closeUltrasonicsArray(pUltrasonicsArray);
}
}
}
// Starts a stream and verifies all data received is valid.
TEST_P(EvsHidlTest, UltrasonicsVerifyStreamData) {
LOG(INFO) << "Starting UltrasonicsVerifyStreamData";
// Get the ultrasonics array list
loadUltrasonicsArrayList();
// For each ultrasonics array.
for (auto&& ultraInfo : ultrasonicsArraysInfo) {
LOG(DEBUG) << "Testing ultrasonics array: " << ultraInfo.ultrasonicsArrayId;
sp<IEvsUltrasonicsArray> pUltrasonicsArray =
pEnumerator->openUltrasonicsArray(ultraInfo.ultrasonicsArrayId);
ASSERT_NE(pUltrasonicsArray, nullptr);
sp<FrameHandlerUltrasonics> frameHandler = new FrameHandlerUltrasonics(pUltrasonicsArray);
// Start stream.
EvsResult result = pUltrasonicsArray->startStream(frameHandler);
ASSERT_EQ(result, EvsResult::OK);
// Wait 5 seconds to receive frames.
sleep(5);
// Stop stream.
pUltrasonicsArray->stopStream();
EXPECT_GT(frameHandler->getReceiveFramesCount(), 0);
EXPECT_TRUE(frameHandler->areAllFramesValid());
// Explicitly close the ultrasonics array so resources are released right away
pEnumerator->closeUltrasonicsArray(pUltrasonicsArray);
}
}
// Sets frames in flight before and after start of stream and verfies success.
TEST_P(EvsHidlTest, UltrasonicsSetFramesInFlight) {
LOG(INFO) << "Starting UltrasonicsSetFramesInFlight";
// Get the ultrasonics array list
loadUltrasonicsArrayList();
// For each ultrasonics array.
for (auto&& ultraInfo : ultrasonicsArraysInfo) {
LOG(DEBUG) << "Testing ultrasonics array: " << ultraInfo.ultrasonicsArrayId;
sp<IEvsUltrasonicsArray> pUltrasonicsArray =
pEnumerator->openUltrasonicsArray(ultraInfo.ultrasonicsArrayId);
ASSERT_NE(pUltrasonicsArray, nullptr);
EvsResult result = pUltrasonicsArray->setMaxFramesInFlight(10);
EXPECT_EQ(result, EvsResult::OK);
sp<FrameHandlerUltrasonics> frameHandler = new FrameHandlerUltrasonics(pUltrasonicsArray);
// Start stream.
result = pUltrasonicsArray->startStream(frameHandler);
ASSERT_EQ(result, EvsResult::OK);
result = pUltrasonicsArray->setMaxFramesInFlight(5);
EXPECT_EQ(result, EvsResult::OK);
// Stop stream.
pUltrasonicsArray->stopStream();
// Explicitly close the ultrasonics array so resources are released right away
pEnumerator->closeUltrasonicsArray(pUltrasonicsArray);
}
}
INSTANTIATE_TEST_SUITE_P(
PerInstance,
EvsHidlTest,
testing::ValuesIn(android::hardware::getAllHalInstanceNames(IEvsEnumerator::descriptor)),
android::hardware::PrintInstanceNameToString);