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 "native_avscreen_capture.h"
17
18 #include <mutex>
19 #include <queue>
20 #include <shared_mutex>
21 #include <set>
22
23 #include "buffer/avbuffer.h"
24 #include "common/native_mfmagic.h"
25 #include "media_log.h"
26 #include "media_errors.h"
27 #include "native_avbuffer.h"
28 #include "native_player_magic.h"
29 #include "surface_buffer_impl.h"
30 #include "native_window.h"
31
32 namespace {
33 constexpr int MAX_WINDOWS_LEN = 1000;
34 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_SCREENCAPTURE, "NativeScreenCapture"};
35 }
36
37 typedef struct NativeWindow OHNativeWindow;
38
39 using namespace OHOS::Media;
40 static std::queue<OH_NativeBuffer*> referencedBuffer_;
41 class NativeScreenCaptureCallback;
42
43 struct ScreenCaptureObject : public OH_AVScreenCapture {
ScreenCaptureObjectScreenCaptureObject44 explicit ScreenCaptureObject(const std::shared_ptr<ScreenCapture> &capture)
45 : screenCapture_(capture) {}
46 ~ScreenCaptureObject() = default;
47
48 const std::shared_ptr<ScreenCapture> screenCapture_ = nullptr;
49 std::shared_ptr<NativeScreenCaptureCallback> callback_ = nullptr;
50 bool isStart = false;
51 };
52
53 class NativeScreenCaptureStateChangeCallback {
54 public:
NativeScreenCaptureStateChangeCallback(OH_AVScreenCapture_OnStateChange callback,void * userData)55 NativeScreenCaptureStateChangeCallback(OH_AVScreenCapture_OnStateChange callback, void *userData)
56 : callback_(callback), userData_(userData) {}
57 virtual ~NativeScreenCaptureStateChangeCallback() = default;
58
OnStateChange(struct OH_AVScreenCapture * capture,AVScreenCaptureStateCode infoType)59 void OnStateChange(struct OH_AVScreenCapture *capture, AVScreenCaptureStateCode infoType)
60 {
61 CHECK_AND_RETURN(capture != nullptr && callback_ != nullptr);
62 callback_(capture, static_cast<OH_AVScreenCaptureStateCode>(infoType), userData_);
63 }
64
65 private:
66 OH_AVScreenCapture_OnStateChange callback_;
67 void *userData_;
68 };
69
70 class NativeScreenCaptureDisplaySelectedCallback {
71 public:
NativeScreenCaptureDisplaySelectedCallback(OH_AVScreenCapture_OnDisplaySelected callback,void * userData)72 NativeScreenCaptureDisplaySelectedCallback(OH_AVScreenCapture_OnDisplaySelected callback, void *userData)
73 : callback_(callback), userData_(userData) {}
74 virtual ~NativeScreenCaptureDisplaySelectedCallback() = default;
75
OnDisplaySelected(struct OH_AVScreenCapture * capture,uint64_t displayId)76 void OnDisplaySelected(struct OH_AVScreenCapture *capture, uint64_t displayId)
77 {
78 CHECK_AND_RETURN(capture != nullptr && callback_ != nullptr);
79 callback_(capture, displayId, userData_);
80 }
81
82 private:
83 OH_AVScreenCapture_OnDisplaySelected callback_;
84 void *userData_;
85 };
86
87 class NativeScreenCaptureErrorCallback {
88 public:
NativeScreenCaptureErrorCallback(OH_AVScreenCapture_OnError callback,void * userData)89 NativeScreenCaptureErrorCallback(OH_AVScreenCapture_OnError callback, void *userData)
90 : callback_(callback), userData_(userData) {}
91 virtual ~NativeScreenCaptureErrorCallback() = default;
92
OnError(struct OH_AVScreenCapture * capture,int32_t errorCode)93 void OnError(struct OH_AVScreenCapture *capture, int32_t errorCode)
94 {
95 CHECK_AND_RETURN(capture != nullptr && callback_ != nullptr);
96 callback_(capture, errorCode, userData_);
97 }
98
99 private:
100 OH_AVScreenCapture_OnError callback_;
101 void *userData_;
102 };
103
104 class NativeScreenCaptureDataCallback {
105 public:
NativeScreenCaptureDataCallback(OH_AVScreenCapture_OnBufferAvailable callback,void * userData)106 NativeScreenCaptureDataCallback(OH_AVScreenCapture_OnBufferAvailable callback, void *userData)
107 : callback_(callback), userData_(userData) {}
108 virtual ~NativeScreenCaptureDataCallback() = default;
109
OnBufferAvailable(struct OH_AVScreenCapture * capture,OH_AVScreenCaptureBufferType bufferType)110 void OnBufferAvailable(struct OH_AVScreenCapture *capture, OH_AVScreenCaptureBufferType bufferType)
111 {
112 CHECK_AND_RETURN(capture != nullptr && callback_ != nullptr);
113 switch (bufferType) {
114 case OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_VIDEO:
115 OnProcessVideoBuffer(capture);
116 return;
117 case OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER: // fall-through
118 case OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC:
119 OnProcessAudioBuffer(capture, bufferType);
120 return;
121 default:
122 MEDIA_LOGD("OnBufferAvailable() is called, invalid bufferType:%{public}d", bufferType);
123 return;
124 }
125 }
126
127 private:
AcquireAudioBuffer(const std::shared_ptr<ScreenCapture> & screenCapture,OHOS::sptr<OH_AVBuffer> & ohAvBuffer,int64_t & timestamp,AudioCaptureSourceType type)128 static OH_AVSCREEN_CAPTURE_ErrCode AcquireAudioBuffer(const std::shared_ptr<ScreenCapture> &screenCapture,
129 OHOS::sptr<OH_AVBuffer> &ohAvBuffer, int64_t ×tamp, AudioCaptureSourceType type)
130 {
131 std::shared_ptr<AudioBuffer> aBuffer;
132 int32_t ret = screenCapture->AcquireAudioBuffer(aBuffer, type);
133 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
134 "AcquireAudioBuffer failed not permit! ret:%{public}d", ret);
135 CHECK_AND_RETURN_RET_LOG(aBuffer != nullptr && aBuffer->buffer != nullptr, AV_SCREEN_CAPTURE_ERR_NO_MEMORY,
136 "AcquireAudioBuffer failed aBuffer no memory!");
137 std::shared_ptr<AVBuffer> avBuffer = AVBuffer::CreateAVBuffer(aBuffer->buffer, aBuffer->length,
138 aBuffer->length);
139 CHECK_AND_RETURN_RET_LOG(avBuffer != nullptr, AV_SCREEN_CAPTURE_ERR_NO_MEMORY,
140 "AcquireAudioBuffer failed avBuffer no memory!");
141 aBuffer->buffer = nullptr; // memory control has transfered to AVBuffer
142 timestamp = aBuffer->timestamp;
143 ohAvBuffer = new(std::nothrow) OH_AVBuffer(avBuffer);
144
145 CHECK_AND_RETURN_RET_LOG(ohAvBuffer != nullptr, AV_SCREEN_CAPTURE_ERR_NO_MEMORY,
146 "AcquireAudioBuffer failed ohAvBuffer no memory!");
147 return AV_SCREEN_CAPTURE_ERR_OK;
148 }
149
ReleaseAudioBuffer(const std::shared_ptr<ScreenCapture> & screenCapture,AudioCaptureSourceType type)150 static OH_AVSCREEN_CAPTURE_ErrCode ReleaseAudioBuffer(const std::shared_ptr<ScreenCapture> &screenCapture,
151 AudioCaptureSourceType type)
152 {
153 int32_t ret = screenCapture->ReleaseAudioBuffer(type);
154 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
155 "ReleaseAudioBuffer failed! ret:%{public}d", ret);
156 return AV_SCREEN_CAPTURE_ERR_OK;
157 }
158
OnProcessAudioBuffer(struct OH_AVScreenCapture * capture,OH_AVScreenCaptureBufferType bufferType)159 OH_AVSCREEN_CAPTURE_ErrCode OnProcessAudioBuffer(struct OH_AVScreenCapture *capture,
160 OH_AVScreenCaptureBufferType bufferType)
161 {
162 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
163 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
164 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
165 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture is null");
166
167 MEDIA_LOGD("OnProcessAudioBuffer() is called, bufferType %{public}d", bufferType);
168 AudioCaptureSourceType audioSourceType;
169 if (bufferType == OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
170 audioSourceType = AudioCaptureSourceType::ALL_PLAYBACK;
171 } else if (bufferType == OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC) {
172 audioSourceType = AudioCaptureSourceType::MIC;
173 } else {
174 return AV_SCREEN_CAPTURE_ERR_INVALID_VAL;
175 }
176 OHOS::sptr<OH_AVBuffer> ohAvBuffer;
177 int64_t timestamp = 0;
178 OH_AVSCREEN_CAPTURE_ErrCode errCode =
179 AcquireAudioBuffer(screenCaptureObj->screenCapture_, ohAvBuffer, timestamp, audioSourceType);
180 if (errCode == AV_SCREEN_CAPTURE_ERR_OK) {
181 callback_(capture, reinterpret_cast<OH_AVBuffer *>(ohAvBuffer.GetRefPtr()), bufferType, timestamp,
182 userData_);
183 if (ohAvBuffer->buffer_->memory_ == nullptr) {
184 return AV_SCREEN_CAPTURE_ERR_INVALID_VAL;
185 }
186 free(ohAvBuffer->buffer_->memory_->GetAddr());
187 }
188 errCode = ReleaseAudioBuffer(screenCaptureObj->screenCapture_, audioSourceType);
189 return errCode;
190 }
AcquireVideoBuffer(const std::shared_ptr<ScreenCapture> & screenCapture,OHOS::sptr<OH_AVBuffer> & ohAvBuffer,int64_t & timestamp)191 static OH_AVSCREEN_CAPTURE_ErrCode AcquireVideoBuffer(const std::shared_ptr<ScreenCapture> &screenCapture,
192 OHOS::sptr<OH_AVBuffer> &ohAvBuffer, int64_t ×tamp)
193 {
194 int32_t fence = -1;
195 OHOS::Rect damage;
196 OHOS::sptr<OHOS::SurfaceBuffer> surfaceBuffer =
197 screenCapture->AcquireVideoBuffer(fence, timestamp, damage);
198 CHECK_AND_RETURN_RET_LOG(surfaceBuffer != nullptr, AV_SCREEN_CAPTURE_ERR_NO_MEMORY,
199 "AcquireVideoBuffer failed surfaceBuffer no memory!");
200 std::shared_ptr<AVBuffer> avBuffer = AVBuffer::CreateAVBuffer(surfaceBuffer);
201 CHECK_AND_RETURN_RET_LOG(avBuffer != nullptr && avBuffer->memory_ != nullptr, AV_SCREEN_CAPTURE_ERR_NO_MEMORY,
202 "AcquireVideoBuffer failed avBuffer no memory!");
203 MEDIA_LOGD("AcquireVideoBuffer Size %{public}d", static_cast<int32_t>(surfaceBuffer->GetSize()));
204 avBuffer->memory_->SetSize(static_cast<int32_t>(surfaceBuffer->GetSize()));
205 ohAvBuffer = new(std::nothrow) OH_AVBuffer(avBuffer);
206 CHECK_AND_RETURN_RET_LOG(ohAvBuffer != nullptr, AV_SCREEN_CAPTURE_ERR_NO_MEMORY,
207 "AcquireVideoBuffer failed ohAvBuffer no memory!");
208 return AV_SCREEN_CAPTURE_ERR_OK;
209 }
210
ReleaseVideoBuffer(const std::shared_ptr<ScreenCapture> & screenCapture)211 static OH_AVSCREEN_CAPTURE_ErrCode ReleaseVideoBuffer(const std::shared_ptr<ScreenCapture> &screenCapture)
212 {
213 int32_t ret = screenCapture->ReleaseVideoBuffer();
214 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
215 "ReleaseVideoBuffer failed! ret:%{public}d", ret);
216 return AV_SCREEN_CAPTURE_ERR_OK;
217 }
218
OnProcessVideoBuffer(struct OH_AVScreenCapture * capture)219 OH_AVSCREEN_CAPTURE_ErrCode OnProcessVideoBuffer(struct OH_AVScreenCapture *capture)
220 {
221 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
222 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
223 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
224 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture is null");
225
226 OHOS::sptr<OH_AVBuffer> hoAvBuffer;
227 int64_t timestamp = 0;
228 OH_AVSCREEN_CAPTURE_ErrCode errCode =
229 AcquireVideoBuffer(screenCaptureObj->screenCapture_, hoAvBuffer, timestamp);
230 if (errCode == AV_SCREEN_CAPTURE_ERR_OK) {
231 callback_(capture, reinterpret_cast<OH_AVBuffer *>(hoAvBuffer.GetRefPtr()),
232 OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_VIDEO, timestamp, userData_);
233 }
234 errCode = ReleaseVideoBuffer(screenCaptureObj->screenCapture_);
235 return errCode;
236 }
237
238 private:
239 OH_AVScreenCapture_OnBufferAvailable callback_;
240 void *userData_;
241 };
242
243 class NativeScreenCaptureCallback : public ScreenCaptureCallBack {
244 public:
NativeScreenCaptureCallback(struct OH_AVScreenCapture * capture,struct OH_AVScreenCaptureCallback callback)245 NativeScreenCaptureCallback(struct OH_AVScreenCapture *capture, struct OH_AVScreenCaptureCallback callback)
246 : capture_(capture), callback_(callback) {}
247 virtual ~NativeScreenCaptureCallback() = default;
248
OnError(ScreenCaptureErrorType errorType,int32_t errorCode)249 void OnError(ScreenCaptureErrorType errorType, int32_t errorCode) override
250 {
251 MEDIA_LOGE("OnError() is called, errorType %{public}d, errorCode %{public}d", errorType, errorCode);
252 std::shared_lock<std::shared_mutex> lock(mutex_);
253 CHECK_AND_RETURN(capture_ != nullptr);
254
255 if (errorCallback_ != nullptr) {
256 errorCallback_->OnError(capture_, errorCode);
257 return;
258 }
259
260 if (callback_.onError != nullptr) {
261 callback_.onError(capture_, errorCode);
262 return;
263 }
264 }
265
OnStateChange(AVScreenCaptureStateCode stateCode)266 void OnStateChange(AVScreenCaptureStateCode stateCode) override
267 {
268 MEDIA_LOGI("OnStateChange() is called, stateCode %{public}d", stateCode);
269 std::shared_lock<std::shared_mutex> lock(mutex_);
270 CHECK_AND_RETURN(capture_ != nullptr);
271
272 if (stateChangeCallback_ != nullptr) {
273 stateChangeCallback_->OnStateChange(capture_, stateCode);
274 return;
275 }
276 }
277
OnDisplaySelected(uint64_t displayId)278 void OnDisplaySelected(uint64_t displayId) override
279 {
280 MEDIA_LOGI("OnDisplaySelected() is called, displayId (%{public}" PRIu64 ")", displayId);
281 std::shared_lock<std::shared_mutex> lock(mutex_);
282 CHECK_AND_RETURN(capture_ != nullptr);
283
284 if (displaySelectedCallback_ != nullptr) {
285 displaySelectedCallback_->OnDisplaySelected(capture_, displayId);
286 return;
287 }
288 }
289
OnAudioBufferAvailable(bool isReady,AudioCaptureSourceType type)290 void OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type) override
291 {
292 MEDIA_LOGD("OnAudioBufferAvailable() is called, isReady:%{public}d, type:%{public}d", isReady, type);
293 std::shared_lock<std::shared_mutex> lock(mutex_);
294 CHECK_AND_RETURN(capture_ != nullptr);
295
296 if (dataCallback_ != nullptr) {
297 if (!isReady) {
298 MEDIA_LOGD("OnAudioBufferAvailable not ready");
299 return;
300 }
301 if (type == AudioCaptureSourceType::SOURCE_DEFAULT || type == AudioCaptureSourceType::MIC) {
302 dataCallback_->OnBufferAvailable(capture_,
303 OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
304 } else if (type == AudioCaptureSourceType::ALL_PLAYBACK || type == AudioCaptureSourceType::APP_PLAYBACK) {
305 dataCallback_->OnBufferAvailable(capture_,
306 OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
307 } else {
308 MEDIA_LOGD("OnAudioBufferAvailable() is called, invalid audio source type:%{public}d", type);
309 }
310 MEDIA_LOGD("OnAudioBufferAvailable finished");
311 return;
312 }
313 if (callback_.onAudioBufferAvailable != nullptr) {
314 callback_.onAudioBufferAvailable(capture_, isReady, static_cast<OH_AudioCaptureSourceType>(type));
315 MEDIA_LOGD("OnAudioBufferAvailable finished");
316 return;
317 }
318 MEDIA_LOGD("OnAudioBufferAvailable finished");
319 }
320
OnVideoBufferAvailable(bool isReady)321 void OnVideoBufferAvailable(bool isReady) override
322 {
323 MEDIA_LOGD("OnVideoBufferAvailable() is called, isReady:%{public}d", isReady);
324 std::shared_lock<std::shared_mutex> lock(mutex_);
325 CHECK_AND_RETURN(capture_ != nullptr);
326
327 if (dataCallback_ != nullptr) {
328 if (!isReady) {
329 MEDIA_LOGD("OnVideoBufferAvailable not ready");
330 return;
331 }
332 dataCallback_->OnBufferAvailable(capture_,
333 OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
334 MEDIA_LOGD("OnVideoBufferAvailable finished");
335 return;
336 }
337 if (capture_ != nullptr && callback_.onVideoBufferAvailable != nullptr) {
338 callback_.onVideoBufferAvailable(capture_, isReady);
339 }
340 MEDIA_LOGD("OnVideoBufferAvailable finished");
341 }
342
StopCallback()343 void StopCallback()
344 {
345 std::unique_lock<std::shared_mutex> lock(mutex_);
346 capture_ = nullptr;
347 }
348
SetCallback(struct OH_AVScreenCaptureCallback callback)349 void SetCallback(struct OH_AVScreenCaptureCallback callback)
350 {
351 std::unique_lock<std::shared_mutex> lock(mutex_);
352 callback_ = callback;
353 }
354
IsDataCallbackEnabled()355 bool IsDataCallbackEnabled()
356 {
357 return dataCallback_ != nullptr;
358 }
359
IsStateChangeCallbackEnabled()360 bool IsStateChangeCallbackEnabled()
361 {
362 return stateChangeCallback_ != nullptr;
363 }
364
SetStateChangeCallback(OH_AVScreenCapture_OnStateChange callback,void * userData)365 bool SetStateChangeCallback(OH_AVScreenCapture_OnStateChange callback, void *userData)
366 {
367 std::unique_lock<std::shared_mutex> lock(mutex_);
368 stateChangeCallback_ = std::make_shared<NativeScreenCaptureStateChangeCallback>(callback, userData);
369 return stateChangeCallback_ != nullptr;
370 }
371
SetErrorCallback(OH_AVScreenCapture_OnError callback,void * userData)372 bool SetErrorCallback(OH_AVScreenCapture_OnError callback, void *userData)
373 {
374 std::unique_lock<std::shared_mutex> lock(mutex_);
375 errorCallback_ = std::make_shared<NativeScreenCaptureErrorCallback>(callback, userData);
376 return errorCallback_ != nullptr;
377 }
378
SetDataCallback(OH_AVScreenCapture_OnBufferAvailable callback,void * userData)379 bool SetDataCallback(OH_AVScreenCapture_OnBufferAvailable callback, void *userData)
380 {
381 std::unique_lock<std::shared_mutex> lock(mutex_);
382 dataCallback_ = std::make_shared<NativeScreenCaptureDataCallback>(callback, userData);
383 return dataCallback_ != nullptr;
384 }
385
SetDisplayCallback(OH_AVScreenCapture_OnDisplaySelected callback,void * userData)386 bool SetDisplayCallback(OH_AVScreenCapture_OnDisplaySelected callback, void *userData)
387 {
388 std::unique_lock<std::shared_mutex> lock(mutex_);
389 displaySelectedCallback_ = std::make_shared<NativeScreenCaptureDisplaySelectedCallback>(callback, userData);
390 return displaySelectedCallback_ != nullptr;
391 }
392
393 private:
394 std::shared_mutex mutex_;
395 struct OH_AVScreenCapture *capture_ = nullptr;
396 struct OH_AVScreenCaptureCallback callback_;
397 std::shared_ptr<NativeScreenCaptureStateChangeCallback> stateChangeCallback_ = nullptr;
398 std::shared_ptr<NativeScreenCaptureErrorCallback> errorCallback_ = nullptr;
399 std::shared_ptr<NativeScreenCaptureDataCallback> dataCallback_ = nullptr;
400 std::shared_ptr<NativeScreenCaptureDisplaySelectedCallback> displaySelectedCallback_ = nullptr;
401 };
402
403 struct ScreenCaptureContentFilterObject : public OH_AVScreenCapture_ContentFilter {
404 ScreenCaptureContentFilterObject() = default;
405 ~ScreenCaptureContentFilterObject() = default;
406
407 ScreenCaptureContentFilter screenCaptureContentFilter;
408 };
409
OH_AVScreenCapture_CreateContentFilter(void)410 struct OH_AVScreenCapture_ContentFilter *OH_AVScreenCapture_CreateContentFilter(void)
411 {
412 struct ScreenCaptureContentFilterObject *object = new(std::nothrow) ScreenCaptureContentFilterObject();
413 CHECK_AND_RETURN_RET_LOG(object != nullptr, nullptr, "failed to new ScreenCaptureContentFilterObject");
414 return object;
415 }
416
OH_AVScreenCapture_ReleaseContentFilter(struct OH_AVScreenCapture_ContentFilter * filter)417 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ReleaseContentFilter(struct OH_AVScreenCapture_ContentFilter *filter)
418 {
419 CHECK_AND_RETURN_RET_LOG(filter != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input filter is nullptr!");
420 struct ScreenCaptureContentFilterObject *contentFilterObj =
421 reinterpret_cast<ScreenCaptureContentFilterObject *>(filter);
422 delete contentFilterObj;
423 return AV_SCREEN_CAPTURE_ERR_OK;
424 }
425
OH_AVScreenCapture_ContentFilter_AddAudioContent(struct OH_AVScreenCapture_ContentFilter * filter,OH_AVScreenCaptureFilterableAudioContent content)426 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ContentFilter_AddAudioContent(
427 struct OH_AVScreenCapture_ContentFilter *filter, OH_AVScreenCaptureFilterableAudioContent content)
428 {
429 CHECK_AND_RETURN_RET_LOG(filter != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input filter is nullptr!");
430 struct ScreenCaptureContentFilterObject *contentFilterObj =
431 reinterpret_cast<ScreenCaptureContentFilterObject *>(filter);
432
433 CHECK_AND_RETURN_RET_LOG(
434 content >= OH_AVScreenCaptureFilterableAudioContent::OH_SCREEN_CAPTURE_NOTIFICATION_AUDIO ||
435 content <= OH_AVScreenCaptureFilterableAudioContent::OH_SCREEN_CAPTURE_CURRENT_APP_AUDIO,
436 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input content invalid!");
437 contentFilterObj->screenCaptureContentFilter.filteredAudioContents.insert(
438 static_cast<AVScreenCaptureFilterableAudioContent>(content));
439 return AV_SCREEN_CAPTURE_ERR_OK;
440 }
441
OH_AVScreenCapture_ExcludeContent(struct OH_AVScreenCapture * capture,struct OH_AVScreenCapture_ContentFilter * filter)442 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ExcludeContent(struct OH_AVScreenCapture *capture,
443 struct OH_AVScreenCapture_ContentFilter *filter)
444 {
445 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
446 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
447 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
448 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture is null");
449
450 CHECK_AND_RETURN_RET_LOG(filter != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input filter is nullptr!");
451 struct ScreenCaptureContentFilterObject *contentFilterObj =
452 reinterpret_cast<ScreenCaptureContentFilterObject *>(filter);
453
454 int32_t ret = screenCaptureObj->screenCapture_->ExcludeContent(contentFilterObj->screenCaptureContentFilter);
455 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_UNSUPPORT, "StartScreenCapture failed!");
456 return AV_SCREEN_CAPTURE_ERR_OK;
457 }
458
OH_AVScreenCapture_Create(void)459 struct OH_AVScreenCapture *OH_AVScreenCapture_Create(void)
460 {
461 std::shared_ptr<ScreenCapture> screenCapture = ScreenCaptureFactory::CreateScreenCapture();
462 CHECK_AND_RETURN_RET_LOG(screenCapture != nullptr, nullptr, "failed to ScreenCaptureFactory::CreateScreenCapture");
463
464 struct ScreenCaptureObject *object = new(std::nothrow) ScreenCaptureObject(screenCapture);
465 CHECK_AND_RETURN_RET_LOG(object != nullptr, nullptr, "failed to new ScreenCaptureObject");
466
467 return object;
468 }
469
OH_AVScreenCapture_Convert(OH_AVScreenCaptureConfig config)470 AVScreenCaptureConfig OH_AVScreenCapture_Convert(OH_AVScreenCaptureConfig config)
471 {
472 AVScreenCaptureConfig config_;
473 config_.captureMode = static_cast<CaptureMode>(config.captureMode);
474 config_.dataType = static_cast<DataType>(config.dataType);
475 config_.audioInfo.micCapInfo = {
476 .audioSampleRate = config.audioInfo.micCapInfo.audioSampleRate,
477 .audioChannels = config.audioInfo.micCapInfo.audioChannels,
478 .audioSource = static_cast<AudioCaptureSourceType>(config.audioInfo.micCapInfo.audioSource)
479 };
480 config_.audioInfo.innerCapInfo = {
481 .audioSampleRate = config.audioInfo.innerCapInfo.audioSampleRate,
482 .audioChannels = config.audioInfo.innerCapInfo.audioChannels,
483 .audioSource = static_cast<AudioCaptureSourceType>(config.audioInfo.innerCapInfo.audioSource)
484 };
485 config_.audioInfo.audioEncInfo.audioBitrate = config.audioInfo.audioEncInfo.audioBitrate;
486 config_.audioInfo.audioEncInfo.audioCodecformat =
487 static_cast<AudioCodecFormat>(config.audioInfo.audioEncInfo.audioCodecformat);
488 config_.videoInfo.videoCapInfo.displayId = config.videoInfo.videoCapInfo.displayId;
489 int32_t *taskIds = config.videoInfo.videoCapInfo.missionIDs;
490 int32_t size = config.videoInfo.videoCapInfo.missionIDsLen;
491 size = size >= MAX_WINDOWS_LEN ? MAX_WINDOWS_LEN : size;
492 while (size > 0) {
493 if (taskIds == nullptr) {
494 break;
495 }
496 config_.videoInfo.videoCapInfo.taskIDs.push_back(*(taskIds));
497 taskIds++;
498 size--;
499 }
500 config_.videoInfo.videoCapInfo.videoFrameWidth = config.videoInfo.videoCapInfo.videoFrameWidth;
501 config_.videoInfo.videoCapInfo.videoFrameHeight = config.videoInfo.videoCapInfo.videoFrameHeight;
502 config_.videoInfo.videoCapInfo.videoSource =
503 static_cast<VideoSourceType>(config.videoInfo.videoCapInfo.videoSource);
504 config_.videoInfo.videoEncInfo = {
505 .videoCodec = static_cast<VideoCodecFormat>(config.videoInfo.videoEncInfo.videoCodec ==
506 OH_VideoCodecFormat::OH_VIDEO_DEFAULT ?
507 OH_VideoCodecFormat::OH_H264 : config.videoInfo.videoEncInfo.videoCodec),
508 .videoBitrate = config.videoInfo.videoEncInfo. videoBitrate,
509 .videoFrameRate = config.videoInfo.videoEncInfo.videoFrameRate
510 };
511 if (config.recorderInfo.url != nullptr) {
512 config_.recorderInfo.url = config.recorderInfo.url;
513 }
514 if (config.recorderInfo.fileFormat == CFT_MPEG_4A) {
515 config_.recorderInfo.fileFormat = ContainerFormatType::CFT_MPEG_4A;
516 } else if (config.recorderInfo.fileFormat == CFT_MPEG_4) {
517 config_.recorderInfo.fileFormat = ContainerFormatType::CFT_MPEG_4;
518 }
519 return config_;
520 }
521
OH_AVScreenCapture_Init(struct OH_AVScreenCapture * capture,OH_AVScreenCaptureConfig config)522 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_Init(struct OH_AVScreenCapture *capture, OH_AVScreenCaptureConfig config)
523 {
524 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
525
526 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
527 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
528 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
529
530 AVScreenCaptureConfig config_ = OH_AVScreenCapture_Convert(config);
531 int32_t ret = screenCaptureObj->screenCapture_->Init(config_);
532 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "screenCapture init failed!");
533
534 return AV_SCREEN_CAPTURE_ERR_OK;
535 }
536
SetPrivacyAuthorityEnabled(struct ScreenCaptureObject * screenCaptureObj)537 static int32_t SetPrivacyAuthorityEnabled(struct ScreenCaptureObject *screenCaptureObj)
538 {
539 if (screenCaptureObj->callback_ != nullptr && screenCaptureObj->callback_->IsStateChangeCallbackEnabled()) {
540 int32_t ret = screenCaptureObj->screenCapture_->SetPrivacyAuthorityEnabled();
541 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPrivacyAuthorityEnabled failed!");
542 }
543 return MSERR_OK;
544 }
545
OH_AVScreenCapture_StartScreenCapture(struct OH_AVScreenCapture * capture)546 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_StartScreenCapture(struct OH_AVScreenCapture *capture)
547 {
548 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
549
550 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
551 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
552 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
553
554 int32_t ret = SetPrivacyAuthorityEnabled(screenCaptureObj);
555 CHECK_AND_RETURN_RET(ret == AV_SCREEN_CAPTURE_ERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT);
556 ret = screenCaptureObj->screenCapture_->StartScreenCapture();
557 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "StartScreenCapture failed!");
558 screenCaptureObj->isStart = true;
559 return AV_SCREEN_CAPTURE_ERR_OK;
560 }
561
OH_AVScreenCapture_StartScreenCaptureWithSurface(struct OH_AVScreenCapture * capture,OHNativeWindow * window)562 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_StartScreenCaptureWithSurface(struct OH_AVScreenCapture *capture,
563 OHNativeWindow* window)
564 {
565 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
566 CHECK_AND_RETURN_RET_LOG(window != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input window is nullptr!");
567 CHECK_AND_RETURN_RET_LOG(window->surface != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL,
568 "Input window surface is nullptr!");
569
570 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
571 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
572 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
573
574 int32_t ret = SetPrivacyAuthorityEnabled(screenCaptureObj);
575 CHECK_AND_RETURN_RET(ret == AV_SCREEN_CAPTURE_ERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT);
576 ret = screenCaptureObj->screenCapture_->StartScreenCaptureWithSurface(window->surface);
577 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "StartScreenCapture failed!");
578 screenCaptureObj->isStart = true;
579 return AV_SCREEN_CAPTURE_ERR_OK;
580 }
581
OH_AVScreenCapture_StopScreenCapture(struct OH_AVScreenCapture * capture)582 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_StopScreenCapture(struct OH_AVScreenCapture *capture)
583 {
584 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
585
586 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
587 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
588 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
589
590 int32_t ret = screenCaptureObj->screenCapture_->StopScreenCapture();
591 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "StopScreenCapture failed!");
592 screenCaptureObj->isStart = false;
593 return AV_SCREEN_CAPTURE_ERR_OK;
594 }
595
OH_AVScreenCapture_StartScreenRecording(struct OH_AVScreenCapture * capture)596 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_StartScreenRecording(struct OH_AVScreenCapture *capture)
597 {
598 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
599
600 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
601 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
602 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
603
604 int32_t ret = SetPrivacyAuthorityEnabled(screenCaptureObj);
605 CHECK_AND_RETURN_RET(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT);
606 ret = screenCaptureObj->screenCapture_->StartScreenRecording();
607 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "StartScreenRecording failed!");
608 screenCaptureObj->isStart = true;
609 return AV_SCREEN_CAPTURE_ERR_OK;
610 }
611
OH_AVScreenCapture_StopScreenRecording(struct OH_AVScreenCapture * capture)612 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_StopScreenRecording(struct OH_AVScreenCapture *capture)
613 {
614 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
615
616 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
617 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
618 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
619
620 int32_t ret = screenCaptureObj->screenCapture_->StopScreenRecording();
621 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "StopScreenRecording failed!");
622 screenCaptureObj->isStart = false;
623 return AV_SCREEN_CAPTURE_ERR_OK;
624 }
625
OH_AVScreenCapture_AcquireAudioBuffer(struct OH_AVScreenCapture * capture,OH_AudioBuffer ** audiobuffer,OH_AudioCaptureSourceType type)626 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_AcquireAudioBuffer(struct OH_AVScreenCapture *capture,
627 OH_AudioBuffer **audiobuffer, OH_AudioCaptureSourceType type)
628 {
629 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
630 CHECK_AND_RETURN_RET_LOG(audiobuffer != nullptr && (*audiobuffer != nullptr), AV_SCREEN_CAPTURE_ERR_INVALID_VAL,
631 "input OH_AudioBuffer **audiobuffer is nullptr!");
632
633 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
634 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
635 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
636
637 if (screenCaptureObj->callback_ != nullptr && screenCaptureObj->callback_->IsDataCallbackEnabled()) {
638 MEDIA_LOGE("AcquireAudioBuffer() not permit for has set DataCallback");
639 return AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT;
640 }
641 std::shared_ptr<AudioBuffer> aBuffer;
642 int32_t ret =
643 screenCaptureObj->screenCapture_->AcquireAudioBuffer(aBuffer, static_cast<AudioCaptureSourceType>(type));
644 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "AcquireAudioBuffer failed!");
645 if ((aBuffer == nullptr) || (audiobuffer == nullptr)) {
646 return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
647 }
648 if (aBuffer->buffer != nullptr) {
649 (*audiobuffer)->buf = std::move(aBuffer->buffer);
650 aBuffer->buffer = nullptr;
651 }
652 (*audiobuffer)->size = aBuffer->length;
653 (*audiobuffer)->timestamp = aBuffer->timestamp;
654 (*audiobuffer)->type = static_cast<OH_AudioCaptureSourceType>(aBuffer->sourcetype);
655 return AV_SCREEN_CAPTURE_ERR_OK;
656 }
657
OH_AVScreenCapture_AcquireVideoBuffer(struct OH_AVScreenCapture * capture,int32_t * fence,int64_t * timestamp,struct OH_Rect * region)658 OH_NativeBuffer* OH_AVScreenCapture_AcquireVideoBuffer(struct OH_AVScreenCapture *capture,
659 int32_t *fence, int64_t *timestamp, struct OH_Rect *region)
660 {
661 CHECK_AND_RETURN_RET_LOG(capture != nullptr, nullptr, "input capture is nullptr!");
662
663 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
664 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr, nullptr, "screenCapture_ is null");
665
666 if (screenCaptureObj->callback_ != nullptr && screenCaptureObj->callback_->IsDataCallbackEnabled()) {
667 MEDIA_LOGE("AcquireVideoBuffer() not permit for has set DataCallback");
668 return nullptr;
669 }
670 OHOS::Rect damage;
671 OHOS::sptr<OHOS::SurfaceBuffer> sufacebuffer =
672 screenCaptureObj->screenCapture_->AcquireVideoBuffer(*fence, *timestamp, damage);
673 region->x = damage.x;
674 region->y = damage.y;
675 region->width = damage.w;
676 region->height = damage.h;
677 CHECK_AND_RETURN_RET_LOG(sufacebuffer != nullptr, nullptr, "AcquireVideoBuffer failed!");
678
679 OH_NativeBuffer* nativebuffer = sufacebuffer->SurfaceBufferToNativeBuffer();
680 OH_NativeBuffer_Reference(nativebuffer);
681 referencedBuffer_.push(nativebuffer);
682 MEDIA_LOGD("return and reference the nativebuffer");
683
684 return nativebuffer;
685 }
686
OH_AVScreenCapture_ReleaseVideoBuffer(struct OH_AVScreenCapture * capture)687 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ReleaseVideoBuffer(struct OH_AVScreenCapture *capture)
688 {
689 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
690
691 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
692 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
693 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
694
695 if (screenCaptureObj->callback_ != nullptr && screenCaptureObj->callback_->IsDataCallbackEnabled()) {
696 MEDIA_LOGE("ReleaseVideoBuffer() not permit for has set DataCallback");
697 return AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT;
698 }
699
700 if (!referencedBuffer_.empty()) {
701 OH_NativeBuffer* nativebuffer = referencedBuffer_.front();
702 OH_NativeBuffer_Unreference(nativebuffer);
703 referencedBuffer_.pop();
704 MEDIA_LOGD("unreference the front nativebuffer");
705 }
706
707 int32_t ret = screenCaptureObj->screenCapture_->ReleaseVideoBuffer();
708 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "ReleaseVideoBuffer failed!");
709
710 return AV_SCREEN_CAPTURE_ERR_OK;
711 }
712
OH_AVScreenCapture_ReleaseAudioBuffer(struct OH_AVScreenCapture * capture,OH_AudioCaptureSourceType type)713 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ReleaseAudioBuffer(struct OH_AVScreenCapture *capture,
714 OH_AudioCaptureSourceType type)
715 {
716 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
717
718 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
719 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
720 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
721
722 if (screenCaptureObj->callback_ != nullptr && screenCaptureObj->callback_->IsDataCallbackEnabled()) {
723 MEDIA_LOGE("ReleaseAudioBuffer() not permit for has set DataCallback");
724 return AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT;
725 }
726 int32_t ret = screenCaptureObj->screenCapture_->ReleaseAudioBuffer(static_cast<AudioCaptureSourceType>(type));
727 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "ReleaseSurfaceBuffer failed!");
728
729 return AV_SCREEN_CAPTURE_ERR_OK;
730 }
731
OH_AVScreenCapture_SetCallback(struct OH_AVScreenCapture * capture,struct OH_AVScreenCaptureCallback callback)732 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetCallback(struct OH_AVScreenCapture *capture,
733 struct OH_AVScreenCaptureCallback callback)
734 {
735 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
736
737 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
738 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
739 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
740
741 if (screenCaptureObj->callback_ == nullptr) {
742 screenCaptureObj->callback_ = std::make_shared<NativeScreenCaptureCallback>(capture, callback);
743 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->callback_ != nullptr,
744 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "callback_ is nullptr!");
745 } else {
746 screenCaptureObj->callback_->SetCallback(callback);
747 }
748
749 int32_t ret = screenCaptureObj->screenCapture_->SetScreenCaptureCallback(screenCaptureObj->callback_);
750 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
751 "SetScreenCaptureCallback failed!");
752 return AV_SCREEN_CAPTURE_ERR_OK;
753 }
754
OH_AVScreenCapture_Release(struct OH_AVScreenCapture * capture)755 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_Release(struct OH_AVScreenCapture *capture)
756 {
757 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
758
759 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
760
761 if (screenCaptureObj != nullptr && screenCaptureObj->screenCapture_ != nullptr) {
762 if (screenCaptureObj->callback_ != nullptr) {
763 screenCaptureObj->callback_->StopCallback();
764 }
765 int32_t ret = screenCaptureObj->screenCapture_->Release();
766 if (ret != MSERR_OK) {
767 MEDIA_LOGE("screen capture Release failed!");
768 capture = nullptr;
769 return AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT;
770 }
771 } else {
772 MEDIA_LOGD("screen capture is nullptr!");
773 }
774
775 delete capture;
776 return AV_SCREEN_CAPTURE_ERR_OK;
777 }
778
OH_AVScreenCapture_SetMicrophoneEnabled(struct OH_AVScreenCapture * capture,bool isMicrophone)779 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetMicrophoneEnabled(struct OH_AVScreenCapture *capture,
780 bool isMicrophone)
781 {
782 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
783
784 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
785 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
786 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
787
788 int32_t ret = screenCaptureObj->screenCapture_->SetMicrophoneEnabled(isMicrophone);
789 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT, "setMicrophoneEnable failed!");
790
791 return AV_SCREEN_CAPTURE_ERR_OK;
792 }
793
AVScreenCaptureSetCallback(struct OH_AVScreenCapture * capture,struct ScreenCaptureObject * screenCaptureObj)794 static OH_AVSCREEN_CAPTURE_ErrCode AVScreenCaptureSetCallback(struct OH_AVScreenCapture *capture,
795 struct ScreenCaptureObject *screenCaptureObj)
796 {
797 MEDIA_LOGD("AVScreenCaptureSetCallback S");
798 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
799 CHECK_AND_RETURN_RET_LOG(screenCaptureObj != nullptr && screenCaptureObj->screenCapture_ != nullptr,
800 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is nullptr!");
801 if (screenCaptureObj->callback_ == nullptr) {
802 MEDIA_LOGD("AVScreenCaptureSetCallback new NativeScreenCaptureCallback");
803 OH_AVScreenCaptureCallback dummyCallback = {
804 .onError = nullptr,
805 .onAudioBufferAvailable = nullptr,
806 .onVideoBufferAvailable = nullptr
807 };
808 screenCaptureObj->callback_ = std::make_shared<NativeScreenCaptureCallback>(capture, dummyCallback);
809 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->callback_ != nullptr,
810 AV_SCREEN_CAPTURE_ERR_NO_MEMORY, "callback_ is nullptr!");
811
812 int32_t ret = screenCaptureObj->screenCapture_->SetScreenCaptureCallback(screenCaptureObj->callback_);
813 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
814 "SetScreenCaptureCallback failed!");
815 }
816 MEDIA_LOGD("AVScreenCaptureSetCallback E");
817 return AV_SCREEN_CAPTURE_ERR_OK;
818 }
819
OH_AVScreenCapture_SetStateCallback(struct OH_AVScreenCapture * capture,OH_AVScreenCapture_OnStateChange callback,void * userData)820 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetStateCallback(struct OH_AVScreenCapture *capture,
821 OH_AVScreenCapture_OnStateChange callback, void *userData)
822 {
823 MEDIA_LOGD("OH_AVScreenCapture_SetStateCallback S");
824 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
825 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input stateCallback is nullptr!");
826 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
827 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
828 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
829
830 OH_AVSCREEN_CAPTURE_ErrCode errCode = AVScreenCaptureSetCallback(capture, screenCaptureObj);
831 CHECK_AND_RETURN_RET_LOG(errCode == AV_SCREEN_CAPTURE_ERR_OK, errCode, "SetStateCallback is null");
832
833 if (screenCaptureObj->callback_ == nullptr ||
834 !screenCaptureObj->callback_->SetStateChangeCallback(callback, userData)) {
835 MEDIA_LOGE("OH_AVScreenCapture_SetStateCallback error");
836 return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
837 }
838 MEDIA_LOGD("OH_AVScreenCapture_SetStateCallback E");
839 return AV_SCREEN_CAPTURE_ERR_OK;
840 }
841
OH_AVScreenCapture_SetErrorCallback(struct OH_AVScreenCapture * capture,OH_AVScreenCapture_OnError callback,void * userData)842 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetErrorCallback(struct OH_AVScreenCapture *capture,
843 OH_AVScreenCapture_OnError callback, void *userData)
844 {
845 MEDIA_LOGD("OH_AVScreenCapture_SetErrorCallback S");
846 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
847 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input errorCallback is nullptr!");
848 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
849 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
850 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
851
852 OH_AVSCREEN_CAPTURE_ErrCode errCode = AVScreenCaptureSetCallback(capture, screenCaptureObj);
853 CHECK_AND_RETURN_RET_LOG(errCode == AV_SCREEN_CAPTURE_ERR_OK, errCode, "SetErrorCallback is null");
854
855 if (screenCaptureObj->callback_ == nullptr || !screenCaptureObj->callback_->SetErrorCallback(callback, userData)) {
856 MEDIA_LOGE("OH_AVScreenCapture_SetErrorCallback error");
857 return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
858 }
859 MEDIA_LOGD("OH_AVScreenCapture_SetErrorCallback E");
860 return AV_SCREEN_CAPTURE_ERR_OK;
861 }
862
OH_AVScreenCapture_SetDataCallback(struct OH_AVScreenCapture * capture,OH_AVScreenCapture_OnBufferAvailable callback,void * userData)863 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetDataCallback(struct OH_AVScreenCapture *capture,
864 OH_AVScreenCapture_OnBufferAvailable callback, void *userData)
865 {
866 MEDIA_LOGD("OH_AVScreenCapture_SetDataCallback E");
867 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
868 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input dataCallback is nullptr!");
869 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
870 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
871 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
872
873 OH_AVSCREEN_CAPTURE_ErrCode errCode = AVScreenCaptureSetCallback(capture, screenCaptureObj);
874 CHECK_AND_RETURN_RET_LOG(errCode == AV_SCREEN_CAPTURE_ERR_OK, errCode, "SetDataCallback is null");
875
876 if (screenCaptureObj->callback_ == nullptr ||
877 !screenCaptureObj->callback_->SetDataCallback(callback, userData)) {
878 MEDIA_LOGE("OH_AVScreenCapture_SetDataCallback error");
879 return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
880 }
881 MEDIA_LOGD("OH_AVScreenCapture_SetDataCallback E");
882 return AV_SCREEN_CAPTURE_ERR_OK;
883 }
884
OH_AVScreenCapture_SetCanvasRotation(struct OH_AVScreenCapture * capture,bool canvasRotation)885 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetCanvasRotation(struct OH_AVScreenCapture *capture,
886 bool canvasRotation)
887 {
888 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
889
890 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
891 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
892 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
893
894 int32_t ret = screenCaptureObj->screenCapture_->SetCanvasRotation(canvasRotation);
895 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
896 "SetCanvasRotation failed!");
897
898 return AV_SCREEN_CAPTURE_ERR_OK;
899 }
900
OH_AVScreenCapture_ShowCursor(struct OH_AVScreenCapture * capture,bool showCursor)901 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ShowCursor(struct OH_AVScreenCapture *capture,
902 bool showCursor)
903 {
904 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
905
906 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
907 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
908 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
909 int32_t ret = screenCaptureObj->screenCapture_->ShowCursor(showCursor);
910 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
911 "ShowCursor failed!");
912
913 return AV_SCREEN_CAPTURE_ERR_OK;
914 }
915
OH_AVScreenCapture_ContentFilter_AddWindowContent(struct OH_AVScreenCapture_ContentFilter * filter,int32_t * windowIDs,int32_t windowCount)916 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ContentFilter_AddWindowContent(
917 struct OH_AVScreenCapture_ContentFilter *filter, int32_t *windowIDs, int32_t windowCount)
918 {
919 CHECK_AND_RETURN_RET_LOG(filter != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input filter is nullptr!");
920 struct ScreenCaptureContentFilterObject *contentFilterObj =
921 reinterpret_cast<ScreenCaptureContentFilterObject *>(filter);
922 CHECK_AND_RETURN_RET_LOG(windowIDs != nullptr && windowCount > 0 && windowCount < MAX_WINDOWS_LEN,
923 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input window invalid!");
924 std::vector<uint64_t> vec;
925 for (int32_t i = 0; i < windowCount; i++) {
926 if (static_cast<int32_t>(*(windowIDs + i)) >= 0) {
927 vec.push_back(static_cast<uint64_t>(*(windowIDs + i)));
928 }
929 }
930 contentFilterObj->screenCaptureContentFilter.windowIDsVec = vec;
931 return AV_SCREEN_CAPTURE_ERR_OK;
932 }
933
OH_AVScreenCapture_ResizeCanvas(struct OH_AVScreenCapture * capture,int32_t width,int32_t height)934 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_ResizeCanvas(struct OH_AVScreenCapture *capture,
935 int32_t width, int32_t height)
936 {
937 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
938
939 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
940 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
941 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
942
943 CHECK_AND_RETURN_RET_LOG(width > 0 && height > 0, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
944 "input width or height invalid!");
945
946 int32_t ret = screenCaptureObj->screenCapture_->ResizeCanvas(width, height);
947 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
948 "ResizeCanvas failed!");
949
950 return AV_SCREEN_CAPTURE_ERR_OK;
951 }
952
OH_AVScreenCapture_SkipPrivacyMode(struct OH_AVScreenCapture * capture,int32_t * windowIDs,int32_t windowCount)953 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SkipPrivacyMode(struct OH_AVScreenCapture *capture,
954 int32_t *windowIDs, int32_t windowCount)
955 {
956 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
957 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
958 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
959 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
960 CHECK_AND_RETURN_RET_LOG(windowCount >= 0 && windowCount < MAX_WINDOWS_LEN,
961 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input window invalid!");
962 CHECK_AND_RETURN_RET_LOG(!(windowIDs == nullptr && windowCount > 0),
963 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input window invalid, nullptr but size not 0!");
964 std::vector<uint64_t> vec;
965 for (int32_t i = 0; i < windowCount; i++) {
966 if (static_cast<int32_t>(*(windowIDs + i)) >= 0) {
967 vec.push_back(static_cast<uint64_t>(*(windowIDs + i)));
968 }
969 }
970 CHECK_AND_RETURN_RET_LOG(vec.size() >= 0, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input window content invalid!");
971 int32_t ret = screenCaptureObj->screenCapture_->SkipPrivacyMode(vec);
972 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
973 "SkipPrivacyMode failed!");
974 return AV_SCREEN_CAPTURE_ERR_OK;
975 }
976
OH_AVScreenCapture_SetMaxVideoFrameRate(struct OH_AVScreenCapture * capture,int32_t frameRate)977 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetMaxVideoFrameRate(struct OH_AVScreenCapture *capture,
978 int32_t frameRate)
979 {
980 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
981
982 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
983 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
984 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
985
986 CHECK_AND_RETURN_RET_LOG(frameRate > 0, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input frameRate invalid!");
987
988 int32_t ret = screenCaptureObj->screenCapture_->SetMaxVideoFrameRate(frameRate);
989 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
990 "SetMaxVideoFrameRate failed!");
991
992 return AV_SCREEN_CAPTURE_ERR_OK;
993 }
994
OH_AVScreenCapture_SetDisplayCallback(struct OH_AVScreenCapture * capture,OH_AVScreenCapture_OnDisplaySelected callback,void * userData)995 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetDisplayCallback(struct OH_AVScreenCapture *capture,
996 OH_AVScreenCapture_OnDisplaySelected callback, void *userData)
997 {
998 MEDIA_LOGD("OH_AVScreenCapture_SetDisplayCallback S");
999 CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
1000 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1001 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input displayCallback is nullptr!");
1002 struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
1003 CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
1004 AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is null");
1005
1006 CHECK_AND_RETURN_RET_LOG(!screenCaptureObj->isStart,
1007 AV_SCREEN_CAPTURE_ERR_INVALID_STATE, "This interface should be called before Start is called!");
1008 OH_AVSCREEN_CAPTURE_ErrCode errCode = AVScreenCaptureSetCallback(capture, screenCaptureObj);
1009 CHECK_AND_RETURN_RET_LOG(errCode == AV_SCREEN_CAPTURE_ERR_OK, errCode, "SetDisplayCallback is null");
1010
1011 if (screenCaptureObj->callback_ == nullptr ||
1012 !screenCaptureObj->callback_->SetDisplayCallback(callback, userData)) {
1013 MEDIA_LOGE("OH_AVScreenCapture_SetDisplayCallback error");
1014 return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
1015 }
1016 MEDIA_LOGD("OH_AVScreenCapture_SetDisplayCallback E");
1017 return AV_SCREEN_CAPTURE_ERR_OK;
1018 }