1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "camera_deferred_video_moduletest.h"
17
18 #include "accesstoken_kit.h"
19 #include "camera_log.h"
20 #include "deferred_proc_session/deferred_video_proc_session.h"
21 #include "hap_token_info.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "test_token.h"
25
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace CameraStandard {
30 constexpr int32_t DEFERRED_VIDEO_NOT_ENABLED = 0;
31 constexpr int32_t DEFERRED_VIDEO_ENABLED = 1;
SetUpTestCase(void)32 void CameraDeferredVideoModuleTest::SetUpTestCase(void)
33 {
34 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::SetUpTestCase started!");
35 ASSERT_TRUE(TestToken().GetAllCameraPermission());
36 }
37
TearDownTestCase(void)38 void CameraDeferredVideoModuleTest::TearDownTestCase(void)
39 {
40 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::TearDownTestCase started!");
41 }
42
SetUp()43 void CameraDeferredVideoModuleTest::SetUp()
44 {
45 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::SetUp started!");
46
47 cameraManager_ = CameraManager::GetInstance();
48 ASSERT_NE(cameraManager_, nullptr);
49
50 cameras_ = cameraManager_->GetSupportedCameras();
51 CHECK_RETURN_ELOG(cameras_.empty(), "GetSupportedCameras empty");
52
53 std::vector<SceneMode> sceneModes = GetSupportedSceneModes(cameras_[0]);
54 auto it = std::find(sceneModes.begin(), sceneModes.end(), SceneMode::VIDEO);
55 CHECK_RETURN_ELOG(it == sceneModes.end(), "SceneMode::VIDEO not supported");
56
57 outputCapability_ = cameraManager_->GetSupportedOutputCapability(cameras_[0], SceneMode::VIDEO);
58 ASSERT_NE(outputCapability_, nullptr);
59 previewProfiles_ = outputCapability_->GetPreviewProfiles();
60 videoProfiles_ = outputCapability_->GetVideoProfiles();
61 CHECK_RETURN_ELOG(previewProfiles_.empty() || videoProfiles_.empty(),
62 "GetPreviewProfiles or GetVideoProfiles empty");
63
64 FilterPreviewProfiles(previewProfiles_);
65 previewOutput_ = CreatePreviewOutput(previewProfiles_[0]);
66 ASSERT_NE(previewOutput_, nullptr);
67 cameraInput_ = cameraManager_->CreateCameraInput(cameras_[0]);
68 ASSERT_NE(cameraInput_, nullptr);
69 EXPECT_EQ(cameraInput_->Open(), CameraErrorCode::SUCCESS);
70 }
71
TearDown()72 void CameraDeferredVideoModuleTest::TearDown()
73 {
74 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::TearDown started!");
75 if (captureSession_) {
76 if (cameraInput_) {
77 EXPECT_EQ(cameraInput_->Release(), CameraErrorCode::SUCCESS);
78 }
79 if (previewOutput_) {
80 EXPECT_EQ(previewOutput_->Release(), CameraErrorCode::SUCCESS);
81 }
82 if (videoOutput_) {
83 EXPECT_EQ(videoOutput_->Release(), CameraErrorCode::SUCCESS);
84 }
85 EXPECT_EQ(captureSession_->Release(), CameraErrorCode::SUCCESS);
86 }
87
88 cameras_.clear();
89 previewProfiles_.clear();
90 videoProfiles_.clear();
91 outputCapability_.clear();
92 previewOutput_.clear();
93 videoOutput_.clear();
94 cameraInput_.clear();
95 captureSession_.clear();
96 cameraManager_.clear();
97 }
98
GetSupportedSceneModes(sptr<CameraDevice> & camera)99 std::vector<SceneMode> CameraDeferredVideoModuleTest::GetSupportedSceneModes(sptr<CameraDevice>& camera)
100 {
101 std::vector<SceneMode> sceneModes = {};
102 sceneModes = cameraManager_->GetSupportedModes(cameras_[0]);
103 if (sceneModes.empty()) {
104 sceneModes.emplace_back(SceneMode::CAPTURE);
105 sceneModes.emplace_back(SceneMode::VIDEO);
106 }
107 return sceneModes;
108 }
109
CreatePreviewOutput(Profile & profile)110 sptr<PreviewOutput> CameraDeferredVideoModuleTest::CreatePreviewOutput(Profile& profile)
111 {
112 sptr<IConsumerSurface> previewSurface = IConsumerSurface::Create();
113 Size previewSize = profile.GetSize();
114 previewSurface->SetUserData(CameraManager::surfaceFormat, std::to_string(profile.GetCameraFormat()));
115 previewSurface->SetDefaultWidthAndHeight(previewSize.width, previewSize.height);
116
117 sptr<IBufferProducer> bp = previewSurface->GetProducer();
118 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(bp);
119
120 sptr<PreviewOutput> previewOutput = nullptr;
121 previewOutput = cameraManager_->CreatePreviewOutput(profile, pSurface);
122 return previewOutput;
123 }
124
CreateVideoOutput(VideoProfile & videoProfile)125 sptr<VideoOutput> CameraDeferredVideoModuleTest::CreateVideoOutput(VideoProfile& videoProfile)
126 {
127 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
128 sptr<IBufferProducer> videoProducer = surface->GetProducer();
129 sptr<Surface> videoSurface = Surface::CreateSurfaceAsProducer(videoProducer);
130 sptr<VideoOutput> videoOutput = nullptr;
131 videoOutput = cameraManager_->CreateVideoOutput(videoProfile, videoSurface);
132 return videoOutput;
133 }
134
FilterPreviewProfiles(std::vector<Profile> & previewProfiles)135 void CameraDeferredVideoModuleTest::FilterPreviewProfiles(std::vector<Profile>& previewProfiles)
136 {
137 std::vector<Profile>::iterator itr = previewProfiles.begin();
138 while (itr != previewProfiles.end()) {
139 Profile profile = *itr;
140 if ((profile.size_.width == PRVIEW_WIDTH_176 && profile.size_.height == PRVIEW_HEIGHT_144) ||
141 (profile.size_.width == PRVIEW_WIDTH_480 && profile.size_.height == PRVIEW_HEIGHT_480) ||
142 (profile.size_.width == PRVIEW_WIDTH_640 && profile.size_.height == PRVIEW_HEIGHT_640) ||
143 (profile.size_.width == PRVIEW_WIDTH_4096 && profile.size_.height == PRVIEW_HEIGHT_3072) ||
144 (profile.size_.width == PRVIEW_WIDTH_4160 && profile.size_.height == PRVIEW_HEIGHT_3120) ||
145 (profile.size_.width == PRVIEW_WIDTH_8192 && profile.size_.height == PRVIEW_HEIGHT_6144)) {
146 MEDIA_DEBUG_LOG("SetUp skip previewProfile width:%{public}d height:%{public}d",
147 profile.size_.width, profile.size_.height);
148 itr = previewProfiles.erase(itr);
149 } else {
150 ++itr;
151 }
152 }
153 }
154
RegisterVideoStateCallback()155 void CameraDeferredVideoModuleTest::RegisterVideoStateCallback()
156 {
157 videoStateCallback_ = make_shared<ModuleTestVideoStateCallback>();
158 ASSERT_NE(videoStateCallback_, nullptr);
159 if (videoOutput_) {
160 videoOutput_->SetCallback(videoStateCallback_);
161 }
162 }
163
OnFrameStarted() const164 void ModuleTestVideoStateCallback::OnFrameStarted() const
165 {
166 MEDIA_INFO_LOG("OnFrameStarted is called");
167 }
168
OnFrameEnded(const int32_t frameCount) const169 void ModuleTestVideoStateCallback::OnFrameEnded(const int32_t frameCount) const
170 {
171 MEDIA_INFO_LOG("OnFrameEnded is called");
172 }
173
OnError(const int32_t errorCode) const174 void ModuleTestVideoStateCallback::OnError(const int32_t errorCode) const
175 {
176 MEDIA_INFO_LOG("OnError is called");
177 }
178
OnDeferredVideoEnhancementInfo(const CaptureEndedInfoExt captureEndedInfo) const179 void ModuleTestVideoStateCallback::OnDeferredVideoEnhancementInfo(const CaptureEndedInfoExt captureEndedInfo) const
180 {
181 MEDIA_INFO_LOG("OnDeferredVideoEnhancementInfo is called");
182 }
183
184 /*
185 * Feature: Framework
186 * Function: Test the normal process of enabling deferred video.
187 * SubFunction: NA
188 * FunctionPoints: NA
189 * EnvConditions: NA
190 * CaseDescription: Test the normal process of enabling deferred video.
191 */
192 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_001, TestSize.Level0)
193 {
194 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
195 ASSERT_NE(videoOutput_, nullptr);
196
197 RegisterVideoStateCallback();
198
199 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
200 ASSERT_NE(captureSession_, nullptr);
201
202 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
203 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
204 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
205 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
206 sptr<CaptureOutput> videoOutput = static_cast<CaptureOutput*>(videoOutput_.GetRefPtr());
207 EXPECT_EQ(captureSession_->AddOutput(videoOutput), CameraErrorCode::SUCCESS);
208
209 CHECK_RETURN_ELOG(videoOutput_->IsAutoDeferredVideoEnhancementSupported() == 0,
210 "deferred video not supported");
211 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_NOT_ENABLED);
212 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SUCCESS);
213 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
214 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
215 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_ENABLED);
216 EXPECT_EQ(videoOutput_->Start(), CameraErrorCode::SUCCESS);
217 EXPECT_EQ(videoOutput_->Stop(), CameraErrorCode::SUCCESS);
218 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
219 }
220
221 /*
222 * Feature: Framework
223 * Function: Test the normal process of disabling deferred video.
224 * SubFunction: NA
225 * FunctionPoints: NA
226 * EnvConditions: NA
227 * CaseDescription: Test the normal process of disabling deferred video.
228 */
229 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_002, TestSize.Level0)
230 {
231 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
232 ASSERT_NE(videoOutput_, nullptr);
233
234 RegisterVideoStateCallback();
235
236 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
237 ASSERT_NE(captureSession_, nullptr);
238
239 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
240 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
241 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
242 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
243 sptr<CaptureOutput> videoOutput = static_cast<CaptureOutput*>(videoOutput_.GetRefPtr());
244 EXPECT_EQ(captureSession_->AddOutput(videoOutput), CameraErrorCode::SUCCESS);
245
246 CHECK_RETURN_ELOG(videoOutput_->IsAutoDeferredVideoEnhancementSupported() == 0,
247 "deferred video not supported");
248 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_NOT_ENABLED);
249 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SUCCESS);
250 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_ENABLED);
251 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(false), CameraErrorCode::SUCCESS);
252 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
253 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
254 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_NOT_ENABLED);
255 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
256 }
257
258 /*
259 * Feature: Framework
260 * Function: Test enabling deferred video without add video output.
261 * SubFunction: NA
262 * FunctionPoints: NA
263 * EnvConditions: NA
264 * CaseDescription: Test enabling deferred video without add video output.
265 */
266 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_003, TestSize.Level0)
267 {
268 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
269 ASSERT_NE(videoOutput_, nullptr);
270
271 RegisterVideoStateCallback();
272
273 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
274 ASSERT_NE(captureSession_, nullptr);
275
276 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
277 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
278 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
279 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
280
281 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementSupported(), CameraErrorCode::SERVICE_FATL_ERROR);
282 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), CameraErrorCode::SERVICE_FATL_ERROR);
283 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SERVICE_FATL_ERROR);
284 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
285 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
286 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
287 }
288
289 /*
290 * Feature: Framework
291 * Function: Test enabling deferred video before add input.
292 * SubFunction: NA
293 * FunctionPoints: NA
294 * EnvConditions: NA
295 * CaseDescription: Test enabling deferred video before add input.
296 */
297 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_004, TestSize.Level0)
298 {
299 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
300 ASSERT_NE(videoOutput_, nullptr);
301
302 RegisterVideoStateCallback();
303
304 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
305 ASSERT_NE(captureSession_, nullptr);
306
307 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
308 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementSupported(), CameraErrorCode::SERVICE_FATL_ERROR);
309 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), CameraErrorCode::SERVICE_FATL_ERROR);
310 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SERVICE_FATL_ERROR);
311
312 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
313 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
314 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
315 sptr<CaptureOutput> videoOutput = static_cast<CaptureOutput*>(videoOutput_.GetRefPtr());
316 EXPECT_EQ(captureSession_->AddOutput(videoOutput), CameraErrorCode::SUCCESS);
317 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
318 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
319 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
320 }
321 } // CameraStandard
322 } // OHOS