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
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace CameraStandard {
29 constexpr int32_t DEFERRED_VIDEO_NOT_ENABLED = 0;
30 constexpr int32_t DEFERRED_VIDEO_ENABLED = 1;
SetUpTestCase(void)31 void CameraDeferredVideoModuleTest::SetUpTestCase(void)
32 {
33 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::SetUpTestCase started!");
34 }
35
TearDownTestCase(void)36 void CameraDeferredVideoModuleTest::TearDownTestCase(void)
37 {
38 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::TearDownTestCase started!");
39 }
40
SetUp()41 void CameraDeferredVideoModuleTest::SetUp()
42 {
43 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::SetUp started!");
44 SetNativeToken();
45
46 cameraManager_ = CameraManager::GetInstance();
47 ASSERT_NE(cameraManager_, nullptr);
48
49 cameras_ = cameraManager_->GetSupportedCameras();
50 CHECK_ERROR_RETURN_LOG(cameras_.empty(), "GetSupportedCameras empty");
51
52 std::vector<SceneMode> sceneModes = GetSupportedSceneModes(cameras_[0]);
53 auto it = std::find(sceneModes.begin(), sceneModes.end(), SceneMode::VIDEO);
54 CHECK_ERROR_RETURN_LOG(it == sceneModes.end(), "SceneMode::VIDEO not supported");
55
56 outputCapability_ = cameraManager_->GetSupportedOutputCapability(cameras_[0], SceneMode::VIDEO);
57 ASSERT_NE(outputCapability_, nullptr);
58 previewProfiles_ = outputCapability_->GetPreviewProfiles();
59 videoProfiles_ = outputCapability_->GetVideoProfiles();
60 CHECK_ERROR_RETURN_LOG(previewProfiles_.empty() || videoProfiles_.empty(),
61 "GetPreviewProfiles or GetVideoProfiles empty");
62
63 FilterPreviewProfiles(previewProfiles_);
64 previewOutput_ = CreatePreviewOutput(previewProfiles_[0]);
65 ASSERT_NE(previewOutput_, nullptr);
66 cameraInput_ = cameraManager_->CreateCameraInput(cameras_[0]);
67 ASSERT_NE(cameraInput_, nullptr);
68 EXPECT_EQ(cameraInput_->Open(), CameraErrorCode::SUCCESS);
69 }
70
TearDown()71 void CameraDeferredVideoModuleTest::TearDown()
72 {
73 MEDIA_DEBUG_LOG("CameraDeferredVideoModuleTest::TearDown started!");
74 if (captureSession_) {
75 if (cameraInput_) {
76 EXPECT_EQ(cameraInput_->Release(), CameraErrorCode::SUCCESS);
77 }
78 if (previewOutput_) {
79 EXPECT_EQ(previewOutput_->Release(), CameraErrorCode::SUCCESS);
80 }
81 if (videoOutput_) {
82 EXPECT_EQ(videoOutput_->Release(), CameraErrorCode::SUCCESS);
83 }
84 EXPECT_EQ(captureSession_->Release(), CameraErrorCode::SUCCESS);
85 }
86
87 cameras_.clear();
88 previewProfiles_.clear();
89 videoProfiles_.clear();
90 outputCapability_.clear();
91 previewOutput_.clear();
92 videoOutput_.clear();
93 cameraInput_.clear();
94 captureSession_.clear();
95 cameraManager_.clear();
96 }
97
SetNativeToken()98 void CameraDeferredVideoModuleTest::SetNativeToken()
99 {
100 uint64_t tokenId;
101 const char* perms[2];
102 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
103 perms[1] = "ohos.permission.CAMERA";
104 NativeTokenInfoParams infoInstance = {
105 .dcapsNum = 0,
106 .permsNum = 2,
107 .aclsNum = 0,
108 .dcaps = NULL,
109 .perms = perms,
110 .acls = NULL,
111 .processName = "native_camera_mst",
112 .aplStr = "system_basic",
113 };
114 tokenId = GetAccessTokenId(&infoInstance);
115 SetSelfTokenID(tokenId);
116 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
117 }
118
GetSupportedSceneModes(sptr<CameraDevice> & camera)119 std::vector<SceneMode> CameraDeferredVideoModuleTest::GetSupportedSceneModes(sptr<CameraDevice>& camera)
120 {
121 std::vector<SceneMode> sceneModes = {};
122 sceneModes = cameraManager_->GetSupportedModes(cameras_[0]);
123 if (sceneModes.empty()) {
124 sceneModes.emplace_back(SceneMode::CAPTURE);
125 sceneModes.emplace_back(SceneMode::VIDEO);
126 }
127 return sceneModes;
128 }
129
CreatePreviewOutput(Profile & profile)130 sptr<PreviewOutput> CameraDeferredVideoModuleTest::CreatePreviewOutput(Profile& profile)
131 {
132 sptr<IConsumerSurface> previewSurface = IConsumerSurface::Create();
133 Size previewSize = profile.GetSize();
134 previewSurface->SetUserData(CameraManager::surfaceFormat, std::to_string(profile.GetCameraFormat()));
135 previewSurface->SetDefaultWidthAndHeight(previewSize.width, previewSize.height);
136
137 sptr<IBufferProducer> bp = previewSurface->GetProducer();
138 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(bp);
139
140 sptr<PreviewOutput> previewOutput = nullptr;
141 previewOutput = cameraManager_->CreatePreviewOutput(profile, pSurface);
142 return previewOutput;
143 }
144
CreateVideoOutput(VideoProfile & videoProfile)145 sptr<VideoOutput> CameraDeferredVideoModuleTest::CreateVideoOutput(VideoProfile& videoProfile)
146 {
147 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
148 sptr<IBufferProducer> videoProducer = surface->GetProducer();
149 sptr<Surface> videoSurface = Surface::CreateSurfaceAsProducer(videoProducer);
150 sptr<VideoOutput> videoOutput = nullptr;
151 videoOutput = cameraManager_->CreateVideoOutput(videoProfile, videoSurface);
152 return videoOutput;
153 }
154
FilterPreviewProfiles(std::vector<Profile> & previewProfiles)155 void CameraDeferredVideoModuleTest::FilterPreviewProfiles(std::vector<Profile>& previewProfiles)
156 {
157 std::vector<Profile>::iterator itr = previewProfiles.begin();
158 while (itr != previewProfiles.end()) {
159 Profile profile = *itr;
160 if ((profile.size_.width == PRVIEW_WIDTH_176 && profile.size_.height == PRVIEW_HEIGHT_144) ||
161 (profile.size_.width == PRVIEW_WIDTH_480 && profile.size_.height == PRVIEW_HEIGHT_480) ||
162 (profile.size_.width == PRVIEW_WIDTH_640 && profile.size_.height == PRVIEW_HEIGHT_640) ||
163 (profile.size_.width == PRVIEW_WIDTH_4096 && profile.size_.height == PRVIEW_HEIGHT_3072) ||
164 (profile.size_.width == PRVIEW_WIDTH_4160 && profile.size_.height == PRVIEW_HEIGHT_3120) ||
165 (profile.size_.width == PRVIEW_WIDTH_8192 && profile.size_.height == PRVIEW_HEIGHT_6144)) {
166 MEDIA_DEBUG_LOG("SetUp skip previewProfile width:%{public}d height:%{public}d",
167 profile.size_.width, profile.size_.height);
168 itr = previewProfiles.erase(itr);
169 } else {
170 ++itr;
171 }
172 }
173 }
174
RegisterVideoStateCallback()175 void CameraDeferredVideoModuleTest::RegisterVideoStateCallback()
176 {
177 videoStateCallback_ = make_shared<ModuleTestVideoStateCallback>();
178 ASSERT_NE(videoStateCallback_, nullptr);
179 if (videoOutput_) {
180 videoOutput_->SetCallback(videoStateCallback_);
181 }
182 }
183
OnFrameStarted() const184 void ModuleTestVideoStateCallback::OnFrameStarted() const
185 {
186 MEDIA_INFO_LOG("OnFrameStarted is called");
187 }
188
OnFrameEnded(const int32_t frameCount) const189 void ModuleTestVideoStateCallback::OnFrameEnded(const int32_t frameCount) const
190 {
191 MEDIA_INFO_LOG("OnFrameEnded is called");
192 }
193
OnError(const int32_t errorCode) const194 void ModuleTestVideoStateCallback::OnError(const int32_t errorCode) const
195 {
196 MEDIA_INFO_LOG("OnError is called");
197 }
198
OnDeferredVideoEnhancementInfo(const CaptureEndedInfoExt captureEndedInfo) const199 void ModuleTestVideoStateCallback::OnDeferredVideoEnhancementInfo(const CaptureEndedInfoExt captureEndedInfo) const
200 {
201 MEDIA_INFO_LOG("OnDeferredVideoEnhancementInfo is called");
202 }
203
204 /*
205 * Feature: Framework
206 * Function: Test the normal process of enabling deferred video.
207 * SubFunction: NA
208 * FunctionPoints: NA
209 * EnvConditions: NA
210 * CaseDescription: Test the normal process of enabling deferred video.
211 */
212 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_001, TestSize.Level0)
213 {
214 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
215 ASSERT_NE(videoOutput_, nullptr);
216
217 RegisterVideoStateCallback();
218
219 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
220 ASSERT_NE(captureSession_, nullptr);
221
222 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
223 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
224 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
225 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
226 sptr<CaptureOutput> videoOutput = static_cast<CaptureOutput*>(videoOutput_.GetRefPtr());
227 EXPECT_EQ(captureSession_->AddOutput(videoOutput), CameraErrorCode::SUCCESS);
228
229 CHECK_ERROR_RETURN_LOG(videoOutput_->IsAutoDeferredVideoEnhancementSupported() == 0,
230 "deferred video not supported");
231 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_NOT_ENABLED);
232 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SUCCESS);
233 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
234 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
235 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_ENABLED);
236 EXPECT_EQ(videoOutput_->Start(), CameraErrorCode::SUCCESS);
237 EXPECT_EQ(videoOutput_->Stop(), CameraErrorCode::SUCCESS);
238 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
239 }
240
241 /*
242 * Feature: Framework
243 * Function: Test the normal process of disabling deferred video.
244 * SubFunction: NA
245 * FunctionPoints: NA
246 * EnvConditions: NA
247 * CaseDescription: Test the normal process of disabling deferred video.
248 */
249 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_002, TestSize.Level0)
250 {
251 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
252 ASSERT_NE(videoOutput_, nullptr);
253
254 RegisterVideoStateCallback();
255
256 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
257 ASSERT_NE(captureSession_, nullptr);
258
259 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
260 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
261 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
262 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
263 sptr<CaptureOutput> videoOutput = static_cast<CaptureOutput*>(videoOutput_.GetRefPtr());
264 EXPECT_EQ(captureSession_->AddOutput(videoOutput), CameraErrorCode::SUCCESS);
265
266 CHECK_ERROR_RETURN_LOG(videoOutput_->IsAutoDeferredVideoEnhancementSupported() == 0,
267 "deferred video not supported");
268 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_NOT_ENABLED);
269 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SUCCESS);
270 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_ENABLED);
271 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(false), CameraErrorCode::SUCCESS);
272 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
273 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
274 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), DEFERRED_VIDEO_NOT_ENABLED);
275 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
276 }
277
278 /*
279 * Feature: Framework
280 * Function: Test enabling deferred video without add video output.
281 * SubFunction: NA
282 * FunctionPoints: NA
283 * EnvConditions: NA
284 * CaseDescription: Test enabling deferred video without add video output.
285 */
286 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_003, TestSize.Level0)
287 {
288 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
289 ASSERT_NE(videoOutput_, nullptr);
290
291 RegisterVideoStateCallback();
292
293 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
294 ASSERT_NE(captureSession_, nullptr);
295
296 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
297 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
298 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
299 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
300
301 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementSupported(), CameraErrorCode::SERVICE_FATL_ERROR);
302 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), CameraErrorCode::SERVICE_FATL_ERROR);
303 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SERVICE_FATL_ERROR);
304 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
305 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
306 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
307 }
308
309 /*
310 * Feature: Framework
311 * Function: Test enabling deferred video before add input.
312 * SubFunction: NA
313 * FunctionPoints: NA
314 * EnvConditions: NA
315 * CaseDescription: Test enabling deferred video before add input.
316 */
317 HWTEST_F(CameraDeferredVideoModuleTest, camera_deferred_video_moduletest_004, TestSize.Level0)
318 {
319 videoOutput_ = CreateVideoOutput(videoProfiles_[0]);
320 ASSERT_NE(videoOutput_, nullptr);
321
322 RegisterVideoStateCallback();
323
324 captureSession_ = cameraManager_->CreateCaptureSession(SceneMode::VIDEO);
325 ASSERT_NE(captureSession_, nullptr);
326
327 EXPECT_EQ(captureSession_->BeginConfig(), CameraErrorCode::SUCCESS);
328 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementSupported(), CameraErrorCode::SERVICE_FATL_ERROR);
329 EXPECT_EQ(videoOutput_->IsAutoDeferredVideoEnhancementEnabled(), CameraErrorCode::SERVICE_FATL_ERROR);
330 EXPECT_EQ(videoOutput_->EnableAutoDeferredVideoEnhancement(true), CameraErrorCode::SERVICE_FATL_ERROR);
331
332 EXPECT_EQ(captureSession_->AddInput(cameraInput_), CameraErrorCode::SUCCESS);
333 sptr<CaptureOutput> previewOutput = static_cast<CaptureOutput*>(previewOutput_.GetRefPtr());
334 EXPECT_EQ(captureSession_->AddOutput(previewOutput), CameraErrorCode::SUCCESS);
335 sptr<CaptureOutput> videoOutput = static_cast<CaptureOutput*>(videoOutput_.GetRefPtr());
336 EXPECT_EQ(captureSession_->AddOutput(videoOutput), CameraErrorCode::SUCCESS);
337 EXPECT_EQ(captureSession_->CommitConfig(), CameraErrorCode::SUCCESS);
338 EXPECT_EQ(captureSession_->Start(), CameraErrorCode::SUCCESS);
339 EXPECT_EQ(captureSession_->Stop(), CameraErrorCode::SUCCESS);
340 }
341 } // CameraStandard
342 } // OHOS