1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "screen_capture_adapter_impl.h"
17
18 #include "../native/media_errors.h"
19 #include "nweb_log.h"
20 #include "surface_adapter_impl.h"
21
22 namespace OHOS::NWeb {
23 namespace {
GetOHCaptureMode(const CaptureModeAdapter & mode)24 OHOS::Media::CaptureMode GetOHCaptureMode(const CaptureModeAdapter& mode)
25 {
26 switch (mode) {
27 case CaptureModeAdapter::CAPTURE_HOME_SCREEN:
28 return OHOS::Media::CaptureMode::CAPTURE_HOME_SCREEN;
29 case CaptureModeAdapter::CAPTURE_SPECIFIED_SCREEN:
30 return OHOS::Media::CaptureMode::CAPTURE_SPECIFIED_SCREEN;
31 case CaptureModeAdapter::CAPTURE_SPECIFIED_WINDOW:
32 return OHOS::Media::CaptureMode::CAPTURE_SPECIFIED_WINDOW;
33 default:
34 return OHOS::Media::CaptureMode::CAPTURE_INVAILD;
35 }
36 }
37
GetOHDataType(const DataTypeAdapter & type)38 OHOS::Media::DataType GetOHDataType(const DataTypeAdapter& type)
39 {
40 switch (type) {
41 case DataTypeAdapter::ORIGINAL_STREAM_DATA_TYPE:
42 return OHOS::Media::DataType::ORIGINAL_STREAM;
43 case DataTypeAdapter::ENCODED_STREAM_DATA_TYPE:
44 return OHOS::Media::DataType::ENCODED_STREAM;
45 case DataTypeAdapter::CAPTURE_FILE_DATA_TYPE:
46 return OHOS::Media::DataType::CAPTURE_FILE;
47 default:
48 return OHOS::Media::DataType::INVAILD;
49 }
50 }
51
GetOHAudioCaptureSourceType(const AudioCaptureSourceTypeAdapter & type)52 OHOS::Media::AudioCaptureSourceType GetOHAudioCaptureSourceType(const AudioCaptureSourceTypeAdapter& type)
53 {
54 switch (type) {
55 case AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT:
56 return OHOS::Media::AudioCaptureSourceType::SOURCE_DEFAULT;
57 case AudioCaptureSourceTypeAdapter::MIC:
58 return OHOS::Media::AudioCaptureSourceType::MIC;
59 case AudioCaptureSourceTypeAdapter::ALL_PLAYBACK:
60 return OHOS::Media::AudioCaptureSourceType::ALL_PLAYBACK;
61 case AudioCaptureSourceTypeAdapter::APP_PLAYBACK:
62 return OHOS::Media::AudioCaptureSourceType::APP_PLAYBACK;
63 default:
64 return OHOS::Media::AudioCaptureSourceType::SOURCE_INVALID;
65 }
66 }
67
GetAudioCaptureSourceTypeAdapter(const OHOS::Media::AudioCaptureSourceType & type)68 AudioCaptureSourceTypeAdapter GetAudioCaptureSourceTypeAdapter(const OHOS::Media::AudioCaptureSourceType& type)
69 {
70 switch (type) {
71 case OHOS::Media::AudioCaptureSourceType::SOURCE_DEFAULT:
72 return AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT;
73 case OHOS::Media::AudioCaptureSourceType::MIC:
74 return AudioCaptureSourceTypeAdapter::MIC;
75 case OHOS::Media::AudioCaptureSourceType::ALL_PLAYBACK:
76 return AudioCaptureSourceTypeAdapter::ALL_PLAYBACK;
77 case OHOS::Media::AudioCaptureSourceType::APP_PLAYBACK:
78 return AudioCaptureSourceTypeAdapter::APP_PLAYBACK;
79 default:
80 return AudioCaptureSourceTypeAdapter::SOURCE_INVALID;
81 }
82 }
83
GetOHAudioCodecFormat(const AudioCodecFormatAdapter & format)84 OHOS::Media::AudioCodecFormat GetOHAudioCodecFormat(const AudioCodecFormatAdapter& format)
85 {
86 switch (format) {
87 case AudioCodecFormatAdapter::AUDIO_DEFAULT:
88 return OHOS::Media::AudioCodecFormat::AUDIO_DEFAULT;
89 case AudioCodecFormatAdapter::AAC_LC:
90 return OHOS::Media::AudioCodecFormat::AAC_LC;
91 default:
92 return OHOS::Media::AudioCodecFormat::AUDIO_CODEC_FORMAT_BUTT;
93 }
94 }
95
GetOHVideoSourceType(const VideoSourceTypeAdapter & type)96 OHOS::Media::VideoSourceType GetOHVideoSourceType(const VideoSourceTypeAdapter& type)
97 {
98 switch (type) {
99 case VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_YUV:
100 return OHOS::Media::VideoSourceType::VIDEO_SOURCE_SURFACE_YUV;
101 case VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_ES:
102 return OHOS::Media::VideoSourceType::VIDEO_SOURCE_SURFACE_ES;
103 case VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_RGBA:
104 return OHOS::Media::VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA;
105 default:
106 return OHOS::Media::VideoSourceType::VIDEO_SOURCE_BUTT;
107 }
108 }
109
GetOHVideoCodecFormat(const VideoCodecFormatAdapter & format)110 OHOS::Media::VideoCodecFormat GetOHVideoCodecFormat(const VideoCodecFormatAdapter& format)
111 {
112 switch (format) {
113 case VideoCodecFormatAdapter::VIDEO_DEFAULT:
114 return OHOS::Media::VideoCodecFormat::VIDEO_DEFAULT;
115 case VideoCodecFormatAdapter::H264:
116 return OHOS::Media::VideoCodecFormat::H264;
117 case VideoCodecFormatAdapter::MPEG4:
118 return OHOS::Media::VideoCodecFormat::MPEG4;
119 default:
120 return OHOS::Media::VideoCodecFormat::VIDEO_CODEC_FORMAT_BUTT;
121 }
122 }
123
GetOHContainerFormatType(const ContainerFormatTypeAdapter & type)124 std::string GetOHContainerFormatType(const ContainerFormatTypeAdapter& type)
125 {
126 switch (type) {
127 case ContainerFormatTypeAdapter::CFT_MPEG_4A_TYPE:
128 return std::string(OHOS::Media::ContainerFormatType::CFT_MPEG_4A);
129 default:
130 return std::string(OHOS::Media::ContainerFormatType::CFT_MPEG_4);
131 }
132 }
133
ConvertScreenCaptureConfig(const std::shared_ptr<ScreenCaptureConfigAdapter> config)134 OHOS::Media::AVScreenCaptureConfig ConvertScreenCaptureConfig(const std::shared_ptr<ScreenCaptureConfigAdapter> config)
135 {
136 OHOS::Media::AVScreenCaptureConfig avConfig;
137
138 if (!config) {
139 WVLOG_I("ConvertScreenCaptureConfig config is null");
140 return avConfig;
141 }
142
143 avConfig.captureMode = GetOHCaptureMode(config->GetCaptureMode());
144 avConfig.dataType = GetOHDataType(config->GetDataType());
145
146 if (config->GetAudioInfo() && config->GetAudioInfo()->GetMicCapInfo()) {
147 avConfig.audioInfo.micCapInfo.audioSampleRate = config->GetAudioInfo()->GetMicCapInfo()->GetAudioSampleRate();
148 avConfig.audioInfo.micCapInfo.audioChannels = config->GetAudioInfo()->GetMicCapInfo()->GetAudioChannels();
149 avConfig.audioInfo.micCapInfo.audioSource =
150 GetOHAudioCaptureSourceType(config->GetAudioInfo()->GetMicCapInfo()->GetAudioSource());
151 }
152
153 if (config->GetAudioInfo() && config->GetAudioInfo()->GetInnerCapInfo()) {
154 avConfig.audioInfo.innerCapInfo.audioSampleRate =
155 config->GetAudioInfo()->GetInnerCapInfo()->GetAudioSampleRate();
156 avConfig.audioInfo.innerCapInfo.audioChannels = config->GetAudioInfo()->GetInnerCapInfo()->GetAudioChannels();
157 avConfig.audioInfo.innerCapInfo.audioSource =
158 GetOHAudioCaptureSourceType(config->GetAudioInfo()->GetInnerCapInfo()->GetAudioSource());
159 }
160
161 if (config->GetAudioInfo() && config->GetAudioInfo()->GetAudioEncInfo()) {
162 avConfig.audioInfo.audioEncInfo.audioBitrate = config->GetAudioInfo()->GetAudioEncInfo()->GetAudioBitrate();
163 avConfig.audioInfo.audioEncInfo.audioCodecformat =
164 GetOHAudioCodecFormat(config->GetAudioInfo()->GetAudioEncInfo()->GetAudioCodecformat());
165 }
166
167 if (config->GetVideoInfo() && config->GetVideoInfo()->GetVideoCapInfo()) {
168 avConfig.videoInfo.videoCapInfo.displayId = config->GetVideoInfo()->GetVideoCapInfo()->GetDisplayId();
169 avConfig.videoInfo.videoCapInfo.taskIDs = config->GetVideoInfo()->GetVideoCapInfo()->GetTaskIDs();
170 avConfig.videoInfo.videoCapInfo.videoFrameWidth =
171 config->GetVideoInfo()->GetVideoCapInfo()->GetVideoFrameWidth();
172 avConfig.videoInfo.videoCapInfo.videoFrameHeight =
173 config->GetVideoInfo()->GetVideoCapInfo()->GetVideoFrameHeight();
174 avConfig.videoInfo.videoCapInfo.videoSource =
175 GetOHVideoSourceType(config->GetVideoInfo()->GetVideoCapInfo()->GetVideoSourceType());
176 }
177
178 if (config->GetVideoInfo() && config->GetVideoInfo()->GetVideoEncInfo()) {
179 avConfig.videoInfo.videoEncInfo.videoCodec =
180 GetOHVideoCodecFormat(config->GetVideoInfo()->GetVideoEncInfo()->GetVideoCodecFormat());
181 avConfig.videoInfo.videoEncInfo.videoBitrate = config->GetVideoInfo()->GetVideoEncInfo()->GetVideoBitrate();
182 avConfig.videoInfo.videoEncInfo.videoFrameRate = config->GetVideoInfo()->GetVideoEncInfo()->GetVideoFrameRate();
183 }
184
185 if (config->GetDataType() == DataTypeAdapter::CAPTURE_FILE_DATA_TYPE && config->GetRecorderInfo()) {
186 avConfig.recorderInfo.url = config->GetRecorderInfo()->GetUrl();
187 avConfig.recorderInfo.fileFormat = GetOHContainerFormatType(config->GetRecorderInfo()->GetFileFormat());
188 }
189
190 return avConfig;
191 }
192
GetScreenCaptureStateCodeAdapter(const OHOS::Media::AVScreenCaptureStateCode & stateCode)193 ScreenCaptureStateCodeAdapter GetScreenCaptureStateCodeAdapter(const OHOS::Media::AVScreenCaptureStateCode& stateCode)
194 {
195 switch (stateCode) {
196 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED:
197 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STARTED;
198 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_CANCELED:
199 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_CANCELED;
200 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER:
201 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STOPPED_BY_USER;
202 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER:
203 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER;
204 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL:
205 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL;
206 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE:
207 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE;
208 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_MUTED_BY_USER:
209 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_MUTED_BY_USER;
210 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNMUTED_BY_USER:
211 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_UNMUTED_BY_USER;
212 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_ENTER_PRIVATE_SCENE:
213 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_ENTER_PRIVATE_SCENE;
214 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_EXIT_PRIVATE_SCENE:
215 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_EXIT_PRIVATE_SCENE;
216 default:
217 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_INVLID;
218 }
219 }
220
ConvertAudioCaptureSourceType(const AudioCaptureSourceTypeAdapter & type)221 OHOS::Media::AudioCaptureSourceType ConvertAudioCaptureSourceType(const AudioCaptureSourceTypeAdapter& type)
222 {
223 switch (type) {
224 case AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT:
225 return OHOS::Media::AudioCaptureSourceType::SOURCE_DEFAULT;
226 case AudioCaptureSourceTypeAdapter::MIC:
227 return OHOS::Media::AudioCaptureSourceType::MIC;
228 case AudioCaptureSourceTypeAdapter::ALL_PLAYBACK:
229 return OHOS::Media::AudioCaptureSourceType::ALL_PLAYBACK;
230 case AudioCaptureSourceTypeAdapter::APP_PLAYBACK:
231 return OHOS::Media::AudioCaptureSourceType::APP_PLAYBACK;
232 default:
233 return OHOS::Media::AudioCaptureSourceType::SOURCE_INVALID;
234 }
235 }
236
237 } // namespace
238
OnError(OHOS::Media::ScreenCaptureErrorType errorType,int32_t errorCode)239 void OHScreenCaptureCallback::OnError(OHOS::Media::ScreenCaptureErrorType errorType, int32_t errorCode)
240 {
241 WVLOG_I("OnError() is called, errorType %{public}d, errorCode %{public}d", errorType, errorCode);
242 if (callback_) {
243 callback_->OnError(errorCode);
244 }
245 }
246
OnAudioBufferAvailable(bool isReady,OHOS::Media::AudioCaptureSourceType type)247 void OHScreenCaptureCallback::OnAudioBufferAvailable(bool isReady, OHOS::Media::AudioCaptureSourceType type)
248 {
249 if (callback_) {
250 callback_->OnAudioBufferAvailable(isReady, GetAudioCaptureSourceTypeAdapter(type));
251 }
252 }
253
OnVideoBufferAvailable(bool isReady)254 void OHScreenCaptureCallback::OnVideoBufferAvailable(bool isReady)
255 {
256 if (callback_) {
257 callback_->OnVideoBufferAvailable(isReady);
258 }
259 }
260
OnStateChange(OHOS::Media::AVScreenCaptureStateCode stateCode)261 void OHScreenCaptureCallback::OnStateChange(OHOS::Media::AVScreenCaptureStateCode stateCode)
262 {
263 WVLOG_I("OnStateChange() is called, stateCode %{public}d", stateCode);
264 if (callback_) {
265 callback_->OnStateChange(GetScreenCaptureStateCodeAdapter(stateCode));
266 }
267 }
268
~ScreenCaptureAdapterImpl()269 ScreenCaptureAdapterImpl::~ScreenCaptureAdapterImpl()
270 {
271 Release();
272 }
273
Init(const std::shared_ptr<ScreenCaptureConfigAdapter> config)274 int32_t ScreenCaptureAdapterImpl::Init(const std::shared_ptr<ScreenCaptureConfigAdapter> config)
275 {
276 if (screenCapture_) {
277 return 0;
278 }
279 screenCapture_ = OHOS::Media::ScreenCaptureFactory::CreateScreenCapture();
280 if (!screenCapture_) {
281 WVLOG_E("CreateScreenCapture create failed");
282 return -1;
283 }
284
285 if (!config) {
286 WVLOG_E("config is null");
287 return -1;
288 }
289
290 int32_t ret = screenCapture_->Init(ConvertScreenCaptureConfig(config));
291 if (ret != Media::MSERR_OK) {
292 WVLOG_E("OH_AVScreenCapture init failed, ret = %{public}d", ret);
293 Release();
294 return -1;
295 }
296 return 0;
297 }
298
Release()299 void ScreenCaptureAdapterImpl::Release()
300 {
301 if (!screenCapture_) {
302 return;
303 }
304 screenCaptureCallback_ = nullptr;
305 int32_t ret = screenCapture_->Release();
306 if (ret != Media::MSERR_OK) {
307 WVLOG_E("OH_AVScreenCapture release failed, ret = %{public}d", ret);
308 }
309 screenCapture_ = nullptr;
310 }
311
SetMicrophoneEnable(bool enable)312 int32_t ScreenCaptureAdapterImpl::SetMicrophoneEnable(bool enable)
313 {
314 if (!screenCapture_) {
315 WVLOG_E("not init");
316 return -1;
317 }
318 int32_t ret = screenCapture_->SetMicrophoneEnabled(enable);
319 if (ret != Media::MSERR_OK) {
320 WVLOG_E("set microphone enabled failed, ret = %{public}d", ret);
321 return -1;
322 }
323 return 0;
324 }
325
StartCapture()326 int32_t ScreenCaptureAdapterImpl::StartCapture()
327 {
328 if (!screenCapture_) {
329 WVLOG_E("not init");
330 return -1;
331 }
332 int32_t ret = screenCapture_->SetPrivacyAuthorityEnabled();
333 if (ret != Media::MSERR_OK) {
334 WVLOG_E("start capture SetPrivacyAuthorityEnabled failed, ret = %{public}d", ret);
335 return -1;
336 }
337 ret = screenCapture_->SetCanvasRotation(true);
338 if (ret != Media::MSERR_OK) {
339 WVLOG_E("start capture SetCanvasRotation failed, ret = %{public}d", ret);
340 }
341 ret = screenCapture_->StartScreenCapture();
342 if (ret != Media::MSERR_OK) {
343 WVLOG_E("start capture failed, ret = %{public}d", ret);
344 return -1;
345 }
346 return 0;
347 }
348
StopCapture()349 int32_t ScreenCaptureAdapterImpl::StopCapture()
350 {
351 if (!screenCapture_) {
352 WVLOG_E("not init");
353 return -1;
354 }
355 int32_t ret = screenCapture_->StopScreenCapture();
356 if (ret != Media::MSERR_OK) {
357 WVLOG_E("stop capture failed, ret = %{public}d", ret);
358 return -1;
359 }
360 return 0;
361 }
362
SetCaptureCallback(const std::shared_ptr<ScreenCaptureCallbackAdapter> callback)363 int32_t ScreenCaptureAdapterImpl::SetCaptureCallback(const std::shared_ptr<ScreenCaptureCallbackAdapter> callback)
364 {
365 if (!screenCapture_ || !callback || screenCaptureCallback_) {
366 WVLOG_E("not init or param error");
367 return -1;
368 }
369 screenCaptureCallback_ = std::make_shared<OHScreenCaptureCallback>(callback);
370 if (!screenCaptureCallback_) {
371 WVLOG_E("make_shared failed");
372 return -1;
373 }
374 int32_t ret = screenCapture_->SetScreenCaptureCallback(screenCaptureCallback_);
375 if (ret != Media::MSERR_OK) {
376 WVLOG_E("set callback failed, ret = %{public}d", ret);
377 screenCaptureCallback_ = nullptr;
378 return -1;
379 }
380 return 0;
381 }
382
AcquireVideoBuffer()383 std::shared_ptr<SurfaceBufferAdapter> ScreenCaptureAdapterImpl::AcquireVideoBuffer()
384 {
385 if (!screenCapture_) {
386 WVLOG_E("not init");
387 return nullptr;
388 }
389 int32_t fence;
390 int64_t timestamp;
391 OHOS::Rect region;
392 sptr<OHOS::SurfaceBuffer> surfaceBuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, region);
393 if (surfaceBuffer == nullptr) {
394 WVLOG_E("acquire video buffer failed");
395 return nullptr;
396 }
397 auto surfaceBufferImpl = std::make_shared<SurfaceBufferAdapterImpl>(surfaceBuffer);
398 if (!surfaceBufferImpl) {
399 WVLOG_E("make_unique failed");
400 (void)ReleaseVideoBuffer();
401 return nullptr;
402 }
403 return std::move(surfaceBufferImpl);
404 }
405
AcquireAudioBuffer(std::shared_ptr<AudioBufferAdapter> audiobuffer,AudioCaptureSourceTypeAdapter type)406 int32_t ScreenCaptureAdapterImpl::AcquireAudioBuffer(
407 std::shared_ptr<AudioBufferAdapter> audiobuffer, AudioCaptureSourceTypeAdapter type)
408 {
409 if (screenCapture_ == nullptr) {
410 WVLOG_E("not init");
411 return -1;
412 }
413
414 if (!audiobuffer) {
415 WVLOG_E("audiobuffer is nullptr");
416 return -1;
417 }
418
419 std::shared_ptr<OHOS::Media::AudioBuffer> avBuffer =
420 std::make_shared<OHOS::Media::AudioBuffer>(nullptr, 0, 0, OHOS::Media::AudioCaptureSourceType::SOURCE_INVALID);
421
422 int32_t ret = screenCapture_->AcquireAudioBuffer(avBuffer, ConvertAudioCaptureSourceType(type));
423 if (ret != Media::MSERR_OK) {
424 WVLOG_E("acquire audio buffer failed");
425 return -1;
426 }
427
428 if (avBuffer == nullptr || avBuffer->buffer == nullptr) {
429 WVLOG_E("avBuffer is nullptr or buffer is nullptr");
430 return -1;
431 }
432
433 audiobuffer->SetBuffer(std::move(avBuffer->buffer));
434 audiobuffer->SetLength(avBuffer->length);
435 audiobuffer->SetTimestamp(avBuffer->timestamp);
436 audiobuffer->SetSourcetype(GetAudioCaptureSourceTypeAdapter(avBuffer->sourcetype));
437 avBuffer->buffer = nullptr;
438
439 return 0;
440 }
441
ReleaseVideoBuffer()442 int32_t ScreenCaptureAdapterImpl::ReleaseVideoBuffer()
443 {
444 if (!screenCapture_) {
445 WVLOG_E("not init");
446 return -1;
447 }
448 int32_t ret = screenCapture_->ReleaseVideoBuffer();
449 if (ret != Media::MSERR_OK) {
450 WVLOG_E("release video buffer failed, ret = %{public}d", ret);
451 return -1;
452 }
453 return 0;
454 }
455
ReleaseAudioBuffer(AudioCaptureSourceTypeAdapter type)456 int32_t ScreenCaptureAdapterImpl::ReleaseAudioBuffer(AudioCaptureSourceTypeAdapter type)
457 {
458 if (!screenCapture_) {
459 WVLOG_E("screen capture not init");
460 return -1;
461 }
462 int32_t ret = screenCapture_->ReleaseAudioBuffer(ConvertAudioCaptureSourceType(type));
463 if (ret != Media::MSERR_OK) {
464 WVLOG_E("release audio buffer failed, ret = %{public}d", ret);
465 return -1;
466 }
467 return 0;
468 }
469
470 } // namespace OHOS::NWeb
471