| // Copyright 2018 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_recording_fixture.h" |
| |
| namespace camera3_test { |
| |
| void Camera3RecordingFixture::SetUp() { |
| ASSERT_EQ(0, cam_service_.Initialize( |
| Camera3Service::ProcessStillCaptureResultCallback(), |
| base::Bind(&Camera3RecordingFixture::ProcessRecordingResult, |
| base::Unretained(this)))) |
| << "Failed to initialize camera service"; |
| } |
| |
| void Camera3RecordingFixture::ProcessRecordingResult( |
| int cam_id, uint32_t /*frame_number*/, ScopedCameraMetadata metadata) { |
| VLOGF_ENTER(); |
| camera_metadata_ro_entry_t entry; |
| ASSERT_EQ(0, find_camera_metadata_ro_entry(metadata.get(), |
| ANDROID_SENSOR_TIMESTAMP, &entry)) |
| << "Failed to get sensor timestamp in recording result"; |
| sensor_timestamp_map_[cam_id].push_back(entry.data.i64[0]); |
| } |
| |
| // Test parameters: |
| // - Camera ID, width, height, frame rate |
| class Camera3BasicRecordingTest |
| : public Camera3RecordingFixture, |
| public ::testing::WithParamInterface< |
| std::tuple<int32_t, int32_t, int32_t, float, bool>> { |
| public: |
| const int32_t kRecordingDurationMs = 3000; |
| // Margin of frame duration in percetange. The value is adopted from |
| // android.hardware.camera2.cts.RecordingTest#testBasicRecording. |
| const float kFrameDurationMargin = 20.0; |
| // Tolerance of frame drop rate in percetange |
| const float kFrameDropRateTolerance = 5.0; |
| |
| Camera3BasicRecordingTest() |
| : Camera3RecordingFixture(std::vector<int>(1, std::get<0>(GetParam()))), |
| cam_id_(std::get<0>(GetParam())), |
| recording_resolution_(std::get<1>(GetParam()), std::get<2>(GetParam())), |
| recording_frame_rate_(std::get<3>(GetParam())), |
| support_constant_framerate_(std::get<4>(GetParam())) {} |
| |
| protected: |
| // |duration_ms|: total duration of recording in milliseconds |
| // |frame_duration_ms|: duration of each frame in milliseconds |
| void ValidateConstantFrameRate(float duration_ms, float frame_duration_ms); |
| |
| // Finds the valid recording fps range in metadata according to |
| // |recording_frame_rate_| and |support_constant_framerate_| and fills the |
| // values in |fps_range|. |
| bool FindValidRecordingFpsRange(int32_t* fps_range); |
| |
| int cam_id_; |
| |
| ResolutionInfo recording_resolution_; |
| |
| float recording_frame_rate_; |
| |
| bool support_constant_framerate_; |
| }; |
| |
| void Camera3BasicRecordingTest::ValidateConstantFrameRate( |
| float duration_ms, float frame_duration_ms) { |
| ASSERT_NE(0, duration_ms); |
| ASSERT_NE(0, frame_duration_ms); |
| float max_frame_duration_ms = |
| frame_duration_ms * (1.0 + kFrameDurationMargin / 100.0); |
| float min_frame_duration_ms = |
| frame_duration_ms * (1.0 - kFrameDurationMargin / 100.0); |
| uint32_t frame_drop_count = 0; |
| int64_t prev_timestamp = sensor_timestamp_map_[cam_id_].front(); |
| sensor_timestamp_map_[cam_id_].pop_front(); |
| while (!sensor_timestamp_map_[cam_id_].empty()) { |
| int64_t cur_timestamp = sensor_timestamp_map_[cam_id_].front(); |
| sensor_timestamp_map_[cam_id_].pop_front(); |
| if (static_cast<float>(cur_timestamp - prev_timestamp) / 1000000 > |
| max_frame_duration_ms || |
| static_cast<float>(cur_timestamp - prev_timestamp) / 1000000 < |
| min_frame_duration_ms) { |
| VLOGF(1) << "Frame drop at " |
| << (prev_timestamp / 1000000 + |
| static_cast<int64_t>(frame_duration_ms)) |
| << " ms, actual " << cur_timestamp / 1000000 << " ms"; |
| ++frame_drop_count; |
| } |
| prev_timestamp = cur_timestamp; |
| } |
| float frame_drop_rate = |
| 100.0 * frame_drop_count * frame_duration_ms / duration_ms; |
| ASSERT_LT(frame_drop_rate, kFrameDropRateTolerance) |
| << "Camera " << cam_id_ |
| << " Video frame drop rate too high: " << frame_drop_rate |
| << ", tolerance " << kFrameDropRateTolerance; |
| } |
| |
| bool Camera3BasicRecordingTest::FindValidRecordingFpsRange(int32_t* fps_range) { |
| std::set<std::pair<int32_t, int32_t>> available_fps_ranges = |
| cam_service_.GetStaticInfo(cam_id_)->GetAvailableFpsRanges(); |
| for (auto& range : available_fps_ranges) { |
| if (support_constant_framerate_) { |
| // Find [fps, fps] for device supports constant frame rate. |
| if (range.first == recording_frame_rate_ && |
| range.second == recording_frame_rate_) { |
| fps_range[0] = range.first; |
| fps_range[1] = range.second; |
| return true; |
| } |
| } else { |
| // Find [min, max] that fulfill |min <= fps <= max| for device which does |
| // not support constant frame rate. |
| if (range.first <= recording_frame_rate_ && |
| recording_frame_rate_ <= range.second) { |
| fps_range[0] = range.first; |
| fps_range[1] = range.second; |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| TEST_P(Camera3BasicRecordingTest, BasicRecording) { |
| #define ARRAY_SIZE(A) (sizeof(A) / sizeof(*(A))) |
| // Choose a preview resolution that is equal to or smaller than full HD so as |
| // to avoid the full-sized one used for the ZSL opaque stream. Ideally we |
| // should check it against the display resolution, but this should do for now. |
| // 1920x1088 is used here since on certain hardware alignment to 16 or higher |
| // is required. |
| const ResolutionInfo full_hd_alt(1920, 1088); |
| auto preview_resolutions = |
| cam_service_.GetStaticInfo(cam_id_)->GetSortedOutputResolutions( |
| HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED); |
| ResolutionInfo preview_resolution(0, 0); |
| for (auto it = preview_resolutions.rbegin(); it != preview_resolutions.rend(); |
| ++it) { |
| // Both width and height should be equal to or smaller than the bound |
| // according to getSupportedPreviewSizes() of cts/CameraTestUtils.java. |
| if (it->Width() <= full_hd_alt.Width() && |
| it->Height() <= full_hd_alt.Height()) { |
| preview_resolution = *it; |
| break; |
| } |
| } |
| ResolutionInfo jpeg_resolution(0, 0); |
| cam_service_.StartPreview(cam_id_, preview_resolution, jpeg_resolution, |
| recording_resolution_); |
| ScopedCameraMetadata recording_metadata( |
| clone_camera_metadata(cam_service_.ConstructDefaultRequestSettings( |
| cam_id_, CAMERA3_TEMPLATE_VIDEO_RECORD))); |
| ASSERT_NE(nullptr, recording_metadata.get()); |
| |
| int32_t fps_range[2]; |
| bool is_found = FindValidRecordingFpsRange(fps_range); |
| ASSERT_EQ(is_found, true); |
| |
| EXPECT_EQ(0, UpdateMetadata(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, fps_range, |
| ARRAY_SIZE(fps_range), &recording_metadata)); |
| cam_service_.StartRecording(cam_id_, recording_metadata.get()); |
| usleep(kRecordingDurationMs * 1000); |
| cam_service_.StopRecording(cam_id_); |
| |
| if (support_constant_framerate_) { |
| float frame_duration_ms = 1000.0 / recording_frame_rate_; |
| float duration_ms = |
| sensor_timestamp_map_[cam_id_].size() * frame_duration_ms; |
| ValidateConstantFrameRate(duration_ms, frame_duration_ms); |
| } else { |
| ASSERT_EQ(cam_service_.GetStaticInfo(cam_id_)->GetHardwareLevel(), |
| ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL); |
| ASSERT_GT(sensor_timestamp_map_[cam_id_].size(), 0); |
| } |
| |
| cam_service_.StopPreview(cam_id_); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(Camera3RecordingFixture, |
| Camera3BasicRecordingTest, |
| ::testing::ValuesIn(ParseRecordingParams())); |
| |
| } // namespace camera3_test |
