1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <memory>
17 #include <mutex>
18 #include <refbase.h>
19
20 #include <securec.h>
21 #include "media_log.h"
22 #include "media_errors.h"
23 #include "native_lpp_common.h"
24 #include "native_mfmagic.h"
25 #include "native_player_magic.h"
26 #include "native_window.h"
27 #include "lpp_video_streamer.h"
28 #include "lowpower_video_sink.h"
29 #include "native_averrors.h"
30 #include "lpp_common.h"
31
32 namespace {
33 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_PLAYER, "NativeLPPVideoStreamer"};
34 }
35
36 using namespace OHOS::Media;
37
38 class NativeLowPowerVideoSinkDataNeeededCallback {
39 public:
NativeLowPowerVideoSinkDataNeeededCallback(OH_LowPowerVideoSink_OnDataNeeded callback,void * userData)40 NativeLowPowerVideoSinkDataNeeededCallback(OH_LowPowerVideoSink_OnDataNeeded callback, void *userData)
41 : callback_(callback), userData_(userData)
42 {}
43 virtual ~NativeLowPowerVideoSinkDataNeeededCallback() = default;
44
OnDataNeeded(OH_LowPowerVideoSink * lppVideoStreamer_,OH_AVSamplesBuffer * framePacket)45 void OnDataNeeded(OH_LowPowerVideoSink *lppVideoStreamer_, OH_AVSamplesBuffer *framePacket)
46 {
47 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
48 callback_(lppVideoStreamer_, framePacket, userData_);
49 }
50
51 private:
52 OH_LowPowerVideoSink_OnDataNeeded callback_ = nullptr;
53 void *userData_ = nullptr;
54 };
55
56 class NativeLowPowerVideoSinkErrorCallback {
57 public:
NativeLowPowerVideoSinkErrorCallback(OH_LowPowerVideoSink_OnError callback,void * userData)58 NativeLowPowerVideoSinkErrorCallback(OH_LowPowerVideoSink_OnError callback, void *userData)
59 : callback_(callback), userData_(userData)
60 {}
61 virtual ~NativeLowPowerVideoSinkErrorCallback() = default;
62
OnError(OH_LowPowerVideoSink * lppVideoStreamer_,OH_AVErrCode errCode,const char * errMsg)63 void OnError(OH_LowPowerVideoSink *lppVideoStreamer_, OH_AVErrCode errCode, const char *errMsg)
64 {
65 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
66 callback_(lppVideoStreamer_, errCode, errMsg, userData_);
67 }
68
69 private:
70 OH_LowPowerVideoSink_OnError callback_ = nullptr;
71 void *userData_ = nullptr;
72 };
73
74 class NativeLowPowerVideoSinkTargetArrivedCallback {
75 public:
NativeLowPowerVideoSinkTargetArrivedCallback(OH_LowPowerVideoSink_OnTargetArrived callback,void * userData)76 NativeLowPowerVideoSinkTargetArrivedCallback(OH_LowPowerVideoSink_OnTargetArrived callback, void *userData)
77 : callback_(callback), userData_(userData)
78 {}
79 virtual ~NativeLowPowerVideoSinkTargetArrivedCallback() = default;
80
OnTargetArrived(OH_LowPowerVideoSink * lppVideoStreamer_,long targetPts,bool isTimeout)81 void OnTargetArrived(OH_LowPowerVideoSink *lppVideoStreamer_, long targetPts, bool isTimeout)
82 {
83 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
84 callback_(lppVideoStreamer_, targetPts, isTimeout, userData_);
85 }
86
87 private:
88 OH_LowPowerVideoSink_OnTargetArrived callback_ = nullptr;
89 void *userData_ = nullptr;
90 };
91
92 class NativeLowPowerVideoSinkRenderStartedCallback {
93 public:
NativeLowPowerVideoSinkRenderStartedCallback(OH_LowPowerVideoSink_OnRenderStarted callback,void * userData)94 NativeLowPowerVideoSinkRenderStartedCallback(OH_LowPowerVideoSink_OnRenderStarted callback, void *userData)
95 : callback_(callback), userData_(userData)
96 {}
97 virtual ~NativeLowPowerVideoSinkRenderStartedCallback() = default;
98
OnRenderStarted(OH_LowPowerVideoSink * lppVideoStreamer_)99 void OnRenderStarted(OH_LowPowerVideoSink *lppVideoStreamer_)
100 {
101 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
102 callback_(lppVideoStreamer_, userData_);
103 }
104
105 private:
106 OH_LowPowerVideoSink_OnRenderStarted callback_ = nullptr;
107 void *userData_ = nullptr;
108 };
109
110 class NativeLowPowerVideoSinkEosCallback {
111 public:
NativeLowPowerVideoSinkEosCallback(OH_LowPowerVideoSink_OnEos callback,void * userData)112 NativeLowPowerVideoSinkEosCallback(OH_LowPowerVideoSink_OnEos callback, void *userData)
113 : callback_(callback), userData_(userData)
114 {}
115 virtual ~NativeLowPowerVideoSinkEosCallback() = default;
116
OnEos(OH_LowPowerVideoSink * lppVideoStreamer_)117 void OnEos(OH_LowPowerVideoSink *lppVideoStreamer_)
118 {
119 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
120 callback_(lppVideoStreamer_, userData_);
121 }
122
123 private:
124 OH_LowPowerVideoSink_OnEos callback_ = nullptr;
125 void *userData_ = nullptr;
126 };
127
128 class NativeLowPowerVideoSinkStreamChangedCallback {
129 public:
NativeLowPowerVideoSinkStreamChangedCallback(OH_LowPowerVideoSink_OnStreamChanged callback,void * userData)130 NativeLowPowerVideoSinkStreamChangedCallback(OH_LowPowerVideoSink_OnStreamChanged callback, void *userData)
131 : callback_(callback), userData_(userData)
132 {}
133 virtual ~NativeLowPowerVideoSinkStreamChangedCallback() = default;
134
OnStreamChanged(OH_LowPowerVideoSink * lppVideoStreamer_,OH_AVFormat * format)135 void OnStreamChanged(OH_LowPowerVideoSink *lppVideoStreamer_, OH_AVFormat *format)
136 {
137 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
138 callback_(lppVideoStreamer_, format, userData_);
139 }
140
141 private:
142 OH_LowPowerVideoSink_OnStreamChanged callback_ = nullptr;
143 void *userData_ = nullptr;
144 };
145
146 class NativeLowPowerVideoSinkFirstFrameReadyCallback {
147 public:
NativeLowPowerVideoSinkFirstFrameReadyCallback(OH_LowPowerVideoSink_OnFirstFrameDecoded callback,void * userData)148 NativeLowPowerVideoSinkFirstFrameReadyCallback(OH_LowPowerVideoSink_OnFirstFrameDecoded callback, void *userData)
149 : callback_(callback), userData_(userData)
150 {}
151 virtual ~NativeLowPowerVideoSinkFirstFrameReadyCallback() = default;
152
OnFirstFrameReady(OH_LowPowerVideoSink * lppVideoStreamer_)153 void OnFirstFrameReady(OH_LowPowerVideoSink *lppVideoStreamer_)
154 {
155 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
156 callback_(lppVideoStreamer_, userData_);
157 }
158
159 private:
160 OH_LowPowerVideoSink_OnFirstFrameDecoded callback_ = nullptr;
161 void *userData_ = nullptr;
162 };
163
164 struct OH_LowPowerVideoSinkCallback : public VideoStreamerCallback {
165 public:
166 void OnError(int32_t errorCode, const std::string &errorMsg) override;
167 void OnInfo(VideoStreamerOnInfoType type, int32_t extra, const Format &infoBody) override;
168
169 public:
170 int32_t SetDataNeededListener(OH_LowPowerVideoSink_OnDataNeeded onDataNeeded, void *userData);
171 int32_t SetErrorListener(OH_LowPowerVideoSink_OnError onError, void *userData);
172 int32_t SetTargetArrivedListener(OH_LowPowerVideoSink_OnTargetArrived onTargetArrived, void *userData);
173 int32_t SetRenderStartListener(OH_LowPowerVideoSink_OnRenderStarted onRenderStarted, void *userData);
174 int32_t SetEosListener(OH_LowPowerVideoSink_OnEos onEos, void *userData);
175 int32_t SetStreamChangedListener(OH_LowPowerVideoSink_OnStreamChanged onStreamChanged, void *userData);
176 int32_t SetFirstFrameReadyListener(OH_LowPowerVideoSink_OnFirstFrameDecoded onFirstFrameReady, void *userData);
177 int32_t SetLowPowerVideoSink(struct OH_LowPowerVideoSink *lppVideoStreamer);
178
179 private:
180 struct OH_LowPowerVideoSink *lppVideoStreamer_ = nullptr;
181 std::shared_ptr<NativeLowPowerVideoSinkDataNeeededCallback> dataNeeededCallback_ = nullptr;
182 // std::shared_ptr<NativeLowPowerVideoSinkAnchorUpdatedCallback> anchorUpdatedCallback_ = nullptr;
183 std::shared_ptr<NativeLowPowerVideoSinkErrorCallback> errorCallback_ = nullptr;
184 std::shared_ptr<NativeLowPowerVideoSinkTargetArrivedCallback> targetArrivedCallback_ = nullptr;
185 std::shared_ptr<NativeLowPowerVideoSinkRenderStartedCallback> renderStartedCallback_ = nullptr;
186 std::shared_ptr<NativeLowPowerVideoSinkEosCallback> eosCallback_ = nullptr;
187 std::shared_ptr<NativeLowPowerVideoSinkStreamChangedCallback> streamChangedCallback_ = nullptr;
188 std::shared_ptr<NativeLowPowerVideoSinkFirstFrameReadyCallback> firstFrameReadyCallback_ = nullptr;
189 };
190
SetLowPowerVideoSink(struct OH_LowPowerVideoSink * lppVideoStreamer)191 int32_t OH_LowPowerVideoSinkCallback::SetLowPowerVideoSink(struct OH_LowPowerVideoSink *lppVideoStreamer)
192 {
193 CHECK_AND_RETURN_RET_LOG(lppVideoStreamer != nullptr, AV_ERR_INVALID_VAL, "lppVideoStreamer is nullptr");
194 lppVideoStreamer_ = lppVideoStreamer;
195 return AV_ERR_OK;
196 }
197
SetDataNeededListener(OH_LowPowerVideoSink_OnDataNeeded onDataNeeded,void * userData)198 int32_t OH_LowPowerVideoSinkCallback::SetDataNeededListener(
199 OH_LowPowerVideoSink_OnDataNeeded onDataNeeded, void *userData)
200 {
201 CHECK_AND_RETURN_RET_LOG(onDataNeeded != nullptr, AV_ERR_INVALID_VAL, "onDataNeeded is nullptr");
202 dataNeeededCallback_ = std::make_shared<NativeLowPowerVideoSinkDataNeeededCallback>(onDataNeeded, userData);
203 CHECK_AND_RETURN_RET_LOG(
204 dataNeeededCallback_ != nullptr, AV_ERR_OPERATE_NOT_PERMIT, "dataNeeededCallback_ is nullptr!");
205 return AV_ERR_OK;
206 }
207
SetErrorListener(OH_LowPowerVideoSink_OnError onError,void * userData)208 int32_t OH_LowPowerVideoSinkCallback::SetErrorListener(OH_LowPowerVideoSink_OnError onError, void *userData)
209 {
210 CHECK_AND_RETURN_RET_LOG(onError != nullptr, AV_ERR_INVALID_VAL, "onError is nullptr");
211 errorCallback_ = std::make_shared<NativeLowPowerVideoSinkErrorCallback>(onError, userData);
212 CHECK_AND_RETURN_RET_LOG(errorCallback_ != nullptr, AV_ERR_OPERATE_NOT_PERMIT, "errorCallback is nullptr!");
213 return AV_ERR_OK;
214 }
215
SetTargetArrivedListener(OH_LowPowerVideoSink_OnTargetArrived onTargetArrived,void * userData)216 int32_t OH_LowPowerVideoSinkCallback::SetTargetArrivedListener(
217 OH_LowPowerVideoSink_OnTargetArrived onTargetArrived, void *userData)
218 {
219 CHECK_AND_RETURN_RET_LOG(onTargetArrived != nullptr, AV_ERR_INVALID_VAL, "onTargetArrived is nullptr");
220 targetArrivedCallback_ = std::make_shared<NativeLowPowerVideoSinkTargetArrivedCallback>(onTargetArrived, userData);
221 CHECK_AND_RETURN_RET_LOG(
222 targetArrivedCallback_ != nullptr, AV_ERR_OPERATE_NOT_PERMIT, "targetArrivedCallback_ is nullptr!");
223 return AV_ERR_OK;
224 }
225
SetRenderStartListener(OH_LowPowerVideoSink_OnRenderStarted onRenderStarted,void * userData)226 int32_t OH_LowPowerVideoSinkCallback::SetRenderStartListener(
227 OH_LowPowerVideoSink_OnRenderStarted onRenderStarted, void *userData)
228 {
229 CHECK_AND_RETURN_RET_LOG(onRenderStarted != nullptr, AV_ERR_INVALID_VAL, "onRenderStarted is nullptr");
230 renderStartedCallback_ = std::make_shared<NativeLowPowerVideoSinkRenderStartedCallback>(onRenderStarted, userData);
231 CHECK_AND_RETURN_RET_LOG(
232 renderStartedCallback_ != nullptr, AV_ERR_OPERATE_NOT_PERMIT, "renderStartedCallback_ is nullptr!");
233 return AV_ERR_OK;
234 }
235
SetEosListener(OH_LowPowerVideoSink_OnEos onEos,void * userData)236 int32_t OH_LowPowerVideoSinkCallback::SetEosListener(OH_LowPowerVideoSink_OnEos onEos, void *userData)
237 {
238 CHECK_AND_RETURN_RET_LOG(onEos != nullptr, AV_ERR_INVALID_VAL, "onEos is nullptr");
239 eosCallback_ = std::make_shared<NativeLowPowerVideoSinkEosCallback>(onEos, userData);
240 CHECK_AND_RETURN_RET_LOG(eosCallback_ != nullptr, AV_ERR_OPERATE_NOT_PERMIT, "eosCallback_ is nullptr!");
241 return AV_ERR_OK;
242 }
243
SetStreamChangedListener(OH_LowPowerVideoSink_OnStreamChanged onStreamChanged,void * userData)244 int32_t OH_LowPowerVideoSinkCallback::SetStreamChangedListener(
245 OH_LowPowerVideoSink_OnStreamChanged onStreamChanged, void *userData)
246 {
247 CHECK_AND_RETURN_RET_LOG(onStreamChanged != nullptr, AV_ERR_INVALID_VAL, "onStreamChanged is nullptr");
248 streamChangedCallback_ = std::make_shared<NativeLowPowerVideoSinkStreamChangedCallback>(onStreamChanged, userData);
249 CHECK_AND_RETURN_RET_LOG(
250 streamChangedCallback_ != nullptr, AV_ERR_OPERATE_NOT_PERMIT, "streamChangedCallback_ is nullptr!");
251 return AV_ERR_OK;
252 }
253
SetFirstFrameReadyListener(OH_LowPowerVideoSink_OnFirstFrameDecoded onFirstFrameReady,void * userData)254 int32_t OH_LowPowerVideoSinkCallback::SetFirstFrameReadyListener(
255 OH_LowPowerVideoSink_OnFirstFrameDecoded onFirstFrameReady, void *userData)
256 {
257 CHECK_AND_RETURN_RET_LOG(onFirstFrameReady != nullptr, AV_ERR_INVALID_VAL, "onFirstFrameReady is nullptr");
258 firstFrameReadyCallback_ =
259 std::make_shared<NativeLowPowerVideoSinkFirstFrameReadyCallback>(onFirstFrameReady, userData);
260 CHECK_AND_RETURN_RET_LOG(
261 firstFrameReadyCallback_ != nullptr, AV_ERR_OPERATE_NOT_PERMIT, "firstFrameReadyCallback_ is nullptr!");
262 return AV_ERR_OK;
263 }
264
OnError(int32_t errorCode,const std::string & errorMsg)265 void OH_LowPowerVideoSinkCallback::OnError(int32_t errorCode, const std::string &errorMsg)
266 {
267 CHECK_AND_RETURN_LOG(lppVideoStreamer_ != nullptr, "lppVideoStreamer_ is nullptr");
268 CHECK_AND_RETURN_LOG(errorCallback_ != nullptr, "errorCallback_ is nullptr");
269
270 OH_AVErrCode avErrorCode = LppMsErrToOHAvErr(errorCode);
271 MediaServiceExtErrCodeAPI9 errorCodeApi9 = MSErrorToExtErrorAPI9(static_cast<MediaServiceErrCode>(errorCode));
272 std::string errorMsgExt = MSExtAVErrorToString(errorCodeApi9) + errorMsg;
273 MEDIA_LOGE("LowPowerVideoSink errorCode: %{public}d, errorMsg: %{public}s", static_cast<int32_t>(avErrorCode),
274 errorMsgExt.c_str());
275 errorCallback_->OnError(lppVideoStreamer_, avErrorCode, errorMsgExt.c_str());
276 }
277
OnInfo(VideoStreamerOnInfoType type,int32_t extra,const Format & infoBody)278 void OH_LowPowerVideoSinkCallback::OnInfo(VideoStreamerOnInfoType type, int32_t extra, const Format &infoBody)
279 {
280 MEDIA_LOGD("OnInfo() is called, VideoStreamerOnInfoType: %{public}d, extra: %{public}d", type, extra);
281 CHECK_AND_RETURN_LOG(lppVideoStreamer_ != nullptr, "lppVideoStreamer_ is nullptr");
282 LowPowerVideoSinkObject *streamerObj = nullptr;
283 switch (type) {
284 case VIDEO_INFO_TYPE_LPP_DATA_NEEDED:
285 CHECK_AND_RETURN_LOG(dataNeeededCallback_ != nullptr, "dataNeeededCallback_ is nullptr");
286 streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(lppVideoStreamer_);
287 CHECK_AND_RETURN_LOG(streamerObj != nullptr, "streamerObj is nullptr");
288 CHECK_AND_RETURN_LOG(streamerObj->framePacket_ != nullptr &&
289 streamerObj->framePacket_->lppDataPacket_ != nullptr, "framePacket_ is nullptr");
290 streamerObj->framePacket_->lppDataPacket_->Enable();
291 dataNeeededCallback_->OnDataNeeded(lppVideoStreamer_, streamerObj->framePacket_);
292 break;
293 case VIDEO_INFO_TYPE_LPP_FIRST_FRAME_READY:
294 CHECK_AND_RETURN_LOG(firstFrameReadyCallback_ != nullptr, "firstFrameReadyCallback_ is nullptr");
295 firstFrameReadyCallback_->OnFirstFrameReady(lppVideoStreamer_);
296 break;
297 case VIDEO_INFO_TYPE_LPP_TARGET_ARRIVED:
298 {
299 CHECK_AND_RETURN_LOG(targetArrivedCallback_ != nullptr, "targetArrivedCallback_ is nullptr");
300 int64_t targetPts = 0;
301 (void)infoBody.GetLongValue(VideoStreamerKeys::LPP_VIDEO_TARGET_PTS, targetPts);
302 int32_t isTimeout = 0;
303 (void)infoBody.GetIntValue(VideoStreamerKeys::LPP_VIDEO_IS_TIMEOUT, isTimeout);
304 targetArrivedCallback_->OnTargetArrived(lppVideoStreamer_, targetPts, static_cast<bool>(isTimeout));
305 }
306 break;
307 case VIDEO_INFO_TYPE_LPP_RENDER_STARTED:
308 CHECK_AND_RETURN_LOG(renderStartedCallback_ != nullptr, "renderStartedCallback_ is nullptr");
309 renderStartedCallback_->OnRenderStarted(lppVideoStreamer_);
310 break;
311 case VIDEO_INFO_TYPE_LPP_EOS:
312 CHECK_AND_RETURN_LOG(eosCallback_ != nullptr, "eosCallback_ is nullptr");
313 eosCallback_->OnEos(lppVideoStreamer_);
314 break;
315 case VIDEO_INFO_TYPE_LPP_STREAM_CHANGED:
316 {
317 CHECK_AND_RETURN_LOG(streamChangedCallback_ != nullptr, "streamChangedCallback_ is nullptr");
318 OHOS::sptr<OH_AVFormat> object = OHOS::sptr<OH_AVFormat>::MakeSptr(infoBody);
319 streamChangedCallback_->OnStreamChanged(lppVideoStreamer_,
320 reinterpret_cast<OH_AVFormat *>(object.GetRefPtr()));
321 }
322 break;
323 default:
324 break;
325 }
326 }
327
OH_LowPowerVideoSink_CreateByMime(const char * mime)328 OH_LowPowerVideoSink *OH_LowPowerVideoSink_CreateByMime(const char *mime)
329 {
330 MEDIA_LOGD("OH_LowPowerVideoSink_CreateByMime");
331 CHECK_AND_RETURN_RET_LOG(mime != nullptr, nullptr, "mime is nullptr");
332 std::shared_ptr<VideoStreamer> player = VideoStreamerFactory::CreateByMime(std::string(mime));
333 CHECK_AND_RETURN_RET_LOG(player != nullptr, nullptr, "create player failed!");
334 std::string streamerId = player->GetStreamerId();
335
336 OHOS::sptr<LppDataPacket> lppDataPacket = OHOS::sptr<LppDataPacket>::MakeSptr();
337 CHECK_AND_RETURN_RET_LOG(lppDataPacket != nullptr, nullptr, "create lppDataPacket failed!");
338 lppDataPacket->Init(streamerId);
339
340 AVSamplesBufferObject* framePacket = new(std::nothrow) AVSamplesBufferObject(lppDataPacket);
341 CHECK_AND_RETURN_RET_LOG(framePacket != nullptr, nullptr, "create framePacket failed!");
342 LowPowerVideoSinkObject *object = new (std::nothrow) LowPowerVideoSinkObject(player, framePacket);
343 CHECK_AND_RETURN_RET_LOG(object != nullptr, nullptr, "create object failed!");
344 return object;
345 }
346
OH_LowPowerVideoSink_Configure(OH_LowPowerVideoSink * streamer,const OH_AVFormat * format)347 OH_AVErrCode OH_LowPowerVideoSink_Configure(OH_LowPowerVideoSink *streamer, const OH_AVFormat *format)
348 {
349 MEDIA_LOGD("OH_LowPowerVideoSink_Configure");
350 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr");
351 CHECK_AND_RETURN_RET_LOG(format != nullptr, AV_ERR_INVALID_VAL, "format is nullptr");
352 LowPowerVideoSinkObject *streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
353
354 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
355 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
356 Format format_ = static_cast<Format>(format->format_);
357 int32_t res = streamerObj->videoStreamer_->Configure(format_);
358 return LppMsErrToOHAvErr(res);
359 }
360
OH_LowPowerVideoSink_SetParameter(OH_LowPowerVideoSink * streamer,const OH_AVFormat * format)361 OH_AVErrCode OH_LowPowerVideoSink_SetParameter(OH_LowPowerVideoSink *streamer, const OH_AVFormat *format)
362 {
363 MEDIA_LOGD("OH_LowPowerVideoSink_SetParameter");
364 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr");
365 CHECK_AND_RETURN_RET_LOG(format != nullptr, AV_ERR_INVALID_VAL, "format is nullptr");
366 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
367 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
368 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
369 auto format_ = static_cast<Format>(format->format_);
370 int32_t res = streamerObj->videoStreamer_->SetParameter(format_);
371 return LppMsErrToOHAvErr(res);
372 }
373
OH_LowPowerVideoSink_GetParameter(OH_LowPowerVideoSink * sink,OH_AVFormat * format)374 OH_AVErrCode OH_LowPowerVideoSink_GetParameter(OH_LowPowerVideoSink *sink, OH_AVFormat *format)
375 {
376 MEDIA_LOGD("OH_LowPowerVideoSink_GetParameter");
377 (void)sink;
378 (void)format;
379 return AV_ERR_OK;
380 }
381
OH_LowPowerVideoSink_SetVideoSurface(OH_LowPowerVideoSink * streamer,const OHNativeWindow * window)382 OH_AVErrCode OH_LowPowerVideoSink_SetVideoSurface(OH_LowPowerVideoSink *streamer, const OHNativeWindow *window)
383 {
384 MEDIA_LOGD("OH_LowPowerVideoSink_SetVideoSurface");
385 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
386 CHECK_AND_RETURN_RET_LOG(window != nullptr, AV_ERR_INVALID_VAL, "Window is nullptr!");
387 CHECK_AND_RETURN_RET_LOG(window->surface != nullptr, AV_ERR_INVALID_VAL, "Input window surface is nullptr!");
388
389 window->surface->Disconnect();
390 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
391 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
392 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
393 int32_t res = streamerObj->videoStreamer_->SetOutputSurface(window->surface);
394 return LppMsErrToOHAvErr(res);
395 }
396
OH_LowPowerVideoSink_Prepare(OH_LowPowerVideoSink * streamer)397 OH_AVErrCode OH_LowPowerVideoSink_Prepare(OH_LowPowerVideoSink *streamer)
398 {
399 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
400 LowPowerVideoSinkObject *streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
401 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
402 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
403 int32_t res = streamerObj->videoStreamer_->Prepare();
404 return LppMsErrToOHAvErr(res);
405 }
406
OH_LowPowerVideoSink_StartDecoder(OH_LowPowerVideoSink * streamer)407 OH_AVErrCode OH_LowPowerVideoSink_StartDecoder(OH_LowPowerVideoSink *streamer)
408 {
409 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
410 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
411 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
412 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
413 int32_t res = streamerObj->videoStreamer_->StartDecode();
414 return LppMsErrToOHAvErr(res);
415 }
416
OH_LowPowerVideoSink_StartRenderer(OH_LowPowerVideoSink * streamer)417 OH_AVErrCode OH_LowPowerVideoSink_StartRenderer(OH_LowPowerVideoSink *streamer)
418 {
419 MEDIA_LOGD("OH_LowPowerVideoSink_StartRenderer");
420 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
421 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
422 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
423 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
424 int32_t res = streamerObj->videoStreamer_->StartRender();
425 return LppMsErrToOHAvErr(res);
426 }
427
OH_LowPowerVideoSink_Pause(OH_LowPowerVideoSink * streamer)428 OH_AVErrCode OH_LowPowerVideoSink_Pause(OH_LowPowerVideoSink *streamer)
429 {
430 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
431 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
432 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
433 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
434 int32_t res = streamerObj->videoStreamer_->Pause();
435 return LppMsErrToOHAvErr(res);
436 }
437
OH_LowPowerVideoSink_Resume(OH_LowPowerVideoSink * streamer)438 OH_AVErrCode OH_LowPowerVideoSink_Resume(OH_LowPowerVideoSink *streamer)
439 {
440 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
441 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
442 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
443 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
444 int32_t res = streamerObj->videoStreamer_->Resume();
445 return LppMsErrToOHAvErr(res);
446 }
447
OH_LowPowerVideoSink_Flush(OH_LowPowerVideoSink * streamer)448 OH_AVErrCode OH_LowPowerVideoSink_Flush(OH_LowPowerVideoSink *streamer)
449 {
450 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
451 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
452 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
453 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
454 int32_t res = streamerObj->videoStreamer_->Flush();
455 return LppMsErrToOHAvErr(res);
456 }
457
OH_LowPowerVideoSink_Stop(OH_LowPowerVideoSink * streamer)458 OH_AVErrCode OH_LowPowerVideoSink_Stop(OH_LowPowerVideoSink *streamer)
459 {
460 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
461 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
462 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
463 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
464 int32_t res = streamerObj->videoStreamer_->Stop();
465 return LppMsErrToOHAvErr(res);
466 }
467
OH_LowPowerVideoSink_Reset(OH_LowPowerVideoSink * streamer)468 OH_AVErrCode OH_LowPowerVideoSink_Reset(OH_LowPowerVideoSink *streamer)
469 {
470 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
471 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
472 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
473 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
474 int32_t res = streamerObj->videoStreamer_->Reset();
475 return LppMsErrToOHAvErr(res);
476 }
477
OH_LowPowerVideoSink_Destroy(OH_LowPowerVideoSink * streamer)478 OH_AVErrCode OH_LowPowerVideoSink_Destroy(OH_LowPowerVideoSink *streamer)
479 {
480 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
481 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
482 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
483 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
484 int32_t res = streamerObj->videoStreamer_->Release();
485 MEDIA_LOGI("videostreamer release result is %{public}d", res);
486 delete streamerObj->framePacket_;
487 delete streamerObj;
488 return AV_ERR_OK;
489 }
490
OH_LowPowerVideoSink_SetSyncAudioSink(OH_LowPowerVideoSink * videoStreamer,OH_LowPowerAudioSink * audioStreamer)491 OH_AVErrCode OH_LowPowerVideoSink_SetSyncAudioSink(
492 OH_LowPowerVideoSink *videoStreamer, OH_LowPowerAudioSink *audioStreamer)
493 {
494 CHECK_AND_RETURN_RET_LOG(videoStreamer != nullptr, AV_ERR_INVALID_VAL, "videoStreamer is nullptr!");
495 CHECK_AND_RETURN_RET_LOG(audioStreamer != nullptr, AV_ERR_INVALID_VAL, "audioStreamer is nullptr!");
496 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(videoStreamer);
497 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
498 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
499 auto audioStreamerObj = reinterpret_cast<LowPowerAudioSinkObject *>(audioStreamer);
500 CHECK_AND_RETURN_RET_LOG(audioStreamerObj != nullptr, AV_ERR_INVALID_VAL, "audioStreamerObj is nullptr");
501 CHECK_AND_RETURN_RET_LOG(
502 audioStreamerObj->audioStreamer_ != nullptr, AV_ERR_INVALID_VAL, "audioStreamer_ is nullptr");
503 int32_t res = streamerObj->videoStreamer_->SetSyncAudioStreamer(audioStreamerObj->audioStreamer_);
504 return LppMsErrToOHAvErr(res);
505 }
506
OH_LowPowerVideoSink_SetTargetStartFrame(OH_LowPowerVideoSink * streamer,const long framePts,OH_LowPowerVideoSink_OnTargetArrived onTargetArrived,const long timeoutMs,void * userData)507 OH_AVErrCode OH_LowPowerVideoSink_SetTargetStartFrame(OH_LowPowerVideoSink *streamer, const long framePts,
508 OH_LowPowerVideoSink_OnTargetArrived onTargetArrived, const long timeoutMs, void *userData)
509 {
510 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
511 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
512 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
513 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
514 std::shared_ptr<VideoStreamerCallback> cb = streamerObj->videoStreamer_->GetLppVideoStreamerCallback();
515 CHECK_AND_RETURN_RET_LOG(cb != nullptr, AV_ERR_INVALID_VAL, "VideoStreamerCallback is nullptr");
516 OH_LowPowerVideoSinkCallback *callback = static_cast<OH_LowPowerVideoSinkCallback*>(cb.get());
517 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr");
518 callback->SetTargetArrivedListener(onTargetArrived, userData);
519 int32_t res = streamerObj->videoStreamer_->SetTargetStartFrame(framePts, timeoutMs);
520 return LppMsErrToOHAvErr(res);
521 }
522
OH_LowPowerVideoSink_SetPlaybackSpeed(OH_LowPowerVideoSink * streamer,const float speed)523 OH_AVErrCode OH_LowPowerVideoSink_SetPlaybackSpeed(OH_LowPowerVideoSink *streamer, const float speed)
524 {
525 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
526 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
527 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
528 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
529 int32_t res = streamerObj->videoStreamer_->SetPlaybackSpeed(speed);
530 return LppMsErrToOHAvErr(res);
531 }
532
OH_LowPowerVideoSink_ReturnSamples(OH_LowPowerVideoSink * streamer,OH_AVSamplesBuffer * frames)533 OH_AVErrCode OH_LowPowerVideoSink_ReturnSamples(OH_LowPowerVideoSink *streamer, OH_AVSamplesBuffer *frames)
534 {
535 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
536 CHECK_AND_RETURN_RET_LOG(frames != nullptr, AV_ERR_INVALID_VAL, "frames is nullptr");
537 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
538 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
539 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
540 AVSamplesBufferObject *framePacket = reinterpret_cast<AVSamplesBufferObject *>(frames);
541 CHECK_AND_RETURN_RET_LOG(framePacket != nullptr, AV_ERR_INVALID_VAL, "framePacket is nullptr");
542 CHECK_AND_RETURN_RET_LOG(framePacket->lppDataPacket_ != nullptr, AV_ERR_INVALID_VAL, "lppDataPacket is nullptr");
543 CHECK_AND_RETURN_RET_LOG(framePacket->lppDataPacket_->IsEnable(), AV_ERR_INVALID_VAL, "data packet is not in user");
544 framePacket->lppDataPacket_->Disable();
545 int32_t res = streamerObj->videoStreamer_->ReturnFrames(framePacket->lppDataPacket_);
546 CHECK_AND_RETURN_RET_LOG(res == MSERR_OK, LppMsErrToOHAvErr(res), "ReturnFrames failed");
547 return AV_ERR_OK;
548 }
549
OH_LowPowerVideoSink_RenderFirstFrame(OH_LowPowerVideoSink * streamer)550 OH_AVErrCode OH_LowPowerVideoSink_RenderFirstFrame(OH_LowPowerVideoSink *streamer)
551 {
552 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
553 LowPowerVideoSinkObject *streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
554 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
555 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
556 int32_t res = streamerObj->videoStreamer_->RenderFirstFrame();
557 return LppMsErrToOHAvErr(res);
558 }
559
OH_LowPowerVideoSink_RegisterCallback(OH_LowPowerVideoSink * streamer,OH_LowPowerVideoSinkCallback * callback)560 OH_AVErrCode OH_LowPowerVideoSink_RegisterCallback(
561 OH_LowPowerVideoSink *streamer, OH_LowPowerVideoSinkCallback *callback)
562 {
563 CHECK_AND_RETURN_RET_LOG(streamer != nullptr, AV_ERR_INVALID_VAL, "streamer is nullptr!");
564 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
565 auto streamerObj = reinterpret_cast<LowPowerVideoSinkObject *>(streamer);
566 CHECK_AND_RETURN_RET_LOG(streamerObj != nullptr, AV_ERR_INVALID_VAL, "streamerObj is nullptr");
567 CHECK_AND_RETURN_RET_LOG(streamerObj->videoStreamer_ != nullptr, AV_ERR_INVALID_VAL, "videoStreamer_ is nullptr");
568 callback->SetLowPowerVideoSink(streamer);
569 std::shared_ptr<VideoStreamerCallback> callbackPtr(callback);
570 int32_t res = streamerObj->videoStreamer_->SetLppVideoStreamerCallback(callbackPtr);
571 return LppMsErrToOHAvErr(res);
572 }
573
OH_LowPowerVideoSinkCallback_Create()574 OH_LowPowerVideoSinkCallback *OH_LowPowerVideoSinkCallback_Create()
575 {
576 MEDIA_LOGD("OH_LowPowerVideoSinkCallback_Create");
577 OH_LowPowerVideoSinkCallback *callback = new (std::nothrow) OH_LowPowerVideoSinkCallback();
578 return callback;
579 }
580
OH_LowPowerVideoSinkCallback_Destroy(OH_LowPowerVideoSinkCallback * callback)581 OH_AVErrCode OH_LowPowerVideoSinkCallback_Destroy(OH_LowPowerVideoSinkCallback *callback)
582 {
583 MEDIA_LOGD("OH_OH_LowPowerVideoSinkCallback_Destroy");
584 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
585 return AV_ERR_OK;
586 }
587
OH_LowPowerVideoSinkCallback_SetDataNeededListener(OH_LowPowerVideoSinkCallback * callback,OH_LowPowerVideoSink_OnDataNeeded onDataNeeded,void * userData)588 OH_AVErrCode OH_LowPowerVideoSinkCallback_SetDataNeededListener(
589 OH_LowPowerVideoSinkCallback *callback, OH_LowPowerVideoSink_OnDataNeeded onDataNeeded, void *userData)
590 {
591 MEDIA_LOGD("OH_LowPowerVideoSinkCallback_SetDataNeededListener");
592 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
593 CHECK_AND_RETURN_RET_LOG(onDataNeeded != nullptr, AV_ERR_INVALID_VAL, "onDataNeeded is nullptr!");
594 int32_t res = callback->SetDataNeededListener(onDataNeeded, userData);
595 return LppMsErrToOHAvErr(res);
596 }
597
OH_LowPowerVideoSinkCallback_SetErrorListener(OH_LowPowerVideoSinkCallback * callback,OH_LowPowerVideoSink_OnError onError,void * userData)598 OH_AVErrCode OH_LowPowerVideoSinkCallback_SetErrorListener(
599 OH_LowPowerVideoSinkCallback *callback, OH_LowPowerVideoSink_OnError onError, void *userData)
600 {
601 MEDIA_LOGD("OH_LowPowerVideoSinkCallback_SetErrorListener");
602 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
603 CHECK_AND_RETURN_RET_LOG(onError != nullptr, AV_ERR_INVALID_VAL, "onError is nullptr!");
604 int32_t res = callback->SetErrorListener(onError, userData);
605 return LppMsErrToOHAvErr(res);
606 }
607
OH_LowPowerVideoSinkCallback_SetRenderStartListener(OH_LowPowerVideoSinkCallback * callback,OH_LowPowerVideoSink_OnRenderStarted onRenderStarted,void * userData)608 OH_AVErrCode OH_LowPowerVideoSinkCallback_SetRenderStartListener(
609 OH_LowPowerVideoSinkCallback *callback, OH_LowPowerVideoSink_OnRenderStarted onRenderStarted, void *userData)
610 {
611 MEDIA_LOGD("OH_LowPowerVideoSinkCallback_SetRenderStartListener");
612 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
613 CHECK_AND_RETURN_RET_LOG(onRenderStarted != nullptr, AV_ERR_INVALID_VAL, "onRenderStarted is nullptr!");
614 int32_t res = callback->SetRenderStartListener(onRenderStarted, userData);
615 return LppMsErrToOHAvErr(res);
616 }
617
OH_LowPowerVideoSinkCallback_SetEosListener(OH_LowPowerVideoSinkCallback * callback,OH_LowPowerVideoSink_OnEos onEos,void * userData)618 OH_AVErrCode OH_LowPowerVideoSinkCallback_SetEosListener(
619 OH_LowPowerVideoSinkCallback *callback, OH_LowPowerVideoSink_OnEos onEos, void *userData)
620 {
621 MEDIA_LOGD("OH_LowPowerVideoSinkCallback_SetEosListener");
622 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
623 CHECK_AND_RETURN_RET_LOG(onEos != nullptr, AV_ERR_INVALID_VAL, "onEos is nullptr!");
624 int32_t res = callback->SetEosListener(onEos, userData);
625 return LppMsErrToOHAvErr(res);
626 }
627
OH_LowPowerVideoSinkCallback_SetStreamChangedListener(OH_LowPowerVideoSinkCallback * callback,OH_LowPowerVideoSink_OnStreamChanged onStreamChanged,void * userData)628 OH_AVErrCode OH_LowPowerVideoSinkCallback_SetStreamChangedListener(
629 OH_LowPowerVideoSinkCallback *callback, OH_LowPowerVideoSink_OnStreamChanged onStreamChanged, void *userData)
630 {
631 MEDIA_LOGD("OH_LowPowerVideoSinkCallback_SetStreamChangedListener");
632 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
633 CHECK_AND_RETURN_RET_LOG(onStreamChanged != nullptr, AV_ERR_INVALID_VAL, "onStreamChanged is nullptr!");
634 int32_t res = callback->SetStreamChangedListener(onStreamChanged, userData);
635 return LppMsErrToOHAvErr(res);
636 }
OH_LowPowerVideoSinkCallback_SetFirstFrameDecodedListener(OH_LowPowerVideoSinkCallback * callback,OH_LowPowerVideoSink_OnFirstFrameDecoded onFirstFrameDecoded,void * userData)637 OH_AVErrCode OH_LowPowerVideoSinkCallback_SetFirstFrameDecodedListener(OH_LowPowerVideoSinkCallback *callback,
638 OH_LowPowerVideoSink_OnFirstFrameDecoded onFirstFrameDecoded, void *userData)
639 {
640 MEDIA_LOGD("OH_LowPowerVideoSinkCallback_SetFirstFrameDecodedListener");
641 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_ERR_INVALID_VAL, "callback is nullptr!");
642 CHECK_AND_RETURN_RET_LOG(onFirstFrameDecoded != nullptr, AV_ERR_INVALID_VAL, "onFirstFrameDecoded is nullptr!");
643 int32_t res = callback->SetFirstFrameReadyListener(onFirstFrameDecoded, userData);
644 return LppMsErrToOHAvErr(res);
645 }
646