Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 11:36:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "camera: Add boolean to HalStream for stream specific HAL buffer manager" into main

Browse Source
This commit is contained in:
Jayant Chowdhary
2024-01-06 07:15:44 +00:00
committed by Android (Google) Code Review
parent 34b761ab51 4869ae7838
commit 2d51f59db5
7 changed files with 156 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/ConfigureStreamsRet.aidl
View File

@@ -35,5 +35,4 @@ package android.hardware.camera.device;
@VintfStability
parcelable ConfigureStreamsRet {
android.hardware.camera.device.HalStream[] halStreams;
boolean enableHalBufferManager = false;
}

1
camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/HalStream.aidl
View File

@@ -42,4 +42,5 @@ parcelable HalStream {
android.hardware.graphics.common.Dataspace overrideDataSpace;
String physicalCameraId;
boolean supportOffline;
boolean enableHalBufferManager;
}

5
camera/device/aidl/android/hardware/camera/device/ConfigureStreamsRet.aidl
View File

@@ -34,9 +34,4 @@ parcelable ConfigureStreamsRet {
* overridden format, maximum buffers etc.
*/
HalStream[] halStreams;
/**
* A boolean informing the camera framework whether the HAL buffer manager
* must be used for the session configured.
*/
boolean enableHalBufferManager = false;
}

20
camera/device/aidl/android/hardware/camera/device/HalStream.aidl
View File

@@ -127,4 +127,24 @@ parcelable HalStream {
*
*/
boolean supportOffline;
/**
* Whether the buffers for this stream are HAL buffer managed.
*
* If ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION is
* ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE, this field
* must be set by the HAL to inform the camera framework, whether output buffers for this
* stream will be HAL buffer managed - i.e. requested through the
* ICameraDeviceCallback.requestStreamsBuffers() API. Only the output buffers for the streams
* that have this field set to 'true' will be HAL buffer managed. The output buffers for other
* streams will be managed by the camera framework.
*
* If the value of ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION is
* ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_AIDL_DEVICE, the camera framework
* will ignore this field and assume that all output streams are hal buffer managed.
*
* If ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION is not set at all, the camera framework
* will ignore this field and assume output buffers are managed by the camera framework.
*/
boolean enableHalBufferManager;
}

63
camera/provider/aidl/vts/VtsAidlHalCameraProvider_TargetTest.cpp
View File

