1 /*
2 * Copyright (c) 2023 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 "screen_capture_unit_test.h"
17 #include "media_errors.h"
18
19 using namespace OHOS;
20 using namespace OHOS::Media;
21 using namespace testing::ext;
22 using namespace std;
23 using namespace OHOS::Rosen;
24 using namespace OHOS::Media::ScreenCaptureTestParam;
25
26 namespace OHOS {
27 namespace Media {
OnError(int32_t errorCode)28 void ScreenCaptureUnitTestCallback::OnError(int32_t errorCode)
29 {
30 cout << "Error received, errorCode:" << errorCode << endl;
31 }
32
OnAudioBufferAvailable(bool isReady,AudioCaptureSourceType type)33 void ScreenCaptureUnitTestCallback::OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type)
34 {
35 if (isReady) {
36 std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
37 if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
38 if (audioBuffer == nullptr) {
39 cout << "AcquireAudioBuffer failed, audio buffer empty" << endl;
40 }
41 cout << "AcquireAudioBuffer, audioBufferLen:" << audioBuffer->length << ", timestampe:"
42 << audioBuffer->timestamp << ", audioSourceType:" << audioBuffer->sourcetype << endl;
43 DumpAudioBuffer(audioBuffer);
44 }
45 if (aFlag_ == 1) {
46 screenCapture_->ReleaseAudioBuffer(type);
47 }
48 } else {
49 cout << "AcquireAudioBuffer failed" << endl;
50 }
51 }
52
DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)53 void ScreenCaptureUnitTestCallback::DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)
54 {
55 if ((aFile_ != nullptr) && (audioBuffer->buffer != nullptr)) {
56 if (fwrite(audioBuffer->buffer, 1, audioBuffer->length, aFile_) != audioBuffer->length) {
57 cout << "error occurred in fwrite:" << strerror(errno) <<endl;
58 }
59 }
60 }
61
OnVideoBufferAvailable(bool isReady)62 void ScreenCaptureUnitTestCallback::OnVideoBufferAvailable(bool isReady)
63 {
64 if (isReady) {
65 int32_t fence = 0;
66 int64_t timestamp = 0;
67 OHOS::Rect damage;
68 sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
69 if (surfacebuffer != nullptr) {
70 int32_t length = surfacebuffer->GetSize();
71 cout << "AcquireVideoBuffer, videoBufferLen:" << surfacebuffer->GetSize() << ", timestamp:"
72 << timestamp << ", size:"<< length << endl;
73 DumpVideoBuffer(surfacebuffer);
74 if (vFlag_ == 1) {
75 screenCapture_->ReleaseVideoBuffer();
76 }
77 } else {
78 cout << "AcquireVideoBuffer failed" << endl;
79 }
80 }
81 }
82
DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer)83 void ScreenCaptureUnitTestCallback::DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer)
84 {
85 if (vFile_ != nullptr) {
86 if (fwrite(surfacebuffer->GetVirAddr(), 1, surfacebuffer->GetSize(), vFile_) != surfacebuffer->GetSize()) {
87 cout << "error occurred in fwrite:" << strerror(errno) <<endl;
88 }
89 }
90 }
91
SetUpTestCase(void)92 void ScreenCaptureUnitTest::SetUpTestCase(void)
93 {
94 system("param set debug.media_service.histreamer 0");
95 }
96
TearDownTestCase(void)97 void ScreenCaptureUnitTest::TearDownTestCase(void)
98 {
99 system("param set debug.media_service.histreamer 0");
100 }
101
SetUp(void)102 void ScreenCaptureUnitTest::SetUp(void)
103 {
104 screenCapture_ = ScreenCaptureMockFactory::CreateScreenCapture();
105 ASSERT_NE(nullptr, screenCapture_);
106 }
107
TearDown(void)108 void ScreenCaptureUnitTest::TearDown(void)
109 {
110 }
111
SetConfig(AVScreenCaptureConfig & config)112 int32_t ScreenCaptureUnitTest::SetConfig(AVScreenCaptureConfig &config)
113 {
114 AudioCaptureInfo miccapinfo = {
115 .audioSampleRate = 16000,
116 .audioChannels = 2,
117 .audioSource = SOURCE_DEFAULT
118 };
119
120 VideoCaptureInfo videocapinfo = {
121 .videoFrameWidth = 720,
122 .videoFrameHeight = 1280,
123 .videoSource = VIDEO_SOURCE_SURFACE_RGBA
124 };
125
126 AudioInfo audioinfo = {
127 .micCapInfo = miccapinfo,
128 };
129
130 VideoInfo videoinfo = {
131 .videoCapInfo = videocapinfo
132 };
133
134 config = {
135 .captureMode = CAPTURE_HOME_SCREEN,
136 .dataType = ORIGINAL_STREAM,
137 .audioInfo = audioinfo,
138 .videoInfo = videoinfo,
139 };
140 return MSERR_OK;
141 }
142
OpenFile(std::string filename_)143 void ScreenCaptureUnitTest::OpenFile(std::string filename_)
144 {
145 if (snprintf_s(filename, sizeof(filename), sizeof(filename) - 1, "/data/screen_capture/%s.pcm",
146 filename_.c_str()) >= 0) {
147 aFile = fopen(filename, "w+");
148 if (aFile == nullptr) {
149 cout << "aFile audio open failed, " << strerror(errno) << endl;
150 }
151 } else {
152 cout << "snprintf audio file failed, " << strerror(errno) << endl;
153 return;
154 }
155 if (snprintf_s(filename, sizeof(filename), sizeof(filename) - 1, "/data/screen_capture/%s.yuv",
156 filename_.c_str()) >= 0) {
157 vFile = fopen(filename, "w+");
158 if (vFile == nullptr) {
159 cout << "vFile video open failed, " << strerror(errno) << endl;
160 }
161 } else {
162 cout << "snprintf video file failed, " << strerror(errno) << endl;
163 return;
164 }
165 }
166
CloseFile(void)167 void ScreenCaptureUnitTest::CloseFile(void)
168 {
169 if (aFile != nullptr) {
170 fclose(aFile);
171 aFile = nullptr;
172 }
173 if (vFile != nullptr) {
174 fclose(vFile);
175 vFile = nullptr;
176 }
177 }
178
AudioLoop(void)179 void ScreenCaptureUnitTest::AudioLoop(void)
180 {
181 int index_ = 200;
182 int index_audio_frame = 0;
183 while (index_) {
184 if (screenCapture_ == nullptr) {
185 break;
186 }
187 std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
188 AudioCaptureSourceType type = MIC;
189 if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
190 if (audioBuffer == nullptr) {
191 cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
192 continue;
193 }
194 cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:"
195 << audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:"
196 << audioBuffer->sourcetype << endl;
197 screenCapture_->ReleaseAudioBuffer(type);
198 } else {
199 cout << "AcquireAudioBuffer failed" << endl;
200 }
201 index_--;
202 }
203 }
204
AudioLoopWithoutRelease(void)205 void ScreenCaptureUnitTest::AudioLoopWithoutRelease(void)
206 {
207 int index_ = 200;
208 int index_audio_frame = 0;
209 while (index_) {
210 if (screenCapture_ == nullptr) {
211 break;
212 }
213 std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
214 AudioCaptureSourceType type = MIC;
215 if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
216 if (audioBuffer == nullptr) {
217 cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
218 continue;
219 }
220 cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:"
221 << audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:"
222 << audioBuffer->sourcetype << endl;
223 } else {
224 cout << "AcquireAudioBuffer failed" << endl;
225 }
226 index_--;
227 }
228 }
229
230 /**
231 * @tc.name: screen_capture_video_configure_0001
232 * @tc.desc: init with videoFrameWidth -1
233 * @tc.type: FUNC
234 * @tc.require:
235 */
236 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0001, TestSize.Level2)
237 {
238 AVScreenCaptureConfig config_;
239 SetConfig(config_);
240 config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
241 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
242
243 bool isMicrophone = false;
244 screenCapture_->SetMicrophoneEnabled(isMicrophone);
245 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
246 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
247 }
248
249 /**
250 * @tc.name: screen_capture_video_configure_0002
251 * @tc.desc: init with videoFrameHeight -1
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0002, TestSize.Level2)
256 {
257 AVScreenCaptureConfig config_;
258 SetConfig(config_);
259 config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
260 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
261
262 bool isMicrophone = false;
263 screenCapture_->SetMicrophoneEnabled(isMicrophone);
264 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
265 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
266 }
267
268 /**
269 * @tc.name: screen_capture_video_configure_0003
270 * @tc.desc: init with videoSource yuv
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0003, TestSize.Level2)
275 {
276 AVScreenCaptureConfig config_;
277 SetConfig(config_);
278 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV;
279
280 bool isMicrophone = false;
281 screenCapture_->SetMicrophoneEnabled(isMicrophone);
282 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
283 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
284 }
285
286 /**
287 * @tc.name: screen_capture_video_configure_0004
288 * @tc.desc: init with videoSource es
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0004, TestSize.Level0)
293 {
294 AVScreenCaptureConfig config_;
295 SetConfig(config_);
296 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_ES;
297
298 bool isMicrophone = false;
299 screenCapture_->SetMicrophoneEnabled(isMicrophone);
300 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
301 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
302 }
303
304 /**
305 * @tc.name: screen_capture_without_audio_data
306 * @tc.desc: close microphone
307 * @tc.type: FUNC
308 * @tc.require:
309 */
310 HWTEST_F(ScreenCaptureUnitTest, screen_capture_without_audio_data, TestSize.Level2)
311 {
312 AVScreenCaptureConfig config_;
313 SetConfig(config_);
314 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
315 OpenFile("screen_capture_without_audio_data");
316
317 aFlag = 0;
318 vFlag = 1;
319 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
320 ASSERT_NE(nullptr, screenCaptureCb_);
321 bool isMicrophone = false;
322 screenCapture_->SetMicrophoneEnabled(isMicrophone);
323 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
324 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
325 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
326 sleep(RECORDER_TIME);
327 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
328 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
329 CloseFile();
330 }
331
332 /**
333 * @tc.name: screen_capture_audio_configure_0001
334 * @tc.desc: init with audioSampleRate -1
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0001, TestSize.Level2)
339 {
340 AVScreenCaptureConfig config_;
341 SetConfig(config_);
342 config_.audioInfo.micCapInfo.audioSampleRate = -1;
343 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
344
345 bool isMicrophone = true;
346 screenCapture_->SetMicrophoneEnabled(isMicrophone);
347 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
348 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
349 }
350
351 /**
352 * @tc.name: screen_capture_audio_configure_0002
353 * @tc.desc: init with audioChannels -1
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0002, TestSize.Level2)
358 {
359 AVScreenCaptureConfig config_;
360 SetConfig(config_);
361 config_.audioInfo.micCapInfo.audioChannels = -1;
362 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
363
364 bool isMicrophone = true;
365 screenCapture_->SetMicrophoneEnabled(isMicrophone);
366 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
367 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
368 }
369
370 /**
371 * @tc.name: screen_capture_audio_configure_0003
372 * @tc.desc: init with audioSource SOURCE_INVALID
373 * @tc.type: FUNC
374 * @tc.require:
375 */
376 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0003, TestSize.Level2)
377 {
378 AVScreenCaptureConfig config_;
379 SetConfig(config_);
380 config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID;
381 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
382
383 bool isMicrophone = true;
384 screenCapture_->SetMicrophoneEnabled(isMicrophone);
385 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
386 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
387 }
388
389 /**
390 * @tc.name: screen_capture_avconfigure
391 * @tc.desc: init with both audioinfo and videoinfo invaild
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(ScreenCaptureUnitTest, screen_capture_avconfigure, TestSize.Level2)
396 {
397 AVScreenCaptureConfig config_;
398 SetConfig(config_);
399 config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID;
400 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV;
401
402 bool isMicrophone = true;
403 screenCapture_->SetMicrophoneEnabled(isMicrophone);
404 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
405 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
406 }
407
408 /**
409 * @tc.name: screen_capture_with_audio_data
410 * @tc.desc: open microphone
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_audio_data, TestSize.Level2)
415 {
416 AVScreenCaptureConfig config_;
417 SetConfig(config_);
418 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
419 OpenFile("screen_capture_with_audio_data");
420
421 aFlag = 1;
422 vFlag = 1;
423 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
424 ASSERT_NE(nullptr, screenCaptureCb_);
425 bool isMicrophone = true;
426 screenCapture_->SetMicrophoneEnabled(isMicrophone);
427 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
428 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
429 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
430 sleep(RECORDER_TIME);
431 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
432 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
433 CloseFile();
434 }
435
436 /**
437 * @tc.name: screen_capture_captureMode_0001
438 * @tc.desc: screen capture with captureMode -1
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0001, TestSize.Level2)
443 {
444 AVScreenCaptureConfig config_;
445 SetConfig(config_);
446 config_.captureMode = static_cast<CaptureMode>(-1);
447 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
448
449 bool isMicrophone = true;
450 screenCapture_->SetMicrophoneEnabled(isMicrophone);
451 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
452 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
453 }
454
455 /**
456 * @tc.name: screen_capture_captureMode_0002
457 * @tc.desc: screen capture with captureMode 5
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0002, TestSize.Level2)
462 {
463 AVScreenCaptureConfig config_;
464 SetConfig(config_);
465 config_.captureMode = static_cast<CaptureMode>(5);
466 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
467
468 bool isMicrophone = true;
469 screenCapture_->SetMicrophoneEnabled(isMicrophone);
470 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
471 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
472 }
473
474 /**
475 * @tc.name: screen_capture_init_datatype_0001
476 * @tc.desc: screen capture init with ENCODED_STREAM
477 * @tc.type: FUNC
478 * @tc.require:
479 */
480 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0001, TestSize.Level2)
481 {
482 AVScreenCaptureConfig config_;
483 SetConfig(config_);
484 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
485 config_.dataType = ENCODED_STREAM;
486
487 bool isMicrophone = true;
488 screenCapture_->SetMicrophoneEnabled(isMicrophone);
489 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
490 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
491 }
492
493 /**
494 * @tc.name: screen_capture_init_datatype_0002
495 * @tc.desc: screen capture init with CAPTURE_FILE
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0002, TestSize.Level2)
500 {
501 AVScreenCaptureConfig config_;
502 SetConfig(config_);
503 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
504 config_.dataType = CAPTURE_FILE;
505
506 bool isMicrophone = true;
507 screenCapture_->SetMicrophoneEnabled(isMicrophone);
508 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
509 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
510 }
511
512 /**
513 * @tc.name: screen_capture_init_datatype_0003
514 * @tc.desc: screen capture init with INVAILD
515 * @tc.type: FUNC
516 * @tc.require:
517 */
518 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0003, TestSize.Level2)
519 {
520 AVScreenCaptureConfig config_;
521 SetConfig(config_);
522 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
523 config_.dataType = INVAILD;
524
525 bool isMicrophone = true;
526 screenCapture_->SetMicrophoneEnabled(isMicrophone);
527 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_));
528 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
529 }
530
531 /**
532 * @tc.name: screen_capture_audioSampleRate_48000
533 * @tc.desc: screen capture with audioSampleRate 48000
534 * @tc.type: FUNC
535 * @tc.require:
536 */
537 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audioSampleRate_48000, TestSize.Level2)
538 {
539 AVScreenCaptureConfig config_;
540 SetConfig(config_);
541 config_.audioInfo.micCapInfo.audioSampleRate = 48000;
542 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
543
544 aFlag = 1;
545 vFlag = 1;
546 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
547 ASSERT_NE(nullptr, screenCaptureCb_);
548 bool isMicrophone = true;
549 screenCapture_->SetMicrophoneEnabled(isMicrophone);
550 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
551 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
552 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
553 sleep(RECORDER_TIME);
554 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
555 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
556 }
557
558 /**
559 * @tc.name: screen_capture_video_size_0001
560 * @tc.desc: screen capture with 160x160
561 * @tc.type: FUNC
562 * @tc.require:
563 */
564 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0001, TestSize.Level2)
565 {
566 AVScreenCaptureConfig config_;
567 SetConfig(config_);
568 config_.videoInfo.videoCapInfo.videoFrameWidth = 160;
569 config_.videoInfo.videoCapInfo.videoFrameHeight = 160;
570 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
571 vFile = fopen("/data/screen_capture/screen_capture_video_size_0001.yuv", "w+");
572 if (vFile == nullptr) {
573 cout << "vFile video open failed, " << strerror(errno) << endl;
574 }
575
576 aFlag = 1;
577 vFlag = 1;
578 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
579 ASSERT_NE(nullptr, screenCaptureCb_);
580 bool isMicrophone = true;
581 screenCapture_->SetMicrophoneEnabled(isMicrophone);
582 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
583 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
584 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
585 sleep(RECORDER_TIME);
586 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
587 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
588 CloseFile();
589 }
590
591 /**
592 * @tc.name: screen_capture_video_size_0002
593 * @tc.desc: screen capture with 640x480
594 * @tc.type: FUNC
595 * @tc.require:
596 */
597 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0002, TestSize.Level2)
598 {
599 AVScreenCaptureConfig config_;
600 SetConfig(config_);
601 config_.videoInfo.videoCapInfo.videoFrameWidth = 640;
602 config_.videoInfo.videoCapInfo.videoFrameHeight = 480;
603 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
604 vFile = fopen("/data/screen_capture/screen_capture_video_size_0002.yuv", "w+");
605 if (vFile == nullptr) {
606 cout << "vFile video open failed, " << strerror(errno) << endl;
607 }
608
609 aFlag = 1;
610 vFlag = 1;
611 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
612 ASSERT_NE(nullptr, screenCaptureCb_);
613 bool isMicrophone = true;
614 screenCapture_->SetMicrophoneEnabled(isMicrophone);
615 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
616 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
617 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
618 sleep(RECORDER_TIME);
619 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
620 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
621 CloseFile();
622 }
623
624 /**
625 * @tc.name: screen_capture_video_size_0003
626 * @tc.desc: screen capture with 1920x1080
627 * @tc.type: FUNC
628 * @tc.require:
629 */
630 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0003, TestSize.Level2)
631 {
632 AVScreenCaptureConfig config_;
633 SetConfig(config_);
634 config_.videoInfo.videoCapInfo.videoFrameWidth = 1920;
635 config_.videoInfo.videoCapInfo.videoFrameHeight = 1080;
636 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
637 vFile = fopen("/data/screen_capture/screen_capture_video_size_0003.yuv", "w+");
638 if (vFile == nullptr) {
639 cout << "vFile video open failed, " << strerror(errno) << endl;
640 }
641
642 aFlag = 1;
643 vFlag = 1;
644 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
645 ASSERT_NE(nullptr, screenCaptureCb_);
646 bool isMicrophone = true;
647 screenCapture_->SetMicrophoneEnabled(isMicrophone);
648 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
649 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
650 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
651 sleep(RECORDER_TIME);
652 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
653 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
654 CloseFile();
655 }
656
657 /**
658 * @tc.name: screen_capture_from_display
659 * @tc.desc: screen capture from display
660 * @tc.type: FUNC
661 * @tc.require:
662 */
663 HWTEST_F(ScreenCaptureUnitTest, screen_capture_from_display, TestSize.Level0)
664 {
665 AVScreenCaptureConfig config_;
666 SetConfig(config_);
667 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
668 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync();
669 ASSERT_NE(display, nullptr);
670 cout << "get displayinfo: " << endl;
671 cout << "width: " << display->GetWidth() << "; height: " << display->GetHeight() << "; density: "
672 << display->GetDpi() << "; refreshRate: " << display->GetRefreshRate() << endl;
673
674 config_.videoInfo.videoCapInfo.videoFrameWidth = display->GetWidth();
675 config_.videoInfo.videoCapInfo.videoFrameHeight = display->GetHeight();
676
677 aFlag = 1;
678 vFlag = 1;
679 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
680 ASSERT_NE(nullptr, screenCaptureCb_);
681 bool isMicrophone = true;
682 screenCapture_->SetMicrophoneEnabled(isMicrophone);
683 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
684 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
685 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
686 sleep(RECORDER_TIME);
687 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
688 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
689 }
690
691 /**
692 * @tc.name: screen_capture_buffertest_0001
693 * @tc.desc: screen capture buffer test
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0001, TestSize.Level2)
698 {
699 AVScreenCaptureConfig config_;
700 SetConfig(config_);
701 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
702
703 bool isMicrophone = true;
704 screenCapture_->SetMicrophoneEnabled(isMicrophone);
705 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
706 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
707 int index = 200;
708 int index_video_frame = 0;
709 audioLoop_ = std::make_unique<std::thread>(&ScreenCaptureUnitTest::AudioLoopWithoutRelease, this);
710 while (index) {
711 int32_t fence = 0;
712 int64_t timestamp = 0;
713 OHOS::Rect damage;
714 sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
715 if (surfacebuffer != nullptr) {
716 int32_t length = surfacebuffer->GetSize();
717 cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:"
718 << surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl;
719 } else {
720 cout << "AcquireVideoBuffer failed" << endl;
721 }
722 index--;
723 }
724 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
725 if (audioLoop_ != nullptr && audioLoop_->joinable()) {
726 audioLoop_->join();
727 audioLoop_.reset();
728 audioLoop_ = nullptr;
729 }
730 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
731 }
732
733 /**
734 * @tc.name: screen_capture_buffertest_0002
735 * @tc.desc: screen capture buffer test
736 * @tc.type: FUNC
737 * @tc.require:
738 */
739 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0002, TestSize.Level2)
740 {
741 AVScreenCaptureConfig config_;
742 SetConfig(config_);
743 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
744
745 bool isMicrophone = true;
746 screenCapture_->SetMicrophoneEnabled(isMicrophone);
747 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
748 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
749 int index = 200;
750 int index_video_frame = 0;
751 audioLoop_ = std::make_unique<std::thread>(&ScreenCaptureUnitTest::AudioLoop, this);
752 while (index) {
753 int32_t fence = 0;
754 int64_t timestamp = 0;
755 OHOS::Rect damage;
756 sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
757 if (surfacebuffer != nullptr) {
758 int32_t length = surfacebuffer->GetSize();
759 cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:"
760 << surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl;
761 screenCapture_->ReleaseVideoBuffer();
762 } else {
763 cout << "AcquireVideoBuffer failed" << endl;
764 }
765 index--;
766 }
767 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
768 if (audioLoop_ != nullptr && audioLoop_->joinable()) {
769 audioLoop_->join();
770 audioLoop_.reset();
771 audioLoop_ = nullptr;
772 }
773 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
774 }
775
776 /**
777 * @tc.name: screen_capture_buffertest_0003
778 * @tc.desc: screen capture buffer test
779 * @tc.type: FUNC
780 * @tc.require:
781 */
782 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0003, TestSize.Level2)
783 {
784 AVScreenCaptureConfig config_;
785 SetConfig(config_);
786 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
787
788 aFlag = 0;
789 vFlag = 1;
790 bool isMicrophone = true;
791 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
792 ASSERT_NE(nullptr, screenCaptureCb_);
793 screenCapture_->SetMicrophoneEnabled(isMicrophone);
794 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
795 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
796 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
797 sleep(15);
798 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
799 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
800 }
801
802 /**
803 * @tc.name: screen_capture_buffertest_0004
804 * @tc.desc: screen capture buffer test
805 * @tc.type: FUNC
806 * @tc.require:
807 */
808 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0004, TestSize.Level2)
809 {
810 AVScreenCaptureConfig config_;
811 SetConfig(config_);
812 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
813
814 aFlag = 1;
815 vFlag = 0;
816 bool isMicrophone = true;
817 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
818 ASSERT_NE(nullptr, screenCaptureCb_);
819 screenCapture_->SetMicrophoneEnabled(isMicrophone);
820 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
821 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
822 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
823 sleep(10);
824 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
825 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
826 }
827
828 /**
829 * @tc.name: screen_capture_buffertest_0005
830 * @tc.desc: screen capture buffer test
831 * @tc.type: FUNC
832 * @tc.require:
833 */
834 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0005, TestSize.Level2)
835 {
836 AVScreenCaptureConfig config_;
837 SetConfig(config_);
838 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
839
840 aFlag = 0;
841 vFlag = 0;
842 bool isMicrophone = true;
843 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
844 ASSERT_NE(nullptr, screenCaptureCb_);
845 screenCapture_->SetMicrophoneEnabled(isMicrophone);
846 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
847 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
848 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
849 sleep(10);
850 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
851 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
852 }
853
854 /**
855 * @tc.name: screen_capture_mic_open_close_open
856 * @tc.desc: screen capture mic test
857 * @tc.type: FUNC
858 * @tc.require:
859 */
860 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_open_close_open, TestSize.Level2)
861 {
862 AVScreenCaptureConfig config_;
863 SetConfig(config_);
864 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
865 aFile = fopen("/data/screen_capture/screen_capture_mic_open_close_open.pcm", "w+");
866 if (aFile == nullptr) {
867 cout << "aFile audio open failed, " << strerror(errno) << endl;
868 }
869
870 aFlag = 1;
871 vFlag = 1;
872 bool isMicrophone = true;
873 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
874 ASSERT_NE(nullptr, screenCaptureCb_);
875 screenCapture_->SetMicrophoneEnabled(isMicrophone);
876 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
877 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
878 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
879 sleep(5);
880 isMicrophone = false;
881 screenCapture_->SetMicrophoneEnabled(isMicrophone);
882 sleep(3);
883 isMicrophone = true;
884 screenCapture_->SetMicrophoneEnabled(isMicrophone);
885 sleep(3);
886 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
887 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
888 CloseFile();
889 }
890
891 /**
892 * @tc.name: screen_capture_mic_close_open_close
893 * @tc.desc: screen capture mic test
894 * @tc.type: FUNC
895 * @tc.require:
896 */
897 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_close_open_close, TestSize.Level2)
898 {
899 AVScreenCaptureConfig config_;
900 SetConfig(config_);
901 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
902 aFile = fopen("/data/screen_capture/screen_capture_mic_close_open_close.pcm", "w+");
903 if (aFile == nullptr) {
904 cout << "aFile audio open failed, " << strerror(errno) << endl;
905 }
906
907 aFlag = 1;
908 vFlag = 1;
909 bool isMicrophone = false;
910 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
911 ASSERT_NE(nullptr, screenCaptureCb_);
912 screenCapture_->SetMicrophoneEnabled(isMicrophone);
913 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
914 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
915 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
916 sleep(5);
917 isMicrophone = true;
918 screenCapture_->SetMicrophoneEnabled(isMicrophone);
919 sleep(3);
920 isMicrophone = false;
921 screenCapture_->SetMicrophoneEnabled(isMicrophone);
922 sleep(3);
923 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
924 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
925 CloseFile();
926 }
927
928 /**
929 * @tc.name: screen_capture_displayId
930 * @tc.desc: screen capture displayId test
931 * @tc.type: FUNC
932 * @tc.require:
933 */
934 HWTEST_F(ScreenCaptureUnitTest, screen_capture_displayId, TestSize.Level1)
935 {
936 AVScreenCaptureConfig config_;
937 SetConfig(config_);
938 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
939 config_.videoInfo.videoCapInfo.displayId = 10;
940 OpenFile("screen_capture_displayId");
941
942 aFlag = 1;
943 vFlag = 1;
944 bool isMicrophone = true;
945 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
946 ASSERT_NE(nullptr, screenCaptureCb_);
947 screenCapture_->SetMicrophoneEnabled(isMicrophone);
948 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
949 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
950 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
951 sleep(3);
952 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
953 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
954 CloseFile();
955 }
956
957 /**
958 * @tc.name: screen_capture_taskIDs
959 * @tc.desc: screen capture taskIDs test
960 * @tc.type: FUNC
961 * @tc.require:
962 */
963 HWTEST_F(ScreenCaptureUnitTest, screen_capture_taskIDs, TestSize.Level1)
964 {
965 AVScreenCaptureConfig config_;
966 SetConfig(config_);
967 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
968 int32_t num[] = { 111, 222, 333, 444, 555 };
969 list<int32_t> listInt_A(num, num + size(num));
970
971 (config_.videoInfo.videoCapInfo.taskIDs).assign(++listInt_A.begin(), --listInt_A.end());
972 cout << "taskIDs: ";
973 for (list<int>::iterator it = (config_.videoInfo.videoCapInfo.taskIDs).begin();
974 it != (config_.videoInfo.videoCapInfo.taskIDs).end(); it++)
975 {
976 cout << *it << " ";
977 }
978 cout << endl;
979 OpenFile("screen_capture_taskIDs");
980
981 aFlag = 1;
982 vFlag = 1;
983 bool isMicrophone = true;
984 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag);
985 ASSERT_NE(nullptr, screenCaptureCb_);
986 screenCapture_->SetMicrophoneEnabled(isMicrophone);
987 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
988 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
989 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
990 sleep(3);
991 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
992 EXPECT_EQ(MSERR_OK, screenCapture_->Release());
993 CloseFile();
994 }
995 } // namespace Media
996 } // namespace OHOS