| // Copyright 2017 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "camera3_test/camera3_preview_fixture.h" |
| |
| #include <unistd.h> |
| |
| #include <base/bind.h> |
| #include <base/command_line.h> |
| #include <base/strings/string_number_conversions.h> |
| |
| namespace camera3_test { |
| |
| void Camera3PreviewFixture::SetUp() { |
| ASSERT_EQ(0, cam_service_.Initialize( |
| Camera3Service::ProcessStillCaptureResultCallback(), |
| Camera3Service::ProcessRecordingResultCallback())) |
| << "Failed to initialize camera service"; |
| } |
| |
| void Camera3PreviewFixture::TearDown() { |
| cam_service_.Destroy(); |
| } |
| |
| // Test parameters: |
| // - Camera ID |
| class Camera3SinglePreviewTest : public Camera3PreviewFixture, |
| public ::testing::WithParamInterface<int32_t> { |
| public: |
| const uint32_t kNumPreviewFrames = 10; |
| const uint32_t kTimeoutMsPerFrame = 1000; |
| |
| Camera3SinglePreviewTest() |
| : Camera3PreviewFixture(std::vector<int>(1, GetParam())), |
| cam_id_(GetParam()) {} |
| |
| protected: |
| int cam_id_; |
| }; |
| |
| TEST_P(Camera3SinglePreviewTest, Camera3BasicPreviewTest) { |
| auto resolutions = |
| cam_service_.GetStaticInfo(cam_id_)->GetSortedOutputResolutions( |
| HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED); |
| for (const auto& resolution : resolutions) { |
| ResolutionInfo jpeg_resolution(0, 0), recording_resolution(0, 0); |
| ASSERT_EQ(0, cam_service_.StartPreview(cam_id_, resolution, jpeg_resolution, |
| recording_resolution)) |
| << "Starting preview fails"; |
| ASSERT_EQ(0, cam_service_.WaitForPreviewFrames(cam_id_, kNumPreviewFrames, |
| kTimeoutMsPerFrame)); |
| cam_service_.StopPreview(cam_id_); |
| } |
| } |
| |
| // Test parameters: |
| // - Camera ID |
| class Camera3FaceDetectionTest : public Camera3PreviewFixture, |
| public ::testing::WithParamInterface<int32_t> { |
| public: |
| const uint32_t kNumPreviewFrames = 20; |
| const uint32_t kTimeoutMsPerFrame = 1000; |
| Camera3FaceDetectionTest() |
| : Camera3PreviewFixture(std::vector<int>(1, GetParam())), |
| cam_id_(GetParam()), |
| expected_num_faces_(GetCommandLineFaceDetectNumber()) {} |
| |
| protected: |
| void SetUp() override; |
| |
| void ProcessPreviewResult(int cam_id, |
| uint32_t frame_number, |
| ScopedCameraMetadata metadata); |
| |
| int GetCommandLineFaceDetectNumber() { |
| std::string switch_value = |
| base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII( |
| "expected_num_faces"); |
| if (switch_value == "") { |
| return -1; |
| } |
| int value; |
| if (!base::StringToInt(switch_value, &value)) { |
| LOG(ERROR) << "Failed to convert " << switch_value << " to int"; |
| return -1; |
| } |
| if (value < 0) { |
| return -1; |
| } |
| return value; |
| } |
| |
| void CheckNumOfFaces(int num_faces); |
| |
| int cam_id_; |
| int expected_num_faces_; |
| |
| private: |
| ScopedCameraMetadata result_metadata_; |
| }; |
| |
| void Camera3FaceDetectionTest::SetUp() { |
| ASSERT_EQ(0, cam_service_.Initialize( |
| Camera3Service::ProcessStillCaptureResultCallback(), |
| Camera3Service::ProcessRecordingResultCallback(), |
| base::Bind(&Camera3FaceDetectionTest::ProcessPreviewResult, |
| base::Unretained(this)))) |
| << "Failed to initialize camera service"; |
| } |
| |
| void Camera3FaceDetectionTest::ProcessPreviewResult( |
| int cam_id, uint32_t /*frame_number*/, ScopedCameraMetadata metadata) { |
| VLOGF_ENTER(); |
| result_metadata_ = std::move(metadata); |
| } |
| |
| void Camera3FaceDetectionTest::CheckNumOfFaces(int num_faces) { |
| ASSERT_NE(nullptr, result_metadata_.get()) |
| << "Result metadata is unavailable"; |
| camera_metadata_ro_entry_t entry; |
| int result = find_camera_metadata_ro_entry( |
| result_metadata_.get(), ANDROID_STATISTICS_FACE_RECTANGLES, &entry); |
| // Accept no rectangles. |
| if (num_faces == 0 && result != 0) { |
| return; |
| } |
| ASSERT_EQ(0, result) |
| << "Metadata key ANDROID_STATISTICS_FACE_RECTANGLES not found"; |
| EXPECT_EQ(num_faces * 4, entry.count) |
| << "Expect face rectangles size " << num_faces * 4 << " but detected " |
| << entry.count; |
| ASSERT_EQ( |
| 0, find_camera_metadata_ro_entry(result_metadata_.get(), |
| ANDROID_STATISTICS_FACE_SCORES, &entry)) |
| << "Metadata key ANDROID_STATISTICS_FACE_SCORES not found"; |
| EXPECT_EQ(num_faces, entry.count) |
| << "Expect " << num_faces << " faces, but detected " << entry.count |
| << " faces"; |
| result_metadata_.reset(); |
| } |
| |
| TEST_P(Camera3FaceDetectionTest, Detection) { |
| // Run only if --expected_num_faces argument presented. |
| if (expected_num_faces_ < 0) { |
| GTEST_SKIP(); |
| } |
| |
| auto IsAFSupported = [this]() { |
| std::vector<uint8_t> available_af_modes; |
| cam_service_.GetStaticInfo(cam_id_)->GetAvailableAFModes( |
| &available_af_modes); |
| uint8_t af_modes[] = {ANDROID_CONTROL_AF_MODE_AUTO, |
| ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE, |
| ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, |
| ANDROID_CONTROL_AF_MODE_MACRO}; |
| for (const auto& it : af_modes) { |
| if (std::find(available_af_modes.begin(), available_af_modes.end(), it) != |
| available_af_modes.end()) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| ASSERT_TRUE(cam_service_.GetStaticInfo(cam_id_)->IsKeyAvailable( |
| ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES)) |
| << "NO ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES key in static " |
| "info"; |
| std::set<uint8_t> face_detect_modes; |
| ASSERT_EQ(0, cam_service_.GetStaticInfo(cam_id_)->GetAvailableFaceDetectModes( |
| &face_detect_modes) != 0) |
| << "Failed to get face detect modes"; |
| ASSERT_NE(face_detect_modes.find(ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE), |
| face_detect_modes.end()) |
| << "Can't find ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE"; |
| |
| auto resolution = |
| cam_service_.GetStaticInfo(cam_id_) |
| ->GetSortedOutputResolutions(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) |
| .back(); |
| ResolutionInfo jpeg_resolution(0, 0), recording_resolution(0, 0); |
| ASSERT_EQ(0, cam_service_.StartPreview(cam_id_, resolution, jpeg_resolution, |
| recording_resolution)) |
| << "Starting preview fails"; |
| |
| // Trigger an auto focus run, and wait for AF locked. |
| if (IsAFSupported()) { |
| cam_service_.StartAutoFocus(cam_id_); |
| ASSERT_EQ(0, cam_service_.WaitForAutoFocusDone(cam_id_)) |
| << "Wait for auto focus done timed out"; |
| } |
| // Wait for AWB converged, then lock it. |
| ASSERT_EQ(0, cam_service_.WaitForAWBConvergedAndLock(cam_id_)) |
| << "Wait for AWB converged timed out"; |
| |
| // Trigger an AE precapture metering sequence and wait for AE converged. |
| cam_service_.StartAEPrecapture(cam_id_); |
| ASSERT_EQ(0, cam_service_.WaitForAEStable(cam_id_)) |
| << "Wait for AE stable timed out"; |
| |
| // Check there is no face detected before enabling face detection |
| ASSERT_EQ(0, cam_service_.WaitForPreviewFrames(cam_id_, kNumPreviewFrames, |
| kTimeoutMsPerFrame)); |
| CheckNumOfFaces(0); |
| |
| cam_service_.StartFaceDetection(cam_id_); |
| ASSERT_EQ(0, cam_service_.WaitForPreviewFrames(cam_id_, kNumPreviewFrames, |
| kTimeoutMsPerFrame)); |
| CheckNumOfFaces(expected_num_faces_); |
| |
| // Check no face detected after stop face detection |
| cam_service_.StopFaceDetection(cam_id_); |
| ASSERT_EQ(0, cam_service_.WaitForPreviewFrames(cam_id_, kNumPreviewFrames, |
| kTimeoutMsPerFrame)); |
| CheckNumOfFaces(0); |
| |
| cam_service_.StopPreview(cam_id_); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| Camera3PreviewTest, |
| Camera3SinglePreviewTest, |
| ::testing::ValuesIn(Camera3Module().GetTestCameraIds())); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| Camera3PreviewTest, |
| Camera3FaceDetectionTest, |
| ::testing::ValuesIn(Camera3Module().GetTestCameraIds())); |
| |
| } // namespace camera3_test |