@@ -698,7 +698,6 @@ TEST_P(CameraAidlTest, configureConcurrentStreamsAvailableOutputs) {
for (const auto& cameraDeviceIds : concurrentDeviceCombinations) {
std::vector<CameraIdAndStreamCombination> cameraIdsAndStreamCombinations;
std::vector<CameraTestInfo> cameraTestInfos;
size_t i = 0;
for (const auto& id : cameraDeviceIds.combination) {
CameraTestInfo cti;
auto it = idToNameMap.find(id);
@@ -749,7 +748,6 @@ TEST_P(CameraAidlTest, configureConcurrentStreamsAvailableOutputs) {
cameraIdAndStreamCombination.cameraId = id;
cameraIdAndStreamCombination.streamConfiguration = cti.config;
cameraIdsAndStreamCombinations.push_back(cameraIdAndStreamCombination);
i++;
cameraTestInfos.push_back(cti);
}
// Now verify that concurrent streams are supported
@@ -1614,7 +1612,7 @@ TEST_P(CameraAidlTest, processMultiCaptureRequestPreview) {
std::vector<HalStream> halStreams;
bool supportsPartialResults = false;
bool useHalBufManager = false;
std::set<int32_t> halBufManagedStreamIds;
int32_t partialResultCount = 0;
Stream previewStream;
std::shared_ptr<DeviceCb> cb;
@@ -1622,7 +1620,7 @@ TEST_P(CameraAidlTest, processMultiCaptureRequestPreview) {
configurePreviewStreams(
name, mProvider, &previewThreshold, physicalIds, &mSession, &previewStream,
&halStreams /*out*/, &supportsPartialResults /*out*/, &partialResultCount /*out*/,
&useHalBufManager /*out*/, &cb /*out*/, 0 /*streamConfigCounter*/, true);
&halBufManagedStreamIds /*out*/, &cb /*out*/, 0 /*streamConfigCounter*/, true);
if (mSession == nullptr) {
// stream combination not supported by HAL, skip test for device
continue;
@@ -1659,7 +1657,9 @@ TEST_P(CameraAidlTest, processMultiCaptureRequestPreview) {
size_t k = 0;
for (const auto& halStream : halStreams) {
buffer_handle_t buffer_handle;
if (useHalBufManager) {
bool useHalBufManagerForStream =
halBufManagedStreamIds.find(halStream.id) != halBufManagedStreamIds.end();
if (useHalBufManagerForStream) {
outputBuffers[k] = {halStream.id, /*bufferId*/ 0, NativeHandle(),
BufferStatus::OK, NativeHandle(), NativeHandle()};
} else {
@@ -1763,10 +1763,13 @@ TEST_P(CameraAidlTest, processMultiCaptureRequestPreview) {
defaultPreviewSettings.unlock(settingsBuffer);
filteredSettings.unlock(filteredSettingsBuffer);
if (useHalBufManager) {
std::vector<int32_t> streamIds(halStreams.size());
for (size_t i = 0; i < streamIds.size(); i++) {
streamIds[i] = halStreams[i].id;
if (halBufManagedStreamIds.size() != 0) {
std::vector<int32_t> streamIds;
for (size_t i = 0; i < halStreams.size(); i++) {
int32_t streamId = halStreams[i].id;
if (halBufManagedStreamIds.find(streamId) != halBufManagedStreamIds.end()) {
streamIds.emplace_back(streamId);
}
}
verifyBuffersReturned(mSession, streamIds, cb);
}
@@ -1830,7 +1833,7 @@ TEST_P(CameraAidlTest, processUltraHighResolutionRequest) {
std::vector<HalStream> halStreams;
bool supportsPartialResults = false;
bool useHalBufManager = false;
std::set<int32_t> halBufManagedStreamIds;
int32_t partialResultCount = 0;
Stream previewStream;
std::shared_ptr<DeviceCb> cb;
@@ -1842,8 +1845,8 @@ TEST_P(CameraAidlTest, processUltraHighResolutionRequest) {
GRALLOC1_CONSUMER_USAGE_CPU_READ);
previewStream.dataSpace = Dataspace::UNKNOWN;
configureStreams(name, mProvider, format, &mSession, &previewStream, &halStreams,
&supportsPartialResults, &partialResultCount, &useHalBufManager, &cb,
0, /*maxResolution*/ true);
&supportsPartialResults, &partialResultCount, &halBufManagedStreamIds,
&cb, 0, /*maxResolution*/ true);
ASSERT_NE(mSession, nullptr);
::aidl::android::hardware::common::fmq::MQDescriptor<
@@ -1874,7 +1877,9 @@ TEST_P(CameraAidlTest, processUltraHighResolutionRequest) {
size_t k = 0;
for (const auto& halStream : halStreams) {
buffer_handle_t buffer_handle;
if (useHalBufManager) {
bool halBufManagerUsed =
halBufManagedStreamIds.find(halStream.id) != halBufManagedStreamIds.end();
if (halBufManagerUsed) {
outputBuffers[k] = {halStream.id, 0,
NativeHandle(), BufferStatus::OK,
NativeHandle(), NativeHandle()};
@@ -1926,10 +1931,12 @@ TEST_P(CameraAidlTest, processUltraHighResolutionRequest) {
ASSERT_FALSE(inflightReq->errorCodeValid);
ASSERT_NE(inflightReq->resultOutputBuffers.size(), 0u);
}
if (useHalBufManager) {
std::vector<int32_t> streamIds(halStreams.size());
for (size_t i = 0; i < streamIds.size(); i++) {
streamIds[i] = halStreams[i].id;
if (halBufManagedStreamIds.size()) {
std::vector<int32_t> streamIds;
for (size_t i = 0; i < halStreams.size(); i++) {
if (contains(halBufManagedStreamIds, halStreams[i].id)) {
streamIds.emplace_back(halStreams[i].id);
}
}
verifyBuffersReturned(mSession, streamIds, cb);
}
@@ -1991,7 +1998,7 @@ TEST_P(CameraAidlTest, process10BitDynamicRangeRequest) {
std::vector<HalStream> halStreams;
bool supportsPartialResults = false;
bool useHalBufManager = false;
std::set<int32_t> halBufManagedStreamIds;
int32_t partialResultCount = 0;
Stream previewStream;
std::shared_ptr<DeviceCb> cb;
@@ -2002,7 +2009,7 @@ TEST_P(CameraAidlTest, process10BitDynamicRangeRequest) {
previewStream.dataSpace = getDataspace(PixelFormat::IMPLEMENTATION_DEFINED);
configureStreams(name, mProvider, PixelFormat::IMPLEMENTATION_DEFINED, &mSession,
&previewStream, &halStreams, &supportsPartialResults,
&partialResultCount, &useHalBufManager, &cb, 0,
&partialResultCount, &halBufManagedStreamIds, &cb, 0,
/*maxResolution*/ false, profile);
ASSERT_NE(mSession, nullptr);
@@ -2041,7 +2048,7 @@ TEST_P(CameraAidlTest, process10BitDynamicRangeRequest) {
auto bufferId = requestId + 1; // Buffer id value 0 is not valid
for (const auto& halStream : halStreams) {
buffer_handle_t buffer_handle;
if (useHalBufManager) {
if (contains(halBufManagedStreamIds, halStream.id)) {
outputBuffers[k] = {halStream.id, 0,
NativeHandle(), BufferStatus::OK,
NativeHandle(), NativeHandle()};
@@ -2107,10 +2114,12 @@ TEST_P(CameraAidlTest, process10BitDynamicRangeRequest) {
verify10BitMetadata(mHandleImporter, *inflightReq, profile);
}
if (useHalBufManager) {
std::vector<int32_t> streamIds(halStreams.size());
for (size_t i = 0; i < streamIds.size(); i++) {
streamIds[i] = halStreams[i].id;
if (halBufManagedStreamIds.size() != 0) {
std::vector<int32_t> streamIds;
for (size_t i = 0; i < halStreams.size(); i++) {
if (contains(halBufManagedStreamIds, halStreams[i].id)) {
streamIds.emplace_back(halStreams[i].id);
}
}
mSession->signalStreamFlush(streamIds, /*streamConfigCounter*/ 0);
cb->waitForBuffersReturned();
@@ -2442,11 +2451,11 @@ TEST_P(CameraAidlTest, switchToOffline) {
std::vector<HalStream> halStreams;
std::shared_ptr<DeviceCb> cb;
int32_t jpegBufferSize;
bool useHalBufManager;
std::set<int32_t> halBufManagedStreamIds;
configureOfflineStillStream(name, mProvider, &threshold, &mSession /*out*/, &stream /*out*/,
&halStreams /*out*/, &supportsPartialResults /*out*/,
&partialResultCount /*out*/, &cb /*out*/,
&jpegBufferSize /*out*/, &useHalBufManager /*out*/);
&jpegBufferSize /*out*/, &halBufManagedStreamIds /*out*/);
auto ret = mSession->constructDefaultRequestSettings(RequestTemplate::STILL_CAPTURE,
&settings);
@@ -2482,7 +2491,7 @@ TEST_P(CameraAidlTest, switchToOffline) {
StreamBuffer& outputBuffer = outputBuffers[0];
std::unique_lock<std::mutex> l(mLock);
if (useHalBufManager) {
if (contains(halBufManagedStreamIds, halStream.id)) {
outputBuffer = {halStream.id, 0, NativeHandle(), BufferStatus::OK, NativeHandle(),
NativeHandle()};
} else {

152
camera/provider/aidl/vts/camera_aidl_test.cpp
View File

@@ -2258,7 +2258,6 @@ void CameraAidlTest::processCaptureRequestInternal(uint64_t bufferUsage,
int64_t bufferId = 1;
int32_t frameNumber = 1;
CameraMetadata settings;
for (const auto& name : cameraDeviceNames) {
Stream testStream;
std::vector<HalStream> halStreams;
@@ -2548,12 +2547,19 @@ void CameraAidlTest::configureStreamUseCaseInternal(const AvailableStream &thres
ndk::ScopedAStatus CameraAidlTest::configureStreams(std::shared_ptr<ICameraDeviceSession>& session,
const StreamConfiguration& config,
bool sessionHalBufferManager,
bool* useHalBufManager,
BufferManagerType bufferManagerType,
std::set<int32_t>* halBufManagedStreamIds,
std::vector<HalStream>* halStreams) {
auto ret = ndk::ScopedAStatus::ok();
ConfigureStreamsRet aidl_return;
if (sessionHalBufferManager) {
int32_t interfaceVersion = -1;
ret = session->getInterfaceVersion(&interfaceVersion);
if (!ret.isOk()) {
return ret;
}
if (flags::session_hal_buf_manager() &&
(bufferManagerType == BufferManagerType::SESSION && interfaceVersion >= 3)) {
ret = session->configureStreamsV2(config, &aidl_return);
} else {
ret = session->configureStreams(config, halStreams);
@@ -2561,10 +2567,16 @@ ndk::ScopedAStatus CameraAidlTest::configureStreams(std::shared_ptr<ICameraDevic
if (!ret.isOk()) {
return ret;
}
if (sessionHalBufferManager) {
*useHalBufManager = aidl_return.enableHalBufferManager;
if (flags::session_hal_buf_manager() && bufferManagerType == BufferManagerType::SESSION) {
*halStreams = std::move(aidl_return.halStreams);
}
for (const auto& halStream : *halStreams) {
if ((flags::session_hal_buf_manager() && bufferManagerType == BufferManagerType::SESSION &&
halStream.enableHalBufferManager) ||
bufferManagerType == BufferManagerType::HAL) {
halBufManagedStreamIds->insert(halStream.id);
}
}
return ndk::ScopedAStatus::ok();
}
@@ -2621,16 +2633,16 @@ void CameraAidlTest::configureSingleStream(
ASSERT_TRUE(ret.isOk());
ASSERT_NE(*session, nullptr);
*useHalBufManager = false;
bool sessionHalBufferManager = false;
BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
status = find_camera_metadata_ro_entry(
staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
if ((0 == status) && (entry.count == 1)) {
*useHalBufManager = (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
sessionHalBufferManager =
(entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
bufferManagerType = BufferManagerType::HAL;
} else if (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
bufferManagerType = BufferManagerType::SESSION;
}
}
outputPreviewStreams.clear();
@@ -2689,7 +2701,8 @@ void CameraAidlTest::configureSingleStream(
ASSERT_EQ(supported, true);
std::vector<HalStream> halConfigs;
ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager,
std::set<int32_t> halBufManagedStreamIds;
ret = configureStreams(*session, config, bufferManagerType, &halBufManagedStreamIds,
&halConfigs);
ALOGI("configureStreams returns status: %d:%d", ret.getExceptionCode(),
ret.getServiceSpecificError());
@@ -2697,6 +2710,7 @@ void CameraAidlTest::configureSingleStream(
ASSERT_EQ(1u, halConfigs.size());
halStreams->clear();
halStreams->push_back(halConfigs[0]);
*useHalBufManager = halBufManagedStreamIds.size() != 0;
if (*useHalBufManager) {
std::vector<Stream> ss(1);
std::vector<HalStream> hs(1);
@@ -2823,6 +2837,7 @@ void CameraAidlTest::processPreviewStabilizationCaptureRequestInternal(
overrideRotateAndCrop(&request.settings);
request.outputBuffers = std::vector<StreamBuffer>(1);
StreamBuffer& outputBuffer = request.outputBuffers[0];
if (useHalBufManager) {
outputBuffer = {halStreams[0].id,
/*bufferId*/ 0, NativeHandle(), BufferStatus::OK,
@@ -2941,14 +2956,14 @@ void CameraAidlTest::configurePreviewStreams(
const AvailableStream* previewThreshold, const std::unordered_set<std::string>& physicalIds,
std::shared_ptr<ICameraDeviceSession>* session, Stream* previewStream,
std::vector<HalStream>* halStreams, bool* supportsPartialResults,
int32_t* partialResultCount, bool* useHalBufManager, std::shared_ptr<DeviceCb>* cb,
int32_t streamConfigCounter, bool allowUnsupport) {
int32_t* partialResultCount, std::set<int32_t>* halBufManagedStreamIds,
std::shared_ptr<DeviceCb>* cb, int32_t streamConfigCounter, bool allowUnsupport) {
ASSERT_NE(nullptr, session);
ASSERT_NE(nullptr, halStreams);
ASSERT_NE(nullptr, previewStream);
ASSERT_NE(nullptr, supportsPartialResults);
ASSERT_NE(nullptr, partialResultCount);
ASSERT_NE(nullptr, useHalBufManager);
ASSERT_NE(nullptr, halBufManagedStreamIds);
ASSERT_NE(nullptr, cb);
ASSERT_FALSE(physicalIds.empty());
@@ -2985,16 +3000,16 @@ void CameraAidlTest::configurePreviewStreams(
ASSERT_TRUE(ret.isOk());
ASSERT_NE(*session, nullptr);
*useHalBufManager = false;
bool sessionHalBufferManager = false;
BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
status = find_camera_metadata_ro_entry(
staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
if ((0 == status) && (entry.count == 1)) {
*useHalBufManager = (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
sessionHalBufferManager =
(entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
bufferManagerType = BufferManagerType::HAL;
} else if (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
bufferManagerType = BufferManagerType::SESSION;
}
}
outputPreviewStreams.clear();
@@ -3049,18 +3064,21 @@ void CameraAidlTest::configurePreviewStreams(
config.streamConfigCounter = streamConfigCounter;
std::vector<HalStream> halConfigs;
ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager,
ret = configureStreams(*session, config, bufferManagerType, halBufManagedStreamIds,
&halConfigs);
ASSERT_TRUE(ret.isOk());
ASSERT_EQ(physicalIds.size(), halConfigs.size());
*halStreams = halConfigs;
if (*useHalBufManager) {
std::vector<Stream> ss(physicalIds.size());
std::vector<HalStream> hs(physicalIds.size());
if (halBufManagedStreamIds->size() != 0) {
// Only include the streams that are HAL buffer managed
std::vector<Stream> ss;
std::vector<HalStream> hs;
for (size_t i = 0; i < physicalIds.size(); i++) {
ss[i] = streams[i];
hs[i] = halConfigs[i];
if (contains(*halBufManagedStreamIds, halConfigs[i].id)) {
ss.emplace_back(streams[i]);
hs.emplace_back(halConfigs[i]);
}
}
(*cb)->setCurrentStreamConfig(ss, hs);
}
@@ -3078,22 +3096,20 @@ void CameraAidlTest::verifyBuffersReturned(const std::shared_ptr<ICameraDeviceSe
cb->waitForBuffersReturned();
}
void CameraAidlTest::configureStreams(const std::string& name,
const std::shared_ptr<ICameraProvider>& provider,
PixelFormat format,
std::shared_ptr<ICameraDeviceSession>* session,
Stream* previewStream, std::vector<HalStream>* halStreams,
bool* supportsPartialResults, int32_t* partialResultCount,
bool* useHalBufManager, std::shared_ptr<DeviceCb>* outCb,
uint32_t streamConfigCounter, bool maxResolution,
RequestAvailableDynamicRangeProfilesMap dynamicRangeProf,
RequestAvailableColorSpaceProfilesMap colorSpaceProf) {
void CameraAidlTest::configureStreams(
const std::string& name, const std::shared_ptr<ICameraProvider>& provider,
PixelFormat format, std::shared_ptr<ICameraDeviceSession>* session, Stream* previewStream,
std::vector<HalStream>* halStreams, bool* supportsPartialResults,
int32_t* partialResultCount, std::set<int32_t>* halBufManagedStreamIds,
std::shared_ptr<DeviceCb>* outCb, uint32_t streamConfigCounter, bool maxResolution,
RequestAvailableDynamicRangeProfilesMap dynamicRangeProf,
RequestAvailableColorSpaceProfilesMap colorSpaceProf) {
ASSERT_NE(nullptr, session);
ASSERT_NE(nullptr, halStreams);
ASSERT_NE(nullptr, previewStream);
ASSERT_NE(nullptr, supportsPartialResults);
ASSERT_NE(nullptr, partialResultCount);
ASSERT_NE(nullptr, useHalBufManager);
ASSERT_NE(nullptr, halBufManagedStreamIds);
ASSERT_NE(nullptr, outCb);
ALOGI("configureStreams: Testing camera device %s", name.c_str());
@@ -3130,16 +3146,16 @@ void CameraAidlTest::configureStreams(const std::string& name,
ASSERT_TRUE(ret.isOk());
ASSERT_NE(*session, nullptr);
*useHalBufManager = false;
bool sessionHalBufferManager = false;
BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
status = find_camera_metadata_ro_entry(
staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
if ((0 == status) && (entry.count == 1)) {
*useHalBufManager = (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
sessionHalBufferManager =
(entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
bufferManagerType = BufferManagerType::HAL;
} else if (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
bufferManagerType = BufferManagerType::SESSION;
}
}
outputStreams.clear();
@@ -3193,11 +3209,11 @@ void CameraAidlTest::configureStreams(const std::string& name,
ASSERT_TRUE(ret.isOk());
ASSERT_EQ(supported, true);
ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager, halStreams);
ret = configureStreams(*session, config, bufferManagerType, halBufManagedStreamIds, halStreams);
ASSERT_TRUE(ret.isOk());
if (*useHalBufManager) {
if (halBufManagedStreamIds->size() != 0) {
std::vector<Stream> ss(1);
std::vector<HalStream> hs(1);
ss[0] = streams[0];
@@ -3542,7 +3558,7 @@ void CameraAidlTest::configureOfflineStillStream(
const AvailableStream* threshold, std::shared_ptr<ICameraDeviceSession>* session,
Stream* stream, std::vector<HalStream>* halStreams, bool* supportsPartialResults,
int32_t* partialResultCount, std::shared_ptr<DeviceCb>* outCb, int32_t* jpegBufferSize,
bool* useHalBufManager) {
std::set<int32_t>* halBufManagedStreamIds) {
ASSERT_NE(nullptr, session);
ASSERT_NE(nullptr, halStreams);
ASSERT_NE(nullptr, stream);
@@ -3550,7 +3566,7 @@ void CameraAidlTest::configureOfflineStillStream(
ASSERT_NE(nullptr, partialResultCount);
ASSERT_NE(nullptr, outCb);
ASSERT_NE(nullptr, jpegBufferSize);
ASSERT_NE(nullptr, useHalBufManager);
ASSERT_NE(nullptr, halBufManagedStreamIds);
std::vector<AvailableStream> outputStreams;
std::shared_ptr<ICameraDevice> cameraDevice;
@@ -3577,16 +3593,16 @@ void CameraAidlTest::configureOfflineStillStream(
*supportsPartialResults = (*partialResultCount > 1);
}
*useHalBufManager = false;
bool sessionHalBufferManager = false;
BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
status = find_camera_metadata_ro_entry(
staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
if ((0 == status) && (entry.count == 1)) {
*useHalBufManager = (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
sessionHalBufferManager =
(entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
bufferManagerType = BufferManagerType::HAL;
} else if (entry.data.u8[0] ==
ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
bufferManagerType = BufferManagerType::SESSION;
}
}
auto st = getJpegBufferSize(staticMeta, jpegBufferSize);
@@ -3639,11 +3655,11 @@ void CameraAidlTest::configureOfflineStillStream(
StreamConfiguration config = {streams, StreamConfigurationMode::NORMAL_MODE, CameraMetadata()};
ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager, halStreams);
ret = configureStreams(*session, config, bufferManagerType, halBufManagedStreamIds, halStreams);
ASSERT_TRUE(ret.isOk());
if (*useHalBufManager) {
if (halBufManagedStreamIds->size() != 0) {
(*outCb)->setCurrentStreamConfig(streams, *halStreams);
}
@@ -3746,7 +3762,7 @@ void CameraAidlTest::processColorSpaceRequest(
std::vector<HalStream> halStreams;
bool supportsPartialResults = false;
bool useHalBufManager = false;
std::set<int32_t> halBufManagedStreamIds;
int32_t partialResultCount = 0;
Stream previewStream;
std::shared_ptr<DeviceCb> cb;
@@ -3755,7 +3771,7 @@ void CameraAidlTest::processColorSpaceRequest(
GRALLOC1_CONSUMER_USAGE_HWCOMPOSER);
configureStreams(name, mProvider, PixelFormat::IMPLEMENTATION_DEFINED, &mSession,
&previewStream, &halStreams, &supportsPartialResults, &partialResultCount,
&useHalBufManager, &cb, 0,
&halBufManagedStreamIds, &cb, 0,
/*maxResolution*/ false, dynamicRangeProfile, colorSpace);
ASSERT_NE(mSession, nullptr);
@@ -3794,7 +3810,7 @@ void CameraAidlTest::processColorSpaceRequest(
auto bufferId = requestId + 1; // Buffer id value 0 is not valid
for (const auto& halStream : halStreams) {
buffer_handle_t buffer_handle;
if (useHalBufManager) {
if (contains(halBufManagedStreamIds, halStream.id)) {
outputBuffers[k] = {halStream.id, 0,
NativeHandle(), BufferStatus::OK,
NativeHandle(), NativeHandle()};
@@ -3861,10 +3877,12 @@ void CameraAidlTest::processColorSpaceRequest(
}
}
if (useHalBufManager) {
std::vector<int32_t> streamIds(halStreams.size());
if (halBufManagedStreamIds.size() != 0) {
std::vector<int32_t> streamIds;
for (size_t i = 0; i < streamIds.size(); i++) {
streamIds[i] = halStreams[i].id;
if (contains(halBufManagedStreamIds, halStreams[i].id)) {
streamIds.emplace_back(halStreams[i].id);
}
}
mSession->signalStreamFlush(streamIds, /*streamConfigCounter*/ 0);
cb->waitForBuffersReturned();

19
camera/provider/aidl/vts/camera_aidl_test.h
View File

@@ -99,6 +99,11 @@ using ::ndk::ScopedAStatus;
class DeviceCb; // Forward declare to break circular header dependency
template <typename T>
bool contains(const std::set<T>& container, T value) {
return container.find(value) != container.end();
}
class CameraAidlTest : public ::testing::TestWithParam<std::string> {
public:
enum SystemCameraKind {
@@ -121,6 +126,8 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> {
HIDDEN_SECURE_CAMERA
};
enum BufferManagerType { FRAMEWORK = 0, HAL, SESSION };
struct AvailableStream {
int32_t width;
int32_t height;
@@ -200,11 +207,12 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> {
std::shared_ptr<ICameraDeviceSession>* session /*out*/, Stream* stream /*out*/,
std::vector<HalStream>* halStreams, bool* supportsPartialResults /*out*/,
int32_t* partialResultCount /*out*/, std::shared_ptr<DeviceCb>* outCb /*out*/,
int32_t* jpegBufferSize /*out*/, bool* useHalBufManager /*out*/);
int32_t* jpegBufferSize /*out*/, std::set<int32_t>* halBufManagedStreamIds /*out*/);
ndk::ScopedAStatus configureStreams(std::shared_ptr<ICameraDeviceSession>& session,
const StreamConfiguration& config,
bool sessionHalBufferManager, bool* useHalBufManager,
BufferManagerType bufferManagerType,
std::set<int32_t>* halBufManagedStreamIds,
std::vector<HalStream>* halStreams);
void configureStreams(
@@ -212,8 +220,9 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> {
PixelFormat format, std::shared_ptr<ICameraDeviceSession>* session /*out*/,
Stream* previewStream /*out*/, std::vector<HalStream>* halStreams /*out*/,
bool* supportsPartialResults /*out*/, int32_t* partialResultCount /*out*/,
bool* useHalBufManager /*out*/, std::shared_ptr<DeviceCb>* outCb /*out*/,
uint32_t streamConfigCounter, bool maxResolution,
std::set<int32_t>* halBufManagedStreamIds /*out*/,
std::shared_ptr<DeviceCb>* outCb /*out*/, uint32_t streamConfigCounter,
bool maxResolution,
RequestAvailableDynamicRangeProfilesMap dynamicRangeProf =
RequestAvailableDynamicRangeProfilesMap::
ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
@@ -227,7 +236,7 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> {
const std::unordered_set<std::string>& physicalIds,
std::shared_ptr<ICameraDeviceSession>* session /*out*/, Stream* previewStream /*out*/,
std::vector<HalStream>* halStreams /*out*/, bool* supportsPartialResults /*out*/,
int32_t* partialResultCount /*out*/, bool* useHalBufManager /*out*/,
int32_t* partialResultCount /*out*/, std::set<int32_t>* halBufManagedStreamIds /*out*/,
std::shared_ptr<DeviceCb>* cb /*out*/, int32_t streamConfigCounter = 0,
bool allowUnsupport = false);