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