Snap for 5375030 from e3c3d56907af23d92e74a355b50a2f97c6938aa7 to pi-qpr3-b-release (6ae4f1e7) · Commits · e / os / android_hardware_interfaces

camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp

+109 −20

Original line number	Original line	Diff line number	Diff line
	@@ -671,6 +671,7 @@ public:
	HalStreamConfiguration halStreamConfig /out*/,		HalStreamConfiguration halStreamConfig /out*/,
	bool supportsPartialResults /out*/,		bool supportsPartialResults /out*/,
	uint32_t partialResultCount /out*/);		uint32_t partialResultCount /out*/);
			bool isDepthOnly(camera_metadata_t* staticMeta);
	static Status getAvailableOutputStreams(camera_metadata_t *staticMeta,		static Status getAvailableOutputStreams(camera_metadata_t *staticMeta,
	std::vector<AvailableStream> &outputStreams,		std::vector<AvailableStream> &outputStreams,
	const AvailableStream *threshold = nullptr);		const AvailableStream *threshold = nullptr);
	@@ -682,6 +683,10 @@ public:
	std::unordered_set<std::string> physicalIds/out*/);		std::unordered_set<std::string> physicalIds/out*/);
	static Status getSupportedKeys(camera_metadata_t *staticMeta,		static Status getSupportedKeys(camera_metadata_t *staticMeta,
	uint32_t tagId, std::unordered_set<int32_t> requestIDs/out*/);		uint32_t tagId, std::unordered_set<int32_t> requestIDs/out*/);
			static void fillOutputStreams(camera_metadata_ro_entry_t* entry,
			std::vector<AvailableStream>& outputStreams,
			const AvailableStream *threshold = nullptr,
			const int32_t availableConfigOutputTag = 0u);
	static void constructFilteredSettings(const sp<ICameraDeviceSession>& session,		static void constructFilteredSettings(const sp<ICameraDeviceSession>& session,
	const std::unordered_set<int32_t>& availableKeys, RequestTemplate reqTemplate,		const std::unordered_set<int32_t>& availableKeys, RequestTemplate reqTemplate,
	android::hardware::camera::common::V1_0::helper::CameraMetadata* defaultSettings/out/,		android::hardware::camera::common::V1_0::helper::CameraMetadata* defaultSettings/out/,
	@@ -2521,14 +2526,24 @@ TEST_F(CameraHidlTest, configureStreamsAvailableOutputs) {
	int32_t streamId = 0;		int32_t streamId = 0;
	for (auto& it : outputStreams) {		for (auto& it : outputStreams) {
	V3_2::Stream stream3_2;		V3_2::Stream stream3_2;
	bool isJpeg = static_cast<PixelFormat>(it.format) == PixelFormat::BLOB;		V3_2::DataspaceFlags dataspaceFlag = 0;
			switch (static_cast<PixelFormat>(it.format)) {
			case PixelFormat::BLOB:
			dataspaceFlag = static_cast<V3_2::DataspaceFlags>(Dataspace::V0_JFIF);
			break;
			case PixelFormat::Y16:
			dataspaceFlag = static_cast<V3_2::DataspaceFlags>(Dataspace::DEPTH);
			break;
			default:
			dataspaceFlag = static_cast<V3_2::DataspaceFlags>(Dataspace::UNKNOWN);
			}
	stream3_2 = {streamId,		stream3_2 = {streamId,
	StreamType::OUTPUT,		StreamType::OUTPUT,
	static_cast<uint32_t>(it.width),		static_cast<uint32_t>(it.width),
	static_cast<uint32_t>(it.height),		static_cast<uint32_t>(it.height),
	static_cast<PixelFormat>(it.format),		static_cast<PixelFormat>(it.format),
	GRALLOC1_CONSUMER_USAGE_HWCOMPOSER,		GRALLOC1_CONSUMER_USAGE_HWCOMPOSER,
	(isJpeg) ? static_cast<V3_2::DataspaceFlags>(Dataspace::V0_JFIF) : 0,		dataspaceFlag,
	StreamRotation::ROTATION_0};		StreamRotation::ROTATION_0};
	::android::hardware::hidl_vec<V3_2::Stream> streams3_2 = {stream3_2};		::android::hardware::hidl_vec<V3_2::Stream> streams3_2 = {stream3_2};
	::android::hardware::camera::device::V3_4::StreamConfiguration config3_4;		::android::hardware::camera::device::V3_4::StreamConfiguration config3_4;
	@@ -2962,6 +2977,14 @@ TEST_F(CameraHidlTest, configureStreamsPreviewStillOutputs) {
	openEmptyDeviceSession(name, mProvider, &session /out/, &staticMeta /out/);		openEmptyDeviceSession(name, mProvider, &session /out/, &staticMeta /out/);
	castSession(session, deviceVersion, &session3_3, &session3_4);		castSession(session, deviceVersion, &session3_3, &session3_4);

			// Check if camera support depth only
			if (isDepthOnly(staticMeta)) {
			free_camera_metadata(staticMeta);
			ret = session->close();
			ASSERT_TRUE(ret.isOk());
			continue;
			}

	outputBlobStreams.clear();		outputBlobStreams.clear();
	ASSERT_EQ(Status::OK,		ASSERT_EQ(Status::OK,
	getAvailableOutputStreams(staticMeta, outputBlobStreams,		getAvailableOutputStreams(staticMeta, outputBlobStreams,
	@@ -3230,6 +3253,14 @@ TEST_F(CameraHidlTest, configureStreamsVideoStillOutputs) {
	openEmptyDeviceSession(name, mProvider, &session /out/, &staticMeta /out/);		openEmptyDeviceSession(name, mProvider, &session /out/, &staticMeta /out/);
	castSession(session, deviceVersion, &session3_3, &session3_4);		castSession(session, deviceVersion, &session3_3, &session3_4);

			// Check if camera support depth only
			if (isDepthOnly(staticMeta)) {
			free_camera_metadata(staticMeta);
			ret = session->close();
			ASSERT_TRUE(ret.isOk());
			continue;
			}

	outputBlobStreams.clear();		outputBlobStreams.clear();
	ASSERT_EQ(Status::OK,		ASSERT_EQ(Status::OK,
	getAvailableOutputStreams(staticMeta, outputBlobStreams,		getAvailableOutputStreams(staticMeta, outputBlobStreams,
	@@ -4135,38 +4166,56 @@ TEST_F(CameraHidlTest, flushEmpty) {
	Status CameraHidlTest::getAvailableOutputStreams(camera_metadata_t *staticMeta,		Status CameraHidlTest::getAvailableOutputStreams(camera_metadata_t *staticMeta,
	std::vector<AvailableStream> &outputStreams,		std::vector<AvailableStream> &outputStreams,
	const AvailableStream *threshold) {		const AvailableStream *threshold) {
			AvailableStream depthPreviewThreshold = {kMaxPreviewWidth, kMaxPreviewHeight,
			static_cast<int32_t>(PixelFormat::Y16)};
	if (nullptr == staticMeta) {		if (nullptr == staticMeta) {
	return Status::ILLEGAL_ARGUMENT;		return Status::ILLEGAL_ARGUMENT;
	}		}

	camera_metadata_ro_entry entry;		camera_metadata_ro_entry scalarEntry;
	int rc = find_camera_metadata_ro_entry(staticMeta,		camera_metadata_ro_entry depthEntry;
	ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &entry);		int foundScalar = find_camera_metadata_ro_entry(staticMeta,
	if ((0 != rc) \|\| (0 != (entry.count % 4))) {		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &scalarEntry);
			int foundDepth = find_camera_metadata_ro_entry(staticMeta,
			ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, &depthEntry);
			if ((0 != foundScalar \|\| (0 != (scalarEntry.count % 4))) &&
			(0 != foundDepth \|\| (0 != (depthEntry.count % 4)))) {
	return Status::ILLEGAL_ARGUMENT;		return Status::ILLEGAL_ARGUMENT;
	}		}

	for (size_t i = 0; i < entry.count; i+=4) {		if(foundScalar == 0 && (0 == (scalarEntry.count % 4))) {
	if (ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT ==		fillOutputStreams(&scalarEntry, outputStreams, threshold,
	entry.data.i32[i + 3]) {		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT);
			}

			if(foundDepth == 0 && (0 == (depthEntry.count % 4))) {
			fillOutputStreams(&depthEntry, outputStreams, &depthPreviewThreshold,
			ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT);
			}

			return Status::OK;
			}

			void CameraHidlTest::fillOutputStreams(camera_metadata_ro_entry_t* entry,
			std::vector<AvailableStream>& outputStreams, const AvailableStream* threshold,
			const int32_t availableConfigOutputTag) {
			for (size_t i = 0; i < entry->count; i+=4) {
			if (availableConfigOutputTag == entry->data.i32[i + 3]) {
	if(nullptr == threshold) {		if(nullptr == threshold) {
	AvailableStream s = {entry.data.i32[i+1],		AvailableStream s = {entry->data.i32[i+1],
	entry.data.i32[i+2], entry.data.i32[i]};		entry->data.i32[i+2], entry->data.i32[i]};
	outputStreams.push_back(s);		outputStreams.push_back(s);
	} else {		} else {
	if ((threshold->format == entry.data.i32[i]) &&		if ((threshold->format == entry->data.i32[i]) &&
	(threshold->width >= entry.data.i32[i+1]) &&		(threshold->width >= entry->data.i32[i+1]) &&
	(threshold->height >= entry.data.i32[i+2])) {		(threshold->height >= entry->data.i32[i+2])) {
	AvailableStream s = {entry.data.i32[i+1],		AvailableStream s = {entry->data.i32[i+1],
	entry.data.i32[i+2], threshold->format};		entry->data.i32[i+2], threshold->format};
	outputStreams.push_back(s);		outputStreams.push_back(s);
	}		}
	}		}
	}		}

	}		}

	return Status::OK;
	}		}

	// Get max jpeg buffer size in android.jpeg.maxSize		// Get max jpeg buffer size in android.jpeg.maxSize
	@@ -4563,6 +4612,37 @@ void CameraHidlTest::configurePreviewStreams3_4(const std::string &name, int32_t
	ASSERT_TRUE(ret.isOk());		ASSERT_TRUE(ret.isOk());
	}		}

			bool CameraHidlTest::isDepthOnly(camera_metadata_t* staticMeta) {
			camera_metadata_ro_entry scalarEntry;
			camera_metadata_ro_entry depthEntry;

			int rc = find_camera_metadata_ro_entry(
			staticMeta, ANDROID_REQUEST_AVAILABLE_CAPABILITIES, &scalarEntry);
			if (rc == 0) {
			for (uint32_t i = 0; i < scalarEntry.count; i++) {
			if (scalarEntry.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
			return false;
			}
			}
			}

			for (uint32_t i = 0; i < scalarEntry.count; i++) {
			if (scalarEntry.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT) {

			rc = find_camera_metadata_ro_entry(
			staticMeta, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, &depthEntry);
			size_t i = 0;
			if (rc == 0 && depthEntry.data.i32[i] == static_cast<int32_t>(PixelFormat::Y16)) {
			// only Depth16 format is supported now
			return true;
			}
			break;
			}
			}

			return false;
			}

	// Open a device session and configure a preview stream.		// Open a device session and configure a preview stream.
	void CameraHidlTest::configurePreviewStream(const std::string &name, int32_t deviceVersion,		void CameraHidlTest::configurePreviewStream(const std::string &name, int32_t deviceVersion,
	sp<ICameraProvider> provider,		sp<ICameraProvider> provider,
	@@ -4638,11 +4718,20 @@ void CameraHidlTest::configurePreviewStream(const std::string &name, int32_t dev
	ASSERT_EQ(Status::OK, rc);		ASSERT_EQ(Status::OK, rc);
	ASSERT_FALSE(outputPreviewStreams.empty());		ASSERT_FALSE(outputPreviewStreams.empty());

			V3_2::DataspaceFlags dataspaceFlag = 0;
			switch (static_cast<PixelFormat>(outputPreviewStreams[0].format)) {
			case PixelFormat::Y16:
			dataspaceFlag = static_cast<V3_2::DataspaceFlags>(Dataspace::DEPTH);
			break;
			default:
			dataspaceFlag = static_cast<V3_2::DataspaceFlags>(Dataspace::UNKNOWN);
			}

	V3_2::Stream stream3_2 = {0, StreamType::OUTPUT,		V3_2::Stream stream3_2 = {0, StreamType::OUTPUT,
	static_cast<uint32_t> (outputPreviewStreams[0].width),		static_cast<uint32_t> (outputPreviewStreams[0].width),
	static_cast<uint32_t> (outputPreviewStreams[0].height),		static_cast<uint32_t> (outputPreviewStreams[0].height),
	static_cast<PixelFormat> (outputPreviewStreams[0].format),		static_cast<PixelFormat> (outputPreviewStreams[0].format),
	GRALLOC1_CONSUMER_USAGE_HWCOMPOSER, 0, StreamRotation::ROTATION_0};		GRALLOC1_CONSUMER_USAGE_HWCOMPOSER, dataspaceFlag, StreamRotation::ROTATION_0};
	::android::hardware::hidl_vec<V3_2::Stream> streams3_2 = {stream3_2};		::android::hardware::hidl_vec<V3_2::Stream> streams3_2 = {stream3_2};
	::android::hardware::camera::device::V3_2::StreamConfiguration config3_2;		::android::hardware::camera::device::V3_2::StreamConfiguration config3_2;
	::android::hardware::camera::device::V3_4::StreamConfiguration config3_4;		::android::hardware::camera::device::V3_4::StreamConfiguration config3_4;

radio/1.0/vts/functional/sap_hidl_hal_api.cpp

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,10 @@ TEST_F(SapHidlTest, connectReq) {
	sap->connectReq(token, maxMsgSize);		sap->connectReq(token, maxMsgSize);
	EXPECT_EQ(std::cv_status::no_timeout, wait());		EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(sapCb->sapResponseToken, token);		EXPECT_EQ(sapCb->sapResponseToken, token);

			// Modem side need time for connect to finish. Adding a waiting time to prevent
			// disconnect being requested right after connect request.
			sleep(1);
	}		}

	/*		/*