1 /*
2 * Copyright (c) 2020-2021 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 "liteplayer.h"
17
18 #include "hi_liteplayer_err.h"
19 #include "liteplayer_comm.h"
20 #include <sys/prctl.h>
21 #include <sys/time.h>
22 #include <unistd.h>
23 #include "decoder.h"
24
25 using OHOS::Media::PlayerSource;
26 using OHOS::Media::SinkManager;
27 using OHOS::Media::Decoder;
28
29 namespace OHOS {
30 namespace Media {
31 /* DEFAULT_VID_BUFSIZE: 2 * 1024 * 1024 */
32 const uint32_t DEFAULT_VID_BUFSIZE = 2097152;
33 /* DEFAULT_AUD_BUFSIZE: 256 * 1024 */
34 const uint32_t DEFAULT_AUD_BUFSIZE = 262144;
35
36 const uint32_t GET_BUFFER_TIMEOUT_MS = 0u;
37 const uint32_t RENDER_FULL_SLEEP_TIME_US = 5000u;
38 const uint32_t RENDER_EOS_SLEEP_TIME_US = 3000000u;
39 const uint32_t PAUSE_WAIT_TIME_US = 10000u;
40 const uint32_t DECODER_DEFAULT_WIDTH = 1920;
41 const uint32_t DECODER_DEFAULT_HEIGHT = 1080;
42 const uint32_t QUEUE_BUFFER_FULL_SLEEP_TIME_US = 5000u;
43 const uint32_t NO_DATA_READ_SLEEP_TIME_US = 5000u;
44 const uint32_t MAX_EVENT_MESSAGE_NUM = 128;
45
46 struct CodecFormatAndMimePair {
47 CodecFormat format;
48 AvCodecMime mime;
49 };
50
51 static CodecFormatAndMimePair g_avCodecFormatInfo[CODEC_BUT + 1] = {
52 {CODEC_H264, MEDIA_MIMETYPE_VIDEO_AVC},
53 {CODEC_H265, MEDIA_MIMETYPE_VIDEO_HEVC},
54 {CODEC_JPEG, MEDIA_MIMETYPE_IMAGE_JPEG},
55 {CODEC_AAC, MEDIA_MIMETYPE_AUDIO_AAC},
56 {CODEC_G711A, MEDIA_MIMETYPE_AUDIO_G711A},
57 {CODEC_G711U, MEDIA_MIMETYPE_AUDIO_G711U},
58 {CODEC_PCM, MEDIA_MIMETYPE_AUDIO_PCM},
59 {CODEC_MP3, MEDIA_MIMETYPE_AUDIO_MP3},
60 {CODEC_G726, MEDIA_MIMETYPE_AUDIO_G726},
61 {CODEC_BUT, MEDIA_MIMETYPE_INVALID},
62 };
63
64 namespace {
65 /* playing position notify interval in ms */
66 const uint32_t DEFAULT_POS_NOFITY_INTERVAL = 300;
67 }
68
69 #define CHECK_NULL_RETURN(value, ret, printfString) \
70 do { \
71 if ((value) == nullptr) { \
72 MEDIA_ERR_LOG("%s", printfString ? printfString : " "); \
73 return (ret); \
74 } \
75 } while (0)
76
77 #define CHECK_NULL_RETURN_VOID(value, printfString) \
78 do { \
79 if ((value) == nullptr) { \
80 MEDIA_ERR_LOG("%s", printfString ? printfString : " "); \
81 return; \
82 } \
83 } while (0)
84
85 #define CHECK_FAILED_RETURN(value, target, ret, printfString) \
86 do { \
87 if ((value) != (target)) { \
88 MEDIA_ERR_LOG("%s",printfString ? printfString : " "); \
89 return ret; \
90 } \
91 } while (0)
92
93 #define CHECK_FAILED_PRINT(value, target, printfString) \
94 do { \
95 if ((value) != (target)) { \
96 MEDIA_ERR_LOG("%s",printfString ? printfString : " "); \
97 } \
98 } while (0)
99
100
101 #define CHECK_STATE_SAME(srcState, dstState) \
102 do { \
103 if ((dstState) == (srcState)) { \
104 MEDIA_INFO_LOG("current play state already be %d", (dstState)); \
105 return HI_SUCCESS; \
106 } \
107 } while (0)
108
109 const int32_t SS2US = 1000000;
110
CondTimeWait(pthread_cond_t & cond,pthread_mutex_t & mutex,uint32_t delayUs)111 static void CondTimeWait(pthread_cond_t &cond, pthread_mutex_t &mutex, uint32_t delayUs)
112 {
113 uint32_t tmpUs;
114 struct timeval ts;
115 struct timespec outtime;
116
117 ts.tv_sec = 0;
118 ts.tv_usec = 0;
119 gettimeofday(&ts , nullptr);
120 ts.tv_sec += (delayUs / SS2US);
121 tmpUs = delayUs % SS2US;
122
123 if (ts.tv_usec + tmpUs > SS2US) {
124 outtime.tv_sec = ts.tv_sec + 1;
125 outtime.tv_nsec = ((ts.tv_usec + tmpUs) - SS2US) * 1000;
126 } else {
127 outtime.tv_sec = ts.tv_sec;
128 outtime.tv_nsec = (ts.tv_usec + tmpUs) * 1000;
129 }
130 pthread_cond_timedwait(&cond, &mutex, &outtime);
131 }
132
GetCurVideoSolution(FormatFileInfo & info,uint32_t & width,uint32_t & height)133 static void GetCurVideoSolution(FormatFileInfo &info, uint32_t &width, uint32_t &height)
134 {
135 for (int i = 0; i < HI_DEMUXER_RESOLUTION_CNT; i++) {
136 if (info.stSteamResolution[i].s32VideoStreamIndex == info.s32UsedVideoStreamIndex) {
137 width = info.stSteamResolution[i].u32Width;
138 height = info.stSteamResolution[i].u32Height;
139 break;
140 }
141 }
142 }
143
PlayerControl()144 PlayerControl::PlayerControl() : stateMachine_(nullptr), observer_(nullptr), isInited_(false), isNeedPause_(false),
145 pauseMode_(false), isPlayEnd_(false), isVidPlayEos_(false),
146 isAudPlayEos_(false), cachedPacket_(false), lastRendPos_(0), lastNotifyTime_(0),
147 tplayMode_(PLAYER_TPLAY_ONLY_I_FRAME), lastReadPktStrmIdx_(-1), lastReadPktPts_(0), lastSendPktPts_(0),
148 curSeekOffset_(0), isVideoStarted_(false), isAudioStarted_(false), isVidContinueLost_(false),
149 strmReadEnd_(false), isPlayErr_(false), isTplayLastFrame_(false), isTplayStartRead_(false),
150 lastSendVdecPts_(AV_INVALID_PTS), lastSendAdecPts_(AV_INVALID_PTS), currentPosition_(0), paused_(false),
151 schThreadExit_(false), loop_(false), hasRenderAudioEos_(false), hasRenderVideoEos_(false), renderSleepTime_(0),
152 leftVolume_(-1.0f), rightVolume_(-1.0f), schProcess_(0), seekToTimeMs_(-1), firstAudioFrameAfterSeek_(false),
153 firstVideoFrameAfterSeek_(false), sourceType_(SOURCE_TYPE_BUT), fd_(-1), playerSource_(nullptr),
154 sinkManager_(nullptr), audioDecoder_(nullptr), videoDecoder_(nullptr), audioStreamType_(0)
155 {
156 eventCallback_.player = nullptr;
157 eventCallback_.callbackFun = nullptr;
158 (void)memset_s(&fmtFileInfo_, sizeof(fmtFileInfo_), 0, sizeof(FormatFileInfo));
159 fmtFileInfo_.s32UsedAudioStreamIndex = HI_DEMUXER_NO_MEDIA_STREAM;
160 fmtFileInfo_.s32UsedVideoStreamIndex = HI_DEMUXER_NO_MEDIA_STREAM;
161 playerParam_.u32PlayPosNotifyIntervalMs = DEFAULT_POS_NOFITY_INTERVAL;
162 playerParam_.u32VideoEsBufSize = DEFAULT_POS_NOFITY_INTERVAL;
163 playerParam_.u32AudioEsBufSize = DEFAULT_POS_NOFITY_INTERVAL;
164 playerParam_.u32VdecFrameBufCnt = DEFAULT_POS_NOFITY_INTERVAL;
165 playerParam_.bPauseMode = DEFAULT_POS_NOFITY_INTERVAL;
166 (void)memset_s(&formatPacket_, sizeof(formatPacket_), 0, sizeof(FormatFrame));
167 tplayAttr_.direction = TPLAY_DIRECT_BUTT;
168 tplayAttr_.speed = 1.0;
169 streamAttr_.playMode = RENDER_MODE_NORMAL;
170 streamAttr_.videoBufSize = 0;
171 streamAttr_.audioBufSize = 0;
172 vdecAttr_.type = 0;
173 vdecAttr_.maxWidth = 0;
174 vdecAttr_.maxHeight = 0;
175 vdecAttr_.frameBufCnt = 0;
176 vdecAttr_.errRecover = 0;
177 adecAttr_.type = 0;
178 adecAttr_.sampleRate = 0;
179 adecAttr_.channel = 0;
180 adecAttr_.bitWidth = 0;
181 stream_.ReadData = nullptr;
182 stream_.GetReadableSize = nullptr;
183 stream_.handle = nullptr;
184 surface_ = nullptr;
185 eventQueue.clear();
186 }
187
~PlayerControl()188 PlayerControl::~PlayerControl()
189 {
190 (void)Deinit();
191 if (stateMachine_ != nullptr) {
192 delete stateMachine_;
193 stateMachine_ = nullptr;
194 }
195 if (observer_ != nullptr) {
196 delete observer_;
197 observer_ = nullptr;
198 }
199 eventQueue.clear();
200 }
201
GetState(void)202 PlayerStatus PlayerControl::GetState(void)
203 {
204 CHECK_NULL_RETURN(stateMachine_, PLAY_STATUS_BUTT, "stateMachine_ nullptr");
205 return stateMachine_->GetCurState();
206 }
207
InitAttr(const PlayerControlParam & createParam)208 int32_t PlayerControl::InitAttr(const PlayerControlParam &createParam)
209 {
210 if (memset_s(&fmtFileInfo_, sizeof(fmtFileInfo_), 0x00, sizeof(FormatFileInfo)) != EOK) {
211 MEDIA_ERR_LOG("set fmtFileInfo_ fail\n");
212 return HI_ERR_PLAYERCONTROL_MEM_SET;
213 }
214 fmtFileInfo_.s32UsedAudioStreamIndex = HI_DEMUXER_NO_MEDIA_STREAM;
215 fmtFileInfo_.s32UsedVideoStreamIndex = HI_DEMUXER_NO_MEDIA_STREAM;
216 streamAttr_.playMode = RENDER_MODE_NORMAL;
217 streamAttr_.videoBufSize = DEFAULT_VID_BUFSIZE;
218 streamAttr_.audioBufSize = DEFAULT_AUD_BUFSIZE;
219
220 lastReadPktPts_ = 0;
221 lastSendPktPts_ = 0;
222 pauseMode_ = createParam.bPauseMode;
223 CHECK_FAILED_PRINT(memcpy_s(&playerParam_, sizeof(playerParam_), &createParam, sizeof(PlayerControlParam)), EOK,
224 "copy playerParam_ fail");
225 playerParam_.u32PlayPosNotifyIntervalMs = (createParam.u32PlayPosNotifyIntervalMs == 0) ?
226 DEFAULT_POS_NOFITY_INTERVAL : createParam.u32PlayPosNotifyIntervalMs;
227 return HI_SUCCESS;
228 }
229
Init(const PlayerControlParam & createParam)230 int32_t PlayerControl::Init(const PlayerControlParam &createParam)
231 {
232 int32_t ret;
233 MEDIA_INFO_LOG("Init in");
234 CHECK_FAILED_RETURN(isInited_, false, HI_SUCCESS, "already be inited");
235 CHECK_FAILED_RETURN(InitAttr(createParam), HI_SUCCESS, HI_FAILURE, "InitAttr failed");
236 stateMachine_ = new(std::nothrow) PlayerControlStateMachine(*this);
237 CHECK_NULL_RETURN(stateMachine_, HI_FAILURE, "new PlayerControlStateMachine failed");
238 observer_ = new(std::nothrow) PlayerControlSMObserver(*this);
239 if (observer_ == nullptr) {
240 MEDIA_ERR_LOG("new PlayerControlSMObserver failed\n");
241 goto DEL_STATE;
242 }
243 (void)stateMachine_->RegisterObserver(*observer_);
244 ret = stateMachine_->Init(MAX_MSG_QUEUE_SIZE, MAX_MSG_QUEUE_PAYLOAD_SIZE);
245 if (ret != HI_SUCCESS) {
246 MEDIA_ERR_LOG("init PlayerControlStateMachine failed\n");
247 goto DEL_OBSERVER;
248 }
249 ret = stateMachine_->Start();
250 if (ret != HI_SUCCESS) {
251 MEDIA_ERR_LOG("start PlayerControlStateMachine failed\n");
252 goto DEINIT_STATE;
253 }
254 pthread_mutex_init(&schMutex_, nullptr);
255 pthread_cond_init(&schCond_, nullptr);
256
257 isInited_ = true;
258 return HI_SUCCESS;
259 DEINIT_STATE:
260 (void)stateMachine_->Deinit();
261 DEL_OBSERVER:
262 delete observer_;
263 observer_ = nullptr;
264 DEL_STATE:
265 delete stateMachine_;
266 stateMachine_ = nullptr;
267 return HI_FAILURE;
268 }
269
Deinit()270 int32_t PlayerControl::Deinit()
271 {
272 if (isInited_ == false) {
273 return HI_SUCCESS;
274 }
275 DestroyDecoder();
276 if (stateMachine_ != nullptr) {
277 MsgInfo msgInfo;
278 CHECK_FAILED_PRINT(memset_s(&msgInfo, sizeof(msgInfo), 0, sizeof(MsgInfo)), EOK, "memset_s failed");
279 msgInfo.what = PLAYERCONTROL_MSG_HANDLEDATA;
280 CHECK_FAILED_PRINT(stateMachine_->RemoveEvent(msgInfo), HI_SUCCESS, "RemoveEvent failed");
281 CHECK_FAILED_PRINT(stateMachine_->Stop(), HI_SUCCESS, "Stop failed");
282 CHECK_FAILED_PRINT(stateMachine_->Deinit(), HI_SUCCESS, "Deinit failed");
283 if (observer_ != nullptr) {
284 delete observer_;
285 observer_ = nullptr;
286 }
287 delete stateMachine_;
288 stateMachine_ = nullptr;
289 }
290 pthread_mutex_destroy(&schMutex_);
291 pthread_cond_destroy(&schCond_);
292 isInited_ = false;
293 return HI_SUCCESS;
294 }
295
RegCallback(PlayerCtrlCallbackParam & eventObserver)296 int32_t PlayerControl::RegCallback(PlayerCtrlCallbackParam &eventObserver)
297 {
298 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
299 MsgInfo msg;
300 msg.what = PLAYERCONTROL_MSG_REGCALLBACK;
301 msg.msgData = reinterpret_cast<void *>(&eventObserver);
302 msg.msgDataLen = 0;
303 return stateMachine_->Send(msg);
304 }
305
SetDataSource(const std::string filePath)306 int32_t PlayerControl::SetDataSource(const std::string filePath)
307 {
308 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
309 MsgInfo msg;
310 msg.what = PLAYERCONTROL_MSG_SET_DATASOURCE_URI;
311 msg.msgData = const_cast<void *>(reinterpret_cast<const void *>(filePath.c_str()));
312 msg.msgDataLen = 0;
313 return stateMachine_->Send(msg);
314 }
315
SetDataSource(const int fd)316 int32_t PlayerControl::SetDataSource(const int fd)
317 {
318 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
319 int mediaFd = fd;
320 MsgInfo msg;
321 msg.what = PLAYERCONTROL_MSG_SET_DATASOURCE_FD;
322 msg.msgData = reinterpret_cast<void *>(&mediaFd);
323 msg.msgDataLen = 0;
324 return stateMachine_->Send(msg);
325 }
326
SetDataSource(BufferStream & stream)327 int32_t PlayerControl::SetDataSource(BufferStream &stream)
328 {
329 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
330 MsgInfo msg;
331 msg.what = PLAYERCONTROL_MSG_SET_DATASOURCE_STREAM;
332 msg.msgData = reinterpret_cast<void *>(&stream);
333 msg.msgDataLen = 0;
334 return stateMachine_->Send(msg);
335 }
336
Prepare()337 int32_t PlayerControl::Prepare()
338 {
339 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
340 return stateMachine_->Send(PLAYERCONTROL_MSG_PREPARE);
341 }
342
Play()343 int32_t PlayerControl::Play()
344 {
345 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
346 int32_t ret = stateMachine_->Send(PLAYERCONTROL_MSG_PLAY);
347 CHECK_FAILED_PRINT(ret, HI_SUCCESS, "play failed");
348 return ret;
349 }
350
SetVolume(VolumeAttr & volumeAttr)351 int32_t PlayerControl::SetVolume(VolumeAttr &volumeAttr)
352 {
353 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
354 VolumeAttr attr = volumeAttr;
355 MsgInfo msg;
356 msg.what = PLAYERCONTROL_MSG_SET_VOLUME;
357 msg.msgData = reinterpret_cast<void *>(&attr);
358 msg.msgDataLen = 0;
359 return stateMachine_->Send(msg);
360 }
361
Stop()362 int32_t PlayerControl::Stop()
363 {
364 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
365 return stateMachine_->Send(PLAYERCONTROL_MSG_STOP);
366 }
367
Pause()368 int32_t PlayerControl::Pause()
369 {
370 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
371 return stateMachine_->Send(PLAYERCONTROL_MSG_PAUSE);
372 }
373
Seek(int64_t timeInMs)374 int32_t PlayerControl::Seek(int64_t timeInMs)
375 {
376 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
377 if (fmtFileInfo_.enVideoType == CODEC_JPEG) {
378 MEDIA_ERR_LOG("seek action not support for play picture");
379 return HI_ERR_PLAYERCONTROL_NOT_SUPPORT;
380 }
381 if ((fmtFileInfo_.s64Duration > 0) && (fmtFileInfo_.s64Duration < timeInMs)) {
382 return HI_ERR_PLAYERCONTROL_ILLEGAL_PARAM;
383 }
384 if (!stateMachine_->EventValidAtCurState(PLAYERCONTROL_MSG_SEEK)) {
385 MEDIA_ERR_LOG("invalid event seek at current state");
386 return HI_ERR_PLAYERCONTROL_ILLEGAL_STATE_ACTION;
387 }
388
389 if (seekTabel_[0] == -1) {
390 seekTabel_[0] = timeInMs;
391 } else if (seekTabel_[1] == -1) {
392 seekTabel_[1] = timeInMs;
393 }
394 MEDIA_INFO_LOG("seek out %lld", timeInMs);
395 return HI_SUCCESS;
396 }
397
GetFileInfo(FormatFileInfo & formatInfo)398 int32_t PlayerControl::GetFileInfo(FormatFileInfo &formatInfo)
399 {
400 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
401 MsgInfo msg;
402 msg.what = PLAYERCONTROL_MSG_GETFILEINFO;
403 msg.msgData = &formatInfo;
404 msg.msgDataLen = sizeof(FormatFileInfo);
405 return stateMachine_->Send(msg);
406 }
407
SetMedia(PlayerControlStreamAttr & mediaAttr)408 int32_t PlayerControl::SetMedia(PlayerControlStreamAttr &mediaAttr)
409 {
410 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
411 MsgInfo msg;
412 msg.what = PLAYERCONTROL_MSG_SETATTR;
413 msg.msgData = &mediaAttr;
414 msg.msgDataLen = sizeof(PlayerControlStreamAttr);
415 return stateMachine_->Send(msg);
416 }
417
SetSurface(Surface * surface)418 int32_t PlayerControl::SetSurface(Surface *surface)
419 {
420 surface_ = surface;
421 return 0;
422 }
423
TPlay(TplayAttr tplayAttr)424 int32_t PlayerControl::TPlay(TplayAttr tplayAttr)
425 {
426 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
427 MsgInfo msg;
428 msg.what = PLAYERCONTROL_MSG_TPLAY;
429 msg.msgData = &tplayAttr;
430 msg.msgDataLen = sizeof(TplayAttr);
431 return stateMachine_->Send(msg);
432 }
433
ClearCachePacket()434 void PlayerControl::ClearCachePacket()
435 {
436 if (cachedPacket_) {
437 if (formatPacket_.data != nullptr) {
438 if (playerSource_!= nullptr && playerSource_->FreeFrame(formatPacket_) != 0) {
439 MEDIA_ERR_LOG("FreeFrame failed");
440 }
441 formatPacket_.data = nullptr;
442 formatPacket_.len = 0;
443 formatPacket_.trackId = -1;
444 }
445 /* end packet is null do not need to demux free */
446 cachedPacket_ = false;
447 }
448 }
449
OnVideoEndOfStream()450 void PlayerControl::OnVideoEndOfStream()
451 {
452 CHECK_NULL_RETURN_VOID(stateMachine_, "stateMachine_ nullptr");
453 if ((fmtFileInfo_.s32UsedAudioStreamIndex == HI_DEMUXER_NO_MEDIA_STREAM ||
454 stateMachine_->GetCurState() == PLAY_STATUS_TPLAY) &&
455 lastSendVdecPts_ > AV_INVALID_PTS) {
456 EventCallback(PLAYERCONTROL_EVENT_PROGRESS, &lastSendVdecPts_);
457 }
458 isVidPlayEos_ = true;
459 isPlayEnd_ = IsPlayEos() ? true : isPlayEnd_;
460 }
461
EventProcess(EventCbType event)462 void PlayerControl::EventProcess(EventCbType event)
463 {
464 PlayerControlError playerError;
465 MEDIA_DEBUG_LOG("handleEvent %d", event);
466
467 switch (event) {
468 case EVNET_VIDEO_PLAY_EOS:
469 OnVideoEndOfStream();
470 break;
471 case EVNET_VIDEO_PLAY_SOS:
472 MEDIA_INFO_LOG("video sos recv");
473 break;
474 case EVNET_AUDIO_PLAY_EOS:
475 CHECK_NULL_RETURN_VOID(stateMachine_, "stateMachine_ nullptr");
476 if (stateMachine_->GetCurState() != PLAY_STATUS_TPLAY) {
477 isAudPlayEos_ = true;
478 isPlayEnd_ = IsPlayEos() ? true : isPlayEnd_;
479 if (lastSendAdecPts_ > AV_INVALID_PTS) {
480 EventCallback(PLAYERCONTROL_EVENT_PROGRESS, &lastSendAdecPts_);
481 }
482 }
483 break;
484 case EVNET_VIDEO_RUNNING_ERR:
485 case EVNET_AUDIO_RUNNING_ERR:
486 playerError = PLAYERCONTROL_ERROR_VID_PLAY_FAIL;
487 isPlayErr_ = true;
488 EventCallback(PLAYERCONTROL_EVENT_ERROR, &playerError);
489 break;
490 case EVNET_FRAME_CONTINUE_LOST:
491 isVidContinueLost_ = true;
492 MEDIA_INFO_LOG("receive frame continue lost");
493 break;
494 case EVNET_ON_JPEG_FRAME_RENDED:
495 break;
496 case EVNET_FIRST_VIDEO_REND:
497 if (pauseMode_) {
498 MEDIA_INFO_LOG("first video rended");
499 isNeedPause_ = true;
500 EventCallback(PLAYERCONTROL_FIRST_VIDEO_FRAME, NULL);
501 }
502 break;
503 case EVNET_FIRST_AUDIO_REND:
504 if (pauseMode_ && fmtFileInfo_.s32UsedVideoStreamIndex == -1) {
505 MEDIA_INFO_LOG("first audio rended");
506 isNeedPause_ = true;
507 EventCallback(PLAYERCONTROL_FIRST_AUDIO_FRAME, NULL);
508 }
509 break;
510 default:
511 break;
512 }
513 }
514
EventQueueProcess(void)515 void PlayerControl::EventQueueProcess(void)
516 {
517 size_t queSize;
518 PalayControlEventItem *item = nullptr;
519
520 queSize = eventQueue.size();
521 if (queSize > MAX_EVENT_MESSAGE_NUM) {
522 MEDIA_WARNING_LOG("mesaage except, num:%u", queSize);
523 }
524 for (size_t i = 0; i < queSize && i < MAX_EVENT_MESSAGE_NUM; i++) {
525 item = &eventQueue[i];
526 EventProcess(item->event);
527 }
528 eventQueue.clear();
529 }
530
OnPlayControlEvent(void * priv,const EventCbType event)531 int32_t PlayerControl::OnPlayControlEvent(void *priv, const EventCbType event)
532 {
533 PalayControlEventItem item;
534 PlayerControl *player = reinterpret_cast<PlayerControl *>(priv);
535
536 item.event = event;
537 player->eventQueue.push_back(item);
538 return HI_SUCCESS;
539 }
540
PauseResume(void)541 int32_t PlayerControl::PauseResume(void)
542 {
543 CHECK_NULL_RETURN(sinkManager_, HI_ERR_PLAYERCONTROL_NULL_PTR, "sinkManager_ nullptr");
544 int32_t ret = sinkManager_->Resume();
545 if (ret != HI_SUCCESS) {
546 MEDIA_ERR_LOG("resume failed");
547 }
548 pthread_mutex_lock(&schMutex_);
549 paused_ = false;
550 pthread_cond_signal(&schCond_);
551 pthread_mutex_unlock(&schMutex_);
552 return HI_SUCCESS;
553 }
554
TPlayResume(void)555 int32_t PlayerControl::TPlayResume(void)
556 {
557 CHECK_NULL_RETURN(sinkManager_, HI_ERR_PLAYERCONTROL_NULL_PTR, "sinkManager_ nullptr");
558 int32_t ret = sinkManager_->SetSpeed(1.0, tplayAttr_.direction);
559 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "SetSpeed failed");
560 return HI_SUCCESS;
561 }
562
OnSwitchTPlay2Play()563 int32_t PlayerControl::OnSwitchTPlay2Play()
564 {
565 int32_t ret;
566 CHECK_NULL_RETURN(playerSource_, HI_FAILURE, "playerSource_ nullptr");
567
568 pthread_mutex_lock(&schMutex_);
569 if (tplayMode_ != PLAYER_TPLAY_FULL_PLAY) {
570 ret = TPlayResetBuffer();
571 if (ret != HI_SUCCESS) {
572 MEDIA_ERR_LOG("TPlayResetBuffer failed , ret:%d", ret);
573 pthread_mutex_unlock(&schMutex_);
574 return ret;
575 }
576 ret = playerSource_->Seek(fmtFileInfo_.s32UsedVideoStreamIndex, lastReadPktPts_, FORMAT_SEEK_MODE_FORWARD_KEY);
577 if (ret != HI_SUCCESS) {
578 MEDIA_ERR_LOG("playerSource_ seek failed , ret:%d", ret);
579 pthread_mutex_unlock(&schMutex_);
580 return ret;
581 }
582 strmReadEnd_ = false;
583 isVidPlayEos_ = false;
584 isAudPlayEos_ = false;
585 hasRenderVideoEos_ = false;
586 hasRenderAudioEos_ = false;
587 }
588 firstAudioFrameAfterSeek_ = true;
589 firstVideoFrameAfterSeek_ = true;
590
591 ret = TPlayResume();
592 pthread_mutex_unlock(&schMutex_);
593 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "TPlayResume failed");
594 return HI_SUCCESS;
595 }
596
CheckMediaInfo(void)597 int32_t PlayerControl::CheckMediaInfo(void)
598 {
599 if (fmtFileInfo_.s32UsedAudioStreamIndex >= HI_DEMUXER_RESOLUTION_CNT
600 || fmtFileInfo_.s32UsedVideoStreamIndex >= HI_DEMUXER_RESOLUTION_CNT) {
601 MEDIA_ERR_LOG("input file error video track: %d audio %d",
602 fmtFileInfo_.s32UsedVideoStreamIndex, fmtFileInfo_.s32UsedAudioStreamIndex);
603 return HI_ERR_PLAYERCONTROL_DEMUX_ERROR;
604 }
605 if (CheckMediaType(fmtFileInfo_) != HI_SUCCESS) {
606 return HI_ERR_PLAYERCONTROL_NOT_SUPPORT;
607 }
608 return HI_SUCCESS;
609 }
610
SetVDecAttr(void)611 int32_t PlayerControl::SetVDecAttr(void)
612 {
613 StreamResolution resolution = { 0 };
614 if (GetVideoResolution(fmtFileInfo_.s32UsedVideoStreamIndex, resolution) != HI_SUCCESS) {
615 MEDIA_ERR_LOG("GetVideoResolution failed");
616 return HI_FAILURE;
617 }
618 vdecAttr_.maxWidth = resolution.u32Width;
619 vdecAttr_.maxHeight = resolution.u32Height;
620 vdecAttr_.type = resolution.enVideoType;
621 vdecAttr_.frameBufCnt = playerParam_.u32VdecFrameBufCnt;
622 return HI_SUCCESS;
623 }
624
SetADecAttr(void)625 int32_t PlayerControl::SetADecAttr(void)
626 {
627 adecAttr_.bitWidth = AUDIO_BITWIDTH;
628 adecAttr_.channel = fmtFileInfo_.u32AudioChannelCnt;
629 adecAttr_.sampleRate = fmtFileInfo_.u32SampleRate;
630 adecAttr_.type = fmtFileInfo_.enAudioType;
631 return HI_SUCCESS;
632 }
633
SetStreamAttr()634 int32_t PlayerControl::SetStreamAttr()
635 {
636 if (pauseMode_) {
637 streamAttr_.playMode = RENDER_MODE_PAUSE_AFTER_PLAY;
638 }
639 if (fmtFileInfo_.s32UsedVideoStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM) {
640 StreamResolution resolution = { 0 };
641 if (GetVideoResolution(fmtFileInfo_.s32UsedVideoStreamIndex, resolution) != HI_SUCCESS) {
642 MEDIA_ERR_LOG("GetVideoResolution failed");
643 return HI_ERR_PLAYERCONTROL_ILLEGAL_PARAM;
644 }
645 streamAttr_.videoBufSize = playerParam_.u32VideoEsBufSize;
646 }
647 if (fmtFileInfo_.s32UsedAudioStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM) {
648 streamAttr_.audioBufSize = (playerParam_.u32AudioEsBufSize) ? (playerParam_.u32AudioEsBufSize) :
649 streamAttr_.audioBufSize;
650 }
651
652 if (sinkManager_ != nullptr) {
653 sinkManager_->SetRenderMode(streamAttr_.playMode);
654 }
655 return HI_SUCCESS;
656 }
657
SetDecoderAndStreamAttr(void)658 int32_t PlayerControl::SetDecoderAndStreamAttr(void)
659 {
660 int ret;
661
662 if (fmtFileInfo_.s32UsedAudioStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM) {
663 ret = SetADecAttr();
664 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "SetADecAttr failed");
665 }
666 if (fmtFileInfo_.s32UsedVideoStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM) {
667 ret = SetVDecAttr();
668 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "SetVDecAttr failed");
669 }
670 ret = SetStreamAttr();
671 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "SetStreamAttr failed");
672 return HI_SUCCESS;
673 }
674
TransformCodecFormatToAvCodecMime(CodecFormat format)675 static AvCodecMime TransformCodecFormatToAvCodecMime(CodecFormat format)
676 {
677 AvCodecMime mime = MEDIA_MIMETYPE_INVALID;
678 uint32_t size = sizeof(g_avCodecFormatInfo) / sizeof(CodecFormatAndMimePair);
679
680 for (uint32_t i = 0; i < size; i++) {
681 if (g_avCodecFormatInfo[i].format == format) {
682 mime = g_avCodecFormatInfo[i].mime;
683 break;
684 }
685 }
686
687 return mime;
688 }
689
GetAudioNameByAvCodecMime(AvCodecMime mime)690 static std::string GetAudioNameByAvCodecMime(AvCodecMime mime)
691 {
692 std::string audioName = "codec.unknow.soft.decoder";
693 switch (mime) {
694 case MEDIA_MIMETYPE_AUDIO_AAC:
695 audioName = "codec.aac.soft.decoder";
696 break;
697 case MEDIA_MIMETYPE_AUDIO_MP3:
698 audioName = "codec.mp3.soft.decoder";
699 break;
700 case MEDIA_MIMETYPE_AUDIO_PCM:
701 audioName = "codec.pcm16s.soft.decoder";
702 break;
703 default:
704 MEDIA_ERR_LOG("not support codec type:%d", mime);
705 break;
706 }
707 return audioName;
708 }
709
AudioDecoderStart(void)710 int32_t PlayerControl::AudioDecoderStart(void)
711 {
712 AvCodecMime mime = TransformCodecFormatToAvCodecMime(fmtFileInfo_.enAudioType);
713 if (mime == MEDIA_MIMETYPE_INVALID) {
714 MEDIA_ERR_LOG("DecoderStart not support codec:%d", fmtFileInfo_.enAudioType);
715 return -1;
716 }
717 audioDecoder_ = std::make_shared<Decoder>();
718 CHECK_NULL_RETURN(audioDecoder_, -1, "new decoder failed");
719 AvAttribute attr;
720 attr.type = AUDIO_DECODER;
721 attr.adecAttr.mime = mime;
722 attr.adecAttr.priv = nullptr;
723 attr.adecAttr.bufSize = 0x400; /* 1024 */
724 attr.adecAttr.channelCnt = (mime == MEDIA_MIMETYPE_AUDIO_PCM) ? fmtFileInfo_.u32AudioChannelCnt : 0;
725 const std::string audioName = GetAudioNameByAvCodecMime(mime);
726 int32_t ret = audioDecoder_->CreateHandle(audioName, attr);
727 CHECK_FAILED_RETURN(ret, 0, -1, "create audio decoder failed");
728 ret = audioDecoder_->StartDec();
729 CHECK_FAILED_RETURN(ret, 0, -1, "start audio decoder failed");
730 MEDIA_INFO_LOG("audio decoder started");
731
732 return 0;
733 }
734
VideoDecoderStart(void)735 int32_t PlayerControl::VideoDecoderStart(void)
736 {
737 AvAttribute attr;
738 uint32_t width = DECODER_DEFAULT_WIDTH;
739 uint32_t height = DECODER_DEFAULT_HEIGHT;
740
741 AvCodecMime mime = TransformCodecFormatToAvCodecMime(fmtFileInfo_.enVideoType);
742 if (mime == MEDIA_MIMETYPE_INVALID) {
743 MEDIA_ERR_LOG("DecoderStart not support codec:%d", fmtFileInfo_.enVideoType);
744 return -1;
745 }
746 GetCurVideoSolution(fmtFileInfo_, width, height);
747
748 videoDecoder_ = std::make_shared<Decoder>();
749 CHECK_NULL_RETURN(videoDecoder_, -1, "new decoder failed");
750 attr.type = VIDEO_DECODER;
751 attr.vdecAttr.mime = mime;
752 attr.vdecAttr.priv = nullptr;
753 attr.vdecAttr.bufSize = 0;
754 attr.vdecAttr.maxWidth = width;
755 attr.vdecAttr.maxHeight = height;
756 const std::string videoName = "codec.avc.soft.decoder";
757 int32_t ret = videoDecoder_->CreateHandle(videoName, attr);
758 CHECK_FAILED_RETURN(ret, 0, -1, "create video decoder failed");
759 ret = videoDecoder_->StartDec();
760 CHECK_FAILED_RETURN(ret, 0, -1, "start video decoder failed");
761 MEDIA_INFO_LOG("video decoder started");
762
763 return 0;
764 }
765
DecoderStart(void)766 int32_t PlayerControl::DecoderStart(void)
767 {
768 if (fmtFileInfo_.s32UsedAudioStreamIndex == -1 && fmtFileInfo_.s32UsedVideoStreamIndex == -1) {
769 MEDIA_ERR_LOG("not decoder need start");
770 return -1;
771 }
772 MEDIA_INFO_LOG("PlayerControl::DecoderStart streamid:%d-%d",
773 fmtFileInfo_.s32UsedAudioStreamIndex, fmtFileInfo_.s32UsedVideoStreamIndex);
774 if (fmtFileInfo_.s32UsedAudioStreamIndex != -1) {
775 if (AudioDecoderStart() != 0) {
776 return -1;
777 }
778 }
779 if (fmtFileInfo_.s32UsedVideoStreamIndex != -1) {
780 if (VideoDecoderStart() != 0) {
781 return -1;
782 }
783 }
784 return 0;
785 }
786
DestroyDecoder()787 void PlayerControl::DestroyDecoder()
788 {
789 if (audioDecoder_ != nullptr) {
790 audioDecoder_->DestroyHandle();
791 }
792 if (videoDecoder_ != nullptr) {
793 videoDecoder_->DestroyHandle();
794 }
795 }
796
StopSinkAndDecoder()797 void PlayerControl::StopSinkAndDecoder()
798 {
799 PlayerBufferInfo outInfo;
800
801 if (sinkManager_ != nullptr) {
802 sinkManager_->Stop();
803 }
804 if (audioDecoder_ != nullptr && sinkManager_ != nullptr) {
805 while (sinkManager_->DequeReleaseFrame(true, outInfo) == 0) {
806 audioDecoder_->QueueOutputBuffer((CodecBuffer *)&outInfo, GET_BUFFER_TIMEOUT_MS);
807 }
808 audioDecoder_->StopDec();
809 }
810 if (videoDecoder_ != nullptr && sinkManager_ != nullptr) {
811 while (sinkManager_->DequeReleaseFrame(false, outInfo) == 0) {
812 videoDecoder_->QueueOutputBuffer((CodecBuffer *)&outInfo, GET_BUFFER_TIMEOUT_MS);
813 }
814 videoDecoder_->StopDec();
815 }
816 isVideoStarted_ = false;
817 isAudioStarted_ = false;
818 }
819
820
AddAudioSink(void)821 int32_t PlayerControl::AddAudioSink(void)
822 {
823 CHECK_FAILED_RETURN(isAudioStarted_, false, HI_SUCCESS, "already started");
824 SinkAttr attr;
825 attr.sinkType = SINK_TYPE_AUDIO;
826 attr.trackId = fmtFileInfo_.s32UsedAudioStreamIndex;
827 attr.audAttr.format = fmtFileInfo_.enAudioType;
828 attr.audAttr.sampleFmt = DATA_TYPE_S16;
829 attr.audAttr.sampleRate = adecAttr_.sampleRate;
830 attr.audAttr.channel = fmtFileInfo_.u32AudioChannelCnt;
831 attr.audAttr.volume = 0x6;
832
833 if (sinkManager_->AddNewSink(attr) != 0) {
834 MEDIA_ERR_LOG("AddNewSink failed");
835 return -1;
836 }
837 isAudioStarted_ = true;
838 return HI_SUCCESS;
839 }
840
AddVideoSink()841 int32_t PlayerControl::AddVideoSink()
842 {
843 CHECK_FAILED_RETURN(isVideoStarted_, false, HI_SUCCESS, "already started");
844 SinkAttr attr;
845 attr.sinkType = SINK_TYPE_VIDEO;
846 attr.trackId = fmtFileInfo_.s32UsedVideoStreamIndex;
847 attr.vidAttr.width = fmtFileInfo_.u32Width;
848 attr.vidAttr.height = fmtFileInfo_.u32Height;
849 attr.vidAttr.frameRate = fmtFileInfo_.fFrameRate;
850 attr.vidAttr.format = fmtFileInfo_.enVideoType;
851 attr.vidAttr.surface = surface_;
852 if (sinkManager_->AddNewSink(attr) != 0) {
853 MEDIA_ERR_LOG("AddNewSink failed");
854 return -1;
855 }
856 isVideoStarted_ = true;
857 return HI_SUCCESS;
858 }
859
860
SinkStart(void)861 int32_t PlayerControl::SinkStart(void)
862 {
863 int32_t ret = HI_SUCCESS;
864 sinkManager_ = std::make_shared<SinkManager>();
865 CHECK_NULL_RETURN(sinkManager_, HI_FAILURE, "new sinkManager_ nullptr");
866 if (fmtFileInfo_.s32UsedVideoStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM && !isVideoStarted_) {
867 ret = AddVideoSink();
868 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "AddVideoSink failed");
869 isVideoStarted_ = true;
870 }
871 if (fmtFileInfo_.s32UsedAudioStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM && !isAudioStarted_) {
872 ret = AddAudioSink();
873 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "AddAudioSink failed");
874 isAudioStarted_ = true;
875 sinkManager_->SetAudioStreamType(audioStreamType_);
876 }
877
878 PlayEventCallback callback;
879 GetPlayElementEventCallBack(callback);
880 ret = sinkManager_->RegisterCallBack(callback);
881 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "RegisterCallBack failed");
882 sinkManager_->SetRenderMode((pauseMode_ == true) ? RENDER_MODE_PAUSE_AFTER_PLAY : RENDER_MODE_NORMAL);
883 ret = sinkManager_->Start();
884 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "sinkManager_ Start failed");
885
886 if (leftVolume_ >= 0.0f || rightVolume_ >= 0.0f) {
887 sinkManager_->SetVolume(leftVolume_, rightVolume_);
888 }
889 return HI_SUCCESS;
890 }
891
ReadFrameFromSource(FormatFrame & fmtFrame)892 int32_t PlayerControl::ReadFrameFromSource(FormatFrame &fmtFrame)
893 {
894 CHECK_NULL_RETURN(playerSource_, HI_ERR_PLAYERCONTROL_NULL_PTR, "playerSource_ nullptr");
895 int ret = playerSource_->ReadFrame(fmtFrame);
896 // Check consistency of fmtFrame
897 if ((ret == HI_SUCCESS) && (fmtFrame.data != nullptr) && (fmtFrame.len == 0)) {
898 MEDIA_ERR_LOG("ReadFrame ERROR : u32Size is invalid");
899 ret = HI_FAILURE;
900 }
901 return ret;
902 }
903
GetVideoResolution(int32_t streamIdx,StreamResolution & resolution)904 int32_t PlayerControl::GetVideoResolution(int32_t streamIdx, StreamResolution &resolution)
905 {
906 if (streamIdx == HI_DEMUXER_NO_MEDIA_STREAM) {
907 MEDIA_ERR_LOG("stream id [%d] in invalid", streamIdx);
908 return HI_FAILURE;
909 }
910
911 for (uint32_t i = 0; i < HI_DEMUXER_RESOLUTION_CNT; i++) {
912 if (fmtFileInfo_.stSteamResolution[i].s32VideoStreamIndex == streamIdx) {
913 resolution.enVideoType = fmtFileInfo_.stSteamResolution[i].enVideoType;
914 resolution.s32VideoStreamIndex = fmtFileInfo_.stSteamResolution[i].s32VideoStreamIndex;
915 resolution.u32Width = fmtFileInfo_.stSteamResolution[i].u32Width;
916 resolution.u32Height = fmtFileInfo_.stSteamResolution[i].u32Height;
917 return HI_SUCCESS;
918 }
919 }
920
921 MEDIA_ERR_LOG("not found stream[%d] in file", streamIdx);
922 return HI_FAILURE;
923 }
924
925 // message begin
DoRegCallback(PlayerCtrlCallbackParam & eventCallback)926 int32_t PlayerControl::DoRegCallback(PlayerCtrlCallbackParam &eventCallback)
927 {
928 if (eventCallback_.callbackFun != nullptr) {
929 MEDIA_WARNING_LOG("you have reg callback,now the before callback fun pointer will be overwrite");
930 }
931 eventCallback_ = eventCallback;
932 return HI_SUCCESS;
933 }
934
DoSetDataSource(const std::string filepath)935 int32_t PlayerControl::DoSetDataSource(const std::string filepath)
936 {
937 filePath_ = filepath;
938 sourceType_ = SOURCE_TYPE_URI;
939 return HI_SUCCESS;
940 }
941
DoSetDataSource(const int32_t fd)942 int32_t PlayerControl::DoSetDataSource(const int32_t fd)
943 {
944 fd_ = fd;
945 sourceType_ = SOURCE_TYPE_FD;
946 return HI_SUCCESS;
947 }
948
DoSetDataSource(BufferStream & stream)949 int32_t PlayerControl::DoSetDataSource(BufferStream &stream)
950 {
951 stream_ = stream;
952 sourceType_ = SOURCE_TYPE_STREAM;
953 return HI_SUCCESS;
954 }
955
DoPrepare(void)956 int32_t PlayerControl::DoPrepare(void)
957 {
958 MEDIA_DEBUG_LOG("Process in");
959 CHECK_NULL_RETURN(stateMachine_, HI_FAILURE, "stateMachine_ nullptr");
960 PlayerStatus playerState = stateMachine_->GetCurState();
961 CHECK_STATE_SAME(playerState, PLAY_STATUS_PREPARED);
962 CHECK_NULL_RETURN(eventCallback_.callbackFun, HI_ERR_PLAYERCONTROL_CALLBACK_ERROR, "callbackFun nullptr");
963 isPlayEnd_ = false;
964 isTplayStartRead_ = false;
965 int32_t ret = SyncPrepare();
966 CHECK_FAILED_RETURN(ret, HI_SUCCESS, HI_ERR_PLAYERCONTROL_OTHER, "SyncPrepare failed");
967 if (playerParam_.u32PlayPosNotifyIntervalMs >= fmtFileInfo_.s64Duration) {
968 MEDIA_WARNING_LOG(
969 "play postion notify interval %d ms oversize file duration, user will never receive notify",
970 playerParam_.u32PlayPosNotifyIntervalMs);
971 }
972 MEDIA_DEBUG_LOG("Process out");
973 return HI_SUCCESS;
974 }
975
ReleaseADecoderOutputFrame(void)976 void PlayerControl::ReleaseADecoderOutputFrame(void)
977 {
978 if (audioDecoder_ == nullptr || sinkManager_ == nullptr) {
979 return;
980 }
981 while (true) {
982 PlayerBufferInfo outInfo;
983 if (sinkManager_->DequeReleaseFrame(true, outInfo) != 0) {
984 break;
985 }
986 audioDecoder_->QueueOutputBuffer((CodecBuffer *)&outInfo, GET_BUFFER_TIMEOUT_MS);
987 }
988 }
989
InitOutputBuffer(CodecBuffer & outInfo,CodecType type)990 static void InitOutputBuffer(CodecBuffer &outInfo, CodecType type)
991 {
992 outInfo.bufferCnt = 0;
993 outInfo.timeStamp = -1;
994 outInfo.flag = 0;
995 }
996
RenderAudioFrame(void)997 void PlayerControl::RenderAudioFrame(void)
998 {
999 if (audioDecoder_ == nullptr || sinkManager_ == nullptr || hasRenderAudioEos_) {
1000 return;
1001 }
1002
1003 PlayerBufferInfo outInfo;
1004 int ret = audioDecoder_->DequeueOutputBuffer((CodecBuffer *)&outInfo, GET_BUFFER_TIMEOUT_MS);
1005 if (ret != 0) {
1006 InitOutputBuffer(outInfo.info, AUDIO_DECODER);
1007 if (ret == CODEC_RECEIVE_EOS && strmReadEnd_) {
1008 sinkManager_->RenderEos(true); /* all frame have been send to audio sink */
1009 }
1010 }
1011 ret = sinkManager_->RenderFrame(outInfo, AUDIO_DECODER);
1012 if (ret == SINK_RENDER_FULL || ret == SINK_RENDER_DELAY) {
1013 renderSleepTime_ = RENDER_FULL_SLEEP_TIME_US;
1014 } else if (ret == SINK_QUE_EMPTY) {
1015 renderSleepTime_ = 0;
1016 }
1017 ReleaseADecoderOutputFrame();
1018 /* fuction RenderFrame will return SINK_RENDER_EOS when all frame in queue that have been processed */
1019 if (ret == SINK_RENDER_EOS) {
1020 hasRenderAudioEos_ = true;
1021 MEDIA_INFO_LOG("have render audio eos");
1022 if (IsPlayEos() == true) {
1023 isPlayEnd_ = true;
1024 }
1025 }
1026 }
1027
ReleaseVDecoderOutputFrame(void)1028 void PlayerControl::ReleaseVDecoderOutputFrame(void)
1029 {
1030 if (videoDecoder_ == nullptr || sinkManager_ == nullptr) {
1031 return;
1032 }
1033 while (true) {
1034 PlayerBufferInfo outInfo;
1035 if (sinkManager_->DequeReleaseFrame(false, outInfo) != 0) {
1036 break;
1037 }
1038 videoDecoder_->QueueOutputBuffer((CodecBuffer *)&outInfo, GET_BUFFER_TIMEOUT_MS);
1039 }
1040 }
1041
RenderVideoFrame(void)1042 void PlayerControl::RenderVideoFrame(void)
1043 {
1044 if (videoDecoder_ == nullptr || sinkManager_ == nullptr || hasRenderVideoEos_) {
1045 return;
1046 }
1047
1048 PlayerBufferInfo outInfo;
1049 outInfo.info.bufferCnt = 1;
1050 int ret = videoDecoder_->DequeueOutputBuffer((CodecBuffer *)&outInfo, GET_BUFFER_TIMEOUT_MS);
1051 if (ret != 0) {
1052 InitOutputBuffer(outInfo.info, VIDEO_DECODER);
1053 if (ret == CODEC_RECEIVE_EOS) {
1054 sinkManager_->RenderEos(false); /* all frame have been send to video sink */
1055 }
1056 }
1057
1058 ret = sinkManager_->RenderFrame(outInfo, VIDEO_DECODER);
1059 if (ret == SINK_RENDER_FULL || ret == SINK_RENDER_DELAY) {
1060 renderSleepTime_ = RENDER_FULL_SLEEP_TIME_US;
1061 } else if (ret == SINK_QUE_EMPTY) {
1062 renderSleepTime_ = 0;
1063 }
1064 ReleaseVDecoderOutputFrame();
1065 /* fuction RenderFrame will return SINK_RENDER_EOS when all frame in queue that have been processed */
1066 if (ret == SINK_RENDER_EOS) {
1067 hasRenderVideoEos_ = true;
1068 MEDIA_INFO_LOG("have rendered video eos");
1069 if (IsPlayEos()) {
1070 isPlayEnd_ = true;
1071 }
1072 }
1073 }
1074
ReortRenderPosition(void)1075 void PlayerControl::ReortRenderPosition(void)
1076 {
1077 int64_t position = -1;
1078 CHECK_NULL_RETURN_VOID(sinkManager_, "sinkManager_ nullptr");
1079 sinkManager_->GetRenderPosition(position);
1080 if (position >= 0 && currentPosition_ != position) {
1081 currentPosition_ = position;
1082 EventCallback(PLAYERCONTROL_EVENT_PROGRESS, ¤tPosition_);
1083 }
1084 }
1085
DataSchProcess(void * priv)1086 void *PlayerControl::DataSchProcess(void *priv)
1087 {
1088 PlayerControl *play = (PlayerControl*)priv;
1089 CHECK_NULL_RETURN(play, nullptr, "play nullptr");
1090
1091 prctl(PR_SET_NAME, "PlaySch", 0, 0, 0);
1092 MEDIA_INFO_LOG("start work");
1093 while (true) {
1094 pthread_mutex_lock(&play->schMutex_);
1095 if (play->schThreadExit_ == true) {
1096 pthread_mutex_unlock(&play->schMutex_);
1097 break;
1098 }
1099 play->DoSeekIfNeed();
1100 if (play->paused_) {
1101 CondTimeWait(play->schCond_, play->schMutex_, PAUSE_WAIT_TIME_US);
1102 pthread_mutex_unlock(&play->schMutex_);
1103 continue;
1104 }
1105 play->renderSleepTime_ = 0;
1106 play->ReadPacketAndPushToDecoder();
1107
1108 /* get and render frame */
1109 play->RenderAudioFrame();
1110 play->RenderVideoFrame();
1111 pthread_mutex_unlock(&play->schMutex_);
1112 play->EventQueueProcess();
1113 play->ReortRenderPosition();
1114 if (play->isPlayEnd_) {
1115 play->DealPlayEnd();
1116 play->isPlayEnd_ = false;
1117 }
1118 if (play->IsPlayEos()) {
1119 play->renderSleepTime_ = RENDER_EOS_SLEEP_TIME_US;
1120 }
1121 if (play->renderSleepTime_ > 0) {
1122 pthread_mutex_lock(&play->schMutex_);
1123 CondTimeWait(play->schCond_, play->schMutex_, play->renderSleepTime_);
1124 pthread_mutex_unlock(&play->schMutex_);
1125 }
1126 }
1127 pthread_mutex_lock(&play->schMutex_);
1128 play->schThreadExit_ = true;
1129 pthread_mutex_unlock(&play->schMutex_);
1130 MEDIA_INFO_LOG("end work");
1131 return nullptr;
1132 }
1133
DoPlay()1134 int32_t PlayerControl::DoPlay()
1135 {
1136 MEDIA_DEBUG_LOG("Process in");
1137 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
1138 CHECK_NULL_RETURN(playerSource_, HI_ERR_PLAYERCONTROL_NULL_PTR, "playerSource_ nullptr");
1139
1140 int32_t ret = HI_SUCCESS;
1141 PlayerStatus playerState = stateMachine_->GetCurState();
1142 CHECK_STATE_SAME(playerState, PLAY_STATUS_PLAY);
1143 if (playerState == PLAY_STATUS_TPLAY) {
1144 ret = OnSwitchTPlay2Play();
1145 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "OnSwitchTPlay2Play failed");
1146 } else if (playerState == PLAY_STATUS_PREPARED) {
1147 ret = CheckMediaInfo();
1148 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "CheckMediaInfo failed");
1149 ret = SetDecoderAndStreamAttr();
1150 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "SetDecoderAndStreamAttr failed");
1151 ret = DecoderStart();
1152 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "DecoderStart failed");
1153 ret = SinkStart();
1154 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "SinkStart failed");
1155 ret = playerSource_->Start();
1156 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "playerSource_ Start failed");
1157 pthread_mutex_lock(&schMutex_);
1158 paused_ = true;
1159 pthread_mutex_unlock(&schMutex_);
1160 ret = pthread_create(&schProcess_, nullptr, DataSchProcess, this);
1161 if (ret != 0) {
1162 MEDIA_ERR_LOG("pthread_create failed %d", ret);
1163 pthread_mutex_lock(&schMutex_);
1164 schThreadExit_ = false;
1165 pthread_mutex_unlock(&schMutex_);
1166 return -1;
1167 }
1168 pthread_mutex_lock(&schMutex_);
1169 paused_ = false;
1170 pthread_cond_signal(&schCond_);
1171 pthread_mutex_unlock(&schMutex_);
1172 } else if (playerState == PLAY_STATUS_PAUSE) {
1173 ret = PauseResume();
1174 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "PauseResume failed");
1175 } else {
1176 return HI_ERR_PLAYERCONTROL_ILLEGAL_STATE_ACTION;
1177 }
1178
1179 MEDIA_DEBUG_LOG("Process out");
1180 return ret;
1181 }
1182
DoSetVolume(VolumeAttr & volumeAttr)1183 int32_t PlayerControl::DoSetVolume(VolumeAttr &volumeAttr)
1184 {
1185 leftVolume_ = volumeAttr.leftVolume;
1186 rightVolume_ = volumeAttr.rightVolume;
1187 CHECK_NULL_RETURN(sinkManager_, HI_SUCCESS, "sinkManager_ nullptr, it will be setted after play");
1188 return sinkManager_->SetVolume(volumeAttr.leftVolume, volumeAttr.rightVolume);
1189 }
1190
ReadPacket()1191 int32_t PlayerControl::ReadPacket()
1192 {
1193 int32_t ret = HI_SUCCESS;
1194 if (cachedPacket_) {
1195 return ret;
1196 }
1197 ret = ReadFrameFromSource(formatPacket_);
1198 if (ret != HI_RET_FILE_EOF && (formatPacket_.data == nullptr || formatPacket_.len == 0)) {
1199 return HI_RET_NODATA;
1200 }
1201 if (ret == HI_RET_FILE_EOF) {
1202 CHECK_FAILED_RETURN(memset_s(&formatPacket_, sizeof(formatPacket_), 0, sizeof(FormatFrame)), EOK, -1,
1203 "memset_s failed");
1204 ret = HI_SUCCESS;
1205 } else if (ret == HI_RET_NODATA) {
1206 CHECK_FAILED_RETURN(memset_s(&formatPacket_, sizeof(formatPacket_), 0, sizeof(FormatFrame)), EOK, -1,
1207 "memset_s failed");
1208 strmReadEnd_ = false;
1209 return ret;
1210 } else if (ret != HI_SUCCESS) {
1211 MEDIA_ERR_LOG("ReadFrameFromSource failed , ret:%d", ret);
1212 NotifyError(PLAYERCONTROL_ERROR_DEMUX_FAIL);
1213 return HI_FAILURE;
1214 }
1215 strmReadEnd_ = false;
1216 cachedPacket_ = true;
1217
1218 return ret;
1219 }
1220
IsValidPacket(FormatFrame & packet)1221 inline static bool IsValidPacket(FormatFrame &packet)
1222 {
1223 return (packet.data != nullptr && packet.len != 0) ? true : false;
1224 }
1225
PushPacketToADecoder(void)1226 void PlayerControl::PushPacketToADecoder(void)
1227 {
1228 if (audioDecoder_ == nullptr) {
1229 return;
1230 }
1231 PlayerBufferInfo inputData = {};
1232 CodecBufferInfo inBufInfo;
1233 if (memset_s(&inBufInfo, sizeof(inBufInfo), 0, sizeof(CodecBufferInfo)) != EOK) {
1234 return;
1235 }
1236
1237 inBufInfo.type = BUFFER_TYPE_VIRTUAL;
1238 inBufInfo.buf = (intptr_t)formatPacket_.data;
1239 inBufInfo.length = formatPacket_.len;
1240 inputData.info.bufferCnt = 1;
1241 inputData.info.buffer[0] = inBufInfo;
1242 inputData.info.timeStamp = formatPacket_.timestampUs;
1243 inputData.info.flag = 0;
1244
1245 int32_t ret = audioDecoder_->QueueInputBuffer((CodecBuffer *)&inputData, GET_BUFFER_TIMEOUT_MS);
1246 if (ret == CODEC_ERR_UNKOWN) { // CODEC_ERR_STREAM_BUF_FULL
1247 renderSleepTime_ = QUEUE_BUFFER_FULL_SLEEP_TIME_US;
1248 return;
1249 }
1250 PlayerBufferInfo outData;
1251 ret = audioDecoder_->DequeInputBuffer((CodecBuffer *)&outData, GET_BUFFER_TIMEOUT_MS);
1252 if (ret != 0) {
1253 MEDIA_DEBUG_LOG("audio DequeInputBuffer failed");
1254 return;
1255 }
1256 if (firstAudioFrameAfterSeek_ && IsValidPacket(formatPacket_)) {
1257 firstAudioFrameAfterSeek_ = false;
1258 MEDIA_INFO_LOG("push firstAudioFrameAfterSeek_ success, pts:%lld", inputData.info.timeStamp);
1259 }
1260 if (formatPacket_.data != nullptr || formatPacket_.len != 0) {
1261 lastSendAdecPts_ = formatPacket_.timestampUs;
1262 }
1263 ClearCachePacket();
1264 }
1265
PushPacketToVDecoder(void)1266 void PlayerControl::PushPacketToVDecoder(void)
1267 {
1268 if (videoDecoder_ == nullptr) {
1269 return;
1270 }
1271 PlayerBufferInfo inputData = {};
1272 CodecBufferInfo inBufInfo;
1273 if (memset_s(&inBufInfo, sizeof(inBufInfo), 0, sizeof(CodecBufferInfo)) != EOK) {
1274 return;
1275 }
1276 inBufInfo.type = BUFFER_TYPE_VIRTUAL;
1277 inBufInfo.buf = (intptr_t)formatPacket_.data;
1278 inBufInfo.length = formatPacket_.len;
1279 inputData.info.bufferCnt = 1;
1280 inputData.info.buffer[0] = inBufInfo;
1281 inputData.info.timeStamp = formatPacket_.timestampUs;
1282 inputData.info.flag = 0;
1283 int32_t ret = videoDecoder_->QueueInputBuffer((CodecBuffer *)&inputData, GET_BUFFER_TIMEOUT_MS);
1284 if (ret == CODEC_ERR_UNKOWN) { // CODEC_ERR_STREAM_BUF_FULL
1285 renderSleepTime_ = QUEUE_BUFFER_FULL_SLEEP_TIME_US;
1286 return;
1287 }
1288 PlayerBufferInfo outData;
1289 ret = videoDecoder_->DequeInputBuffer((CodecBuffer *)&outData, GET_BUFFER_TIMEOUT_MS);
1290 if (ret != 0) {
1291 MEDIA_DEBUG_LOG("video DequeInputBuffer failed");
1292 return;
1293 }
1294 if (firstVideoFrameAfterSeek_ && IsValidPacket(formatPacket_)) {
1295 firstVideoFrameAfterSeek_ = false;
1296 MEDIA_INFO_LOG("push firstVideoFrameAfterSeek_ success, pts:%lld", inputData.info.timeStamp);
1297 }
1298 if (formatPacket_.data != nullptr && formatPacket_.len != 0) {
1299 lastSendVdecPts_ = formatPacket_.timestampUs;
1300 }
1301 ClearCachePacket();
1302 }
1303
ReadPacketAndPushToDecoder()1304 int32_t PlayerControl::ReadPacketAndPushToDecoder()
1305 {
1306 int32_t ret = HI_SUCCESS;
1307 PlayerStatus playerState;
1308 if (stateMachine_ == nullptr) {
1309 return HI_FAILURE;
1310 }
1311 playerState = stateMachine_->GetCurState();
1312 if ((playerState != PLAY_STATUS_PLAY) && (playerState != PLAY_STATUS_TPLAY)) {
1313 return HI_SUCCESS;
1314 }
1315 if (isNeedPause_ == true) {
1316 isNeedPause_ = false;
1317 return HI_SUCCESS;
1318 }
1319 if (strmReadEnd_ == true) {
1320 return HI_SUCCESS;
1321 }
1322 if (playerState == PLAY_STATUS_PLAY) {
1323 ret = ReadPacket();
1324 } else {
1325 ret = ReadTplayData();
1326 }
1327 if (ret == HI_RET_NODATA) {
1328 renderSleepTime_ = NO_DATA_READ_SLEEP_TIME_US;
1329 ClearCachePacket();
1330 return ret;
1331 } else if (ret != HI_SUCCESS) {
1332 ClearCachePacket();
1333 return ret;
1334 }
1335 if (formatPacket_.data == nullptr && formatPacket_.len == 0) {
1336 PushPacketToADecoder();
1337 PushPacketToVDecoder();
1338 strmReadEnd_ = true;
1339 ClearCachePacket();
1340 return HI_SUCCESS;
1341 }
1342 if (formatPacket_.frameType == FRAME_TYPE_AUDIO && audioDecoder_ != nullptr) {
1343 PushPacketToADecoder();
1344 } else if (formatPacket_.frameType == FRAME_TYPE_VIDEO && videoDecoder_ != nullptr) {
1345 PushPacketToVDecoder();
1346 }
1347 return HI_SUCCESS;
1348 }
1349
ReadTplayData()1350 int32_t PlayerControl::ReadTplayData()
1351 {
1352 int32_t ret = HI_SUCCESS;
1353 if (cachedPacket_) {
1354 return ret;
1355 }
1356
1357 ret = TPlayBeforeFrameRead();
1358 if (ret == HI_RET_FILE_EOF) {
1359 if (memset_s(&formatPacket_, sizeof(formatPacket_), 0, sizeof(FormatFrame)) != EOK) {
1360 MEDIA_ERR_LOG("SET formatPacket_ failed");
1361 return HI_FAILURE;
1362 }
1363 cachedPacket_ = true; // send eos
1364 return HI_SUCCESS;
1365 } else if (ret != HI_SUCCESS) {
1366 NotifyError(PLAYERCONTROL_ERROR_DEMUX_FAIL);
1367 return HI_FAILURE;
1368 }
1369 ret = ReadFrameFromSource(formatPacket_);
1370 if (ret == HI_RET_FILE_EOF) {
1371 if (memset_s(&formatPacket_, sizeof(formatPacket_), 0, sizeof(FormatFrame)) != EOK) {
1372 MEDIA_ERR_LOG("SET formatPacket_ failed");
1373 return HI_FAILURE;
1374 }
1375 } else if (ret != HI_SUCCESS) {
1376 MEDIA_ERR_LOG("ReadFrameFromSource failed , ret:%d", ret);
1377 NotifyError(PLAYERCONTROL_ERROR_DEMUX_FAIL);
1378 return HI_FAILURE;
1379 }
1380 cachedPacket_ = true;
1381 lastReadPktStrmIdx_ = formatPacket_.trackId;
1382 ret = TPlayAfterFrameRead(formatPacket_);
1383 if (ret == HI_RET_SKIP_PACKET) {
1384 ClearCachePacket();
1385 return ret;
1386 }
1387 isTplayStartRead_ = true;
1388 strmReadEnd_ = false;
1389 return ret;
1390 }
1391
DoStop()1392 int32_t PlayerControl::DoStop()
1393 {
1394 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
1395 int32_t ret = HI_SUCCESS;
1396 PlayerStatus playerState = stateMachine_->GetCurState();
1397 CHECK_STATE_SAME(playerState, PLAY_STATUS_IDLE);
1398
1399 MsgInfo msgInfo;
1400 if (memset_s(&msgInfo, sizeof(MsgInfo), 0x00, sizeof(msgInfo)) != EOK) {
1401 MEDIA_ERR_LOG("memset_s msgInfo failed");
1402 return HI_ERR_PLAYERCONTROL_MEM_SET;
1403 }
1404 msgInfo.what = PLAYERCONTROL_MSG_SEEK;
1405 (void)stateMachine_->RemoveEvent(msgInfo);
1406 if (schProcess_ != 0) {
1407 pthread_mutex_lock(&schMutex_);
1408 schThreadExit_ = true;
1409 pthread_cond_signal(&schCond_);
1410 pthread_mutex_unlock(&schMutex_);
1411 pthread_join(schProcess_, nullptr);
1412 }
1413 StopSinkAndDecoder();
1414 ClearCachePacket();
1415 if (playerSource_ != nullptr) {
1416 ret = playerSource_->Stop();
1417 CHECK_FAILED_PRINT(ret, HI_SUCCESS, "playerSource_ stop failed");
1418 }
1419 isPlayEnd_ = false;
1420 strmReadEnd_ = false;
1421 isPlayErr_ = false;
1422 lastRendPos_ = 0;
1423 lastReadPktPts_ = 0;
1424 lastSendPktPts_ = 0;
1425 isAudPlayEos_ = false;
1426 isVidPlayEos_ = false;
1427 hasRenderVideoEos_ = false;
1428 hasRenderAudioEos_ = false;
1429 lastNotifyTime_ = 0;
1430 seekToTimeMs_ = -1;
1431 if (memset_s(&(fmtFileInfo_), sizeof(fmtFileInfo_), 0, sizeof(FormatFrame)) != EOK) {
1432 MEDIA_ERR_LOG("SET fmtFileInfo_ failed ");
1433 return HI_ERR_PLAYERCONTROL_MEM_SET;
1434 }
1435 return ret;
1436 }
1437
DoPause(void)1438 int32_t PlayerControl::DoPause(void)
1439 {
1440 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
1441 PlayerStatus playerState = stateMachine_->GetCurState();
1442 CHECK_STATE_SAME(playerState, PLAY_STATUS_PAUSE);
1443 CHECK_NULL_RETURN(sinkManager_, HI_FAILURE, "sinkManager_ nullptr");
1444
1445 if (playerState == PLAY_STATUS_PLAY || (playerState == PLAY_STATUS_TPLAY)) {
1446 pthread_mutex_lock(&schMutex_);
1447 paused_ = true;
1448 pthread_mutex_unlock(&schMutex_);
1449 int32_t ret = sinkManager_->Pause();
1450 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "Pause failed");
1451 } else {
1452 return HI_ERR_PLAYERCONTROL_ILLEGAL_STATE_ACTION;
1453 }
1454 return HI_SUCCESS;
1455 }
1456
DoSeekIfNeed(void)1457 int32_t PlayerControl::DoSeekIfNeed(void)
1458 {
1459 uint32_t index = 0;
1460 uint32_t seekCnt = 0;
1461 if (seekTabel_[0] == -1 && seekTabel_[1] == -1) {
1462 return HI_SUCCESS;
1463 }
1464
1465 while (seekCnt < 0x2) {
1466 if (seekTabel_[index] != -1) {
1467 int32_t ret = AyncSeek(seekTabel_[index]);
1468 if (ret != HI_SUCCESS) {
1469 MEDIA_ERR_LOG(" AyncSeek failed , ret:%d", ret);
1470 NotifyError(PLAYERCONTROL_ERROR_VID_PLAY_FAIL);
1471 return ret;
1472 }
1473 seekCnt++;
1474 }
1475 seekTabel_[index] = -1;
1476 if (seekTabel_[0] == -1 && seekTabel_[1] == -1) {
1477 break;
1478 }
1479 index = (index + 1) & 0x1;
1480 }
1481 strmReadEnd_ = false;
1482 isAudPlayEos_ = false;
1483 isVidPlayEos_ = false;
1484 hasRenderVideoEos_ = false;
1485 hasRenderAudioEos_ = false;
1486 isPlayEnd_ = false;
1487
1488 firstAudioFrameAfterSeek_ = true;
1489 firstVideoFrameAfterSeek_ = true;
1490 MEDIA_INFO_LOG("seek end");
1491 return HI_SUCCESS;
1492 }
1493
DoSeek(int64_t timeInMs)1494 int32_t PlayerControl::DoSeek(int64_t timeInMs)
1495 {
1496 seekToTimeMs_ = timeInMs;
1497 return DoSeekIfNeed();
1498 }
1499
DoGetFileInfo(FormatFileInfo & fileInfo)1500 int32_t PlayerControl::DoGetFileInfo(FormatFileInfo &fileInfo)
1501 {
1502 return memcpy_s(&fileInfo, sizeof(FormatFileInfo), &fmtFileInfo_, sizeof(fmtFileInfo_));
1503 }
1504
DoSetMedia(PlayerControlStreamAttr & mediaAttr)1505 int32_t PlayerControl::DoSetMedia(PlayerControlStreamAttr &mediaAttr)
1506 {
1507 CHECK_NULL_RETURN(playerSource_, HI_ERR_PLAYERCONTROL_NULL_PTR, "playerSource_ nullptr");
1508 int32_t ret = playerSource_->SelectTrack(0, mediaAttr.s32VidStreamId);
1509 CHECK_FAILED_RETURN(ret, 0, HI_ERR_PLAYERCONTROL_DEMUX_ERROR, "SelectTrack failed");
1510 ret = playerSource_->SelectTrack(0, mediaAttr.s32AudStreamId);
1511 CHECK_FAILED_RETURN(ret, 0, HI_ERR_PLAYERCONTROL_DEMUX_ERROR, "SelectTrack failed");
1512 fmtFileInfo_.s32UsedVideoStreamIndex = mediaAttr.s32VidStreamId;
1513 fmtFileInfo_.s32UsedAudioStreamIndex = mediaAttr.s32AudStreamId;
1514 return HI_SUCCESS;
1515 }
1516
GetStreamInfo(PlayerStreamInfo & streamInfo)1517 int32_t PlayerControl::GetStreamInfo(PlayerStreamInfo &streamInfo)
1518 {
1519 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
1520 streamInfo.avStatus.syncStatus.lastAudPts = AV_INVALID_PTS;
1521 streamInfo.avStatus.syncStatus.lastVidPts = AV_INVALID_PTS;
1522 if (sinkManager_->GetStatus(streamInfo) != HI_SUCCESS) {
1523 return HI_FAILURE;
1524 }
1525 PlayerStatus status = stateMachine_->GetCurState();
1526 if (status == PLAY_STATUS_PLAY) {
1527 streamInfo.avStatus.vidStatus = (isVideoStarted_) ? (DecoderStatus)status : DECODER_STATUS_IDLE;
1528 streamInfo.avStatus.audStatus = (isAudioStarted_) ? (DecoderStatus)status : DECODER_STATUS_IDLE;
1529 } else {
1530 streamInfo.avStatus.audStatus = (DecoderStatus)status;
1531 }
1532
1533 streamInfo.audioInfo.channel = adecAttr_.channel;
1534 streamInfo.audioInfo.bitwith = adecAttr_.bitWidth;
1535 streamInfo.audioInfo.sampleRate = adecAttr_.sampleRate;
1536 streamInfo.audioInfo.esBufSize = streamAttr_.audioBufSize;
1537 streamInfo.audioInfo.freeEsBufSize = streamAttr_.audioBufSize >> 1;
1538 streamInfo.videoInfo.esBufSize = streamAttr_.videoBufSize;
1539 streamInfo.videoInfo.freeEsBufSize = streamAttr_.videoBufSize >> 1;
1540 return HI_SUCCESS;
1541 }
1542
1543
IsRepeatTplayReq(TplayAttr & tplayAttr,bool & isRepeat)1544 int32_t PlayerControl::IsRepeatTplayReq(TplayAttr &tplayAttr, bool &isRepeat)
1545 {
1546 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
1547 isRepeat = false;
1548 if (stateMachine_->GetCurState() == PLAY_STATUS_TPLAY &&
1549 tplayAttr_.direction == tplayAttr.direction &&
1550 tplayAttr_.speed == tplayAttr.speed) {
1551 MEDIA_ERR_LOG("TPlay input Attr same with current");
1552 isRepeat = true;
1553 return HI_SUCCESS;
1554 }
1555 PlayerStreamInfo streamInfo;
1556 int64_t lastVidRendPts;
1557 int32_t ret = GetStreamInfo(streamInfo);
1558 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "GetStreamInfo failed");
1559 lastVidRendPts = streamInfo.avStatus.syncStatus.lastVidPts;
1560 if (tplayAttr_.direction == TPLAY_DIRECT_BACKWARD &&
1561 tplayAttr.direction == TPLAY_DIRECT_BACKWARD &&
1562 lastVidRendPts == 0) {
1563 MEDIA_DEBUG_LOG("TPlay already played to start");
1564 isRepeat = true;
1565 return HI_SUCCESS;
1566 }
1567 return HI_SUCCESS;
1568 }
1569
DoTPlay(TplayAttr & trickPlayAttr)1570 int32_t PlayerControl::DoTPlay(TplayAttr &trickPlayAttr)
1571 {
1572 isTplayLastFrame_ = false;
1573 isTplayStartRead_ = false;
1574 if (fmtFileInfo_.enVideoType == CODEC_JPEG) {
1575 MEDIA_ERR_LOG("jpeg file do not support tplay");
1576 return HI_ERR_PLAYERCONTROL_NOT_SUPPORT;
1577 }
1578 if (fmtFileInfo_.s32UsedVideoStreamIndex == HI_DEMUXER_NO_MEDIA_STREAM) {
1579 MEDIA_ERR_LOG("only audio file do not support tplay");
1580 return HI_ERR_PLAYERCONTROL_NOT_SUPPORT;
1581 }
1582 bool isRepeat = false;
1583 int32_t ret = IsRepeatTplayReq(trickPlayAttr, isRepeat);
1584 if (ret != HI_SUCCESS) {
1585 return ret;
1586 }
1587 if (isRepeat) {
1588 return HI_SUCCESS;
1589 }
1590 if (memcpy_s(&tplayAttr_, sizeof(tplayAttr_), &trickPlayAttr, sizeof(trickPlayAttr)) != EOK) {
1591 MEDIA_ERR_LOG("copy tplayAttr_ fail");
1592 return HI_FAILURE;
1593 }
1594 pthread_mutex_lock(&schMutex_);
1595 ret = TPlayResetBuffer();
1596 if (ret != HI_SUCCESS) {
1597 MEDIA_ERR_LOG("TPlayResetBuffer failed, ret:%d", ret);
1598 pthread_mutex_unlock(&schMutex_);
1599 return ret;
1600 }
1601 isVidContinueLost_ = false;
1602 ret = sinkManager_->SetSpeed(tplayAttr_.speed, tplayAttr_.direction);
1603 if (ret != HI_SUCCESS) {
1604 MEDIA_ERR_LOG("TPlayResetBuffer failed, ret:%d", ret);
1605 }
1606 curSeekOffset_ = TPlayGetSeekOffset(tplayAttr_.speed, tplayAttr_.direction);
1607 /* for ts file, double step */
1608 if (fmtFileInfo_.formatName != nullptr && strstr(fmtFileInfo_.formatName, "mpegts") != NULL) {
1609 curSeekOffset_ = curSeekOffset_ * 0x2;
1610 }
1611
1612 tplayMode_ = TPlayGetPlayMode();
1613
1614 lastReadPktStrmIdx_ = (uint32_t)fmtFileInfo_.s32UsedVideoStreamIndex;
1615 strmReadEnd_ = false;
1616 isVidPlayEos_ = false;
1617 isAudPlayEos_ = false;
1618 hasRenderVideoEos_ = false;
1619 hasRenderAudioEos_ = false;
1620 lastSendAdecPts_ = AV_INVALID_PTS;
1621 pthread_mutex_unlock(&schMutex_);
1622 return HI_SUCCESS;
1623 }
1624
1625 // util bigein
EventCallback(PlayerControlEvent event,const void * data)1626 void PlayerControl::EventCallback(PlayerControlEvent event, const void *data)
1627 {
1628 CHECK_NULL_RETURN_VOID(eventCallback_.callbackFun, "callbackFun nullptr");
1629 eventCallback_.callbackFun(eventCallback_.player, event, data);
1630 }
1631
NotifyError(PlayerControlError playerError)1632 void PlayerControl::NotifyError(PlayerControlError playerError)
1633 {
1634 EventCallback(PLAYERCONTROL_EVENT_ERROR, reinterpret_cast<void *>(&playerError));
1635 }
1636
StateChangeCallback(PlayerStatus state)1637 void PlayerControl::StateChangeCallback(PlayerStatus state)
1638 {
1639 EventCallback(PLAYERCONTROL_EVENT_STATE_CHANGED, reinterpret_cast<void *>(&state));
1640 }
1641
UpdateProgressNotify()1642 void PlayerControl::UpdateProgressNotify()
1643 {
1644 CHECK_NULL_RETURN_VOID(stateMachine_, "stateMachine nullptr");
1645 int64_t lastRendPts;
1646 PlayerStreamInfo streamInfo;
1647 uint64_t curTime = PlayerControlGetCurRelativeTime();
1648
1649 if (!isPlayEnd_) {
1650 // First progress is not sended to reduce cpu
1651 lastNotifyTime_ = (!lastNotifyTime_) ? curTime : lastNotifyTime_;
1652 if (lastNotifyTime_ &&
1653 (curTime - lastNotifyTime_) < playerParam_.u32PlayPosNotifyIntervalMs) {
1654 return;
1655 }
1656 }
1657 int32_t ret = GetStreamInfo(streamInfo);
1658 if (ret != HI_SUCCESS) {
1659 MEDIA_ERR_LOG("GetStreamInfo failed , ret:%x", ret);
1660 return;
1661 }
1662 if (fmtFileInfo_.s32UsedAudioStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM &&
1663 stateMachine_->GetCurState() != PLAY_STATUS_TPLAY) {
1664 lastRendPts = streamInfo.avStatus.syncStatus.lastAudPts;
1665 if (lastRendPts < fmtFileInfo_.s64StartTime) {
1666 return;
1667 }
1668 lastRendPts -= fmtFileInfo_.s64StartTime;
1669 if (!isAudPlayEos_) {
1670 EventCallback(PLAYERCONTROL_EVENT_PROGRESS, &lastRendPts);
1671 }
1672 lastNotifyTime_ = curTime;
1673 lastRendPos_ = lastRendPts;
1674 } else if (!isVidPlayEos_) {
1675 lastRendPts = streamInfo.avStatus.syncStatus.lastVidPts;
1676 if (lastRendPts < fmtFileInfo_.s64StartTime) {
1677 return;
1678 }
1679 lastRendPts -= fmtFileInfo_.s64StartTime;
1680 EventCallback(PLAYERCONTROL_EVENT_PROGRESS, &lastRendPts);
1681 lastNotifyTime_ = curTime;
1682 lastRendPos_ = lastRendPts;
1683 }
1684 }
1685
DealPlayEnd()1686 void PlayerControl::DealPlayEnd()
1687 {
1688 CHECK_NULL_RETURN_VOID(stateMachine_, "stateMachine nullptr");
1689 PlayerStatus playState = stateMachine_->GetCurState();
1690 if (tplayAttr_.direction == TPLAY_DIRECT_BACKWARD && playState == PLAY_STATUS_TPLAY) {
1691 EventCallback(PLAYERCONTROL_EVENT_SOF, nullptr);
1692 } else {
1693 if (fmtFileInfo_.s64Duration != -1) {
1694 EventCallback(PLAYERCONTROL_EVENT_PROGRESS, &fmtFileInfo_.s64Duration);
1695 }
1696 EventCallback(PLAYERCONTROL_EVENT_EOF, nullptr);
1697 }
1698 }
1699
TPlayGetPlayMode()1700 PlayerTplayMode PlayerControl::TPlayGetPlayMode()
1701 {
1702 PlayerTplayMode tplayMode = PLAYER_TPLAY_ONLY_I_FRAME;
1703 StreamResolution resolution = { 0 };
1704 if (GetVideoResolution(fmtFileInfo_.s32UsedVideoStreamIndex, resolution) != HI_SUCCESS) {
1705 MEDIA_ERR_LOG("GetVideoResolution failed");
1706 return PLAYER_TPLAY_ONLY_I_FRAME;
1707 }
1708
1709 if (tplayAttr_.direction == TPLAY_DIRECT_FORWARD && tplayAttr_.speed == PLAY_SPEED_2X_FAST) {
1710 if ((resolution.u32Width * resolution.u32Height) <= FULL_TPLAY_RESULITON_LIMIT &&
1711 fmtFileInfo_.fFrameRate <= FULL_TPLAY_FRAMERATE_LIMIT &&
1712 fmtFileInfo_.u32Bitrate <= FULL_TPLAY_BITRATE_LIMIT) {
1713 tplayMode = PLAYER_TPLAY_FULL_PLAY;
1714 }
1715 }
1716 return tplayMode;
1717 }
1718
TPlayGetSeekOffset(float playSpeed,TplayDirect direction)1719 int32_t PlayerControl::TPlayGetSeekOffset(float playSpeed, TplayDirect direction)
1720 {
1721 int32_t seekOffset = 0;
1722 switch ((int)playSpeed) {
1723 case PLAY_SPEED_2X_FAST:
1724 seekOffset = static_cast<int32_t>(TPLAY_SEEK_OFFSET_2X);
1725 break;
1726 case PLAY_SPEED_4X_FAST:
1727 seekOffset = static_cast<int32_t>(TPLAY_SEEK_OFFSET_4X);
1728 break;
1729 case PLAY_SPEED_8X_FAST:
1730 seekOffset = static_cast<int32_t>(TPLAY_SEEK_OFFSET_8X);
1731 break;
1732 case PLAY_SPEED_16X_FAST:
1733 seekOffset = static_cast<int32_t>(TPLAY_SEEK_OFFSET_16X);
1734 break;
1735 case PLAY_SPEED_32X_FAST:
1736 seekOffset = static_cast<int32_t>(TPLAY_SEEK_OFFSET_32X);
1737 break;
1738 case PLAY_SPEED_64X_FAST:
1739 seekOffset = static_cast<int32_t>(TPLAY_SEEK_OFFSET_64X);
1740 break;
1741 case PLAY_SPEED_128X_FAST:
1742 seekOffset = static_cast<int32_t>(TPLAY_SEEK_OFFSET_128X);
1743 break;
1744 default:
1745 MEDIA_ERR_LOG("unsupporteded play speed: %f", playSpeed);
1746 break;
1747 }
1748 seekOffset = (direction == TPLAY_DIRECT_BACKWARD) ? (-seekOffset) : seekOffset;
1749 return seekOffset;
1750 }
1751
TPlayResetBuffer()1752 int32_t PlayerControl::TPlayResetBuffer()
1753 {
1754 int32_t ret;
1755 PlayerStreamInfo streamInfo;
1756
1757 if (memset_s(&streamInfo, sizeof(streamInfo), 0x00, sizeof(PlayerStreamInfo)) != EOK) {
1758 return HI_FAILURE;
1759 }
1760 ret = GetStreamInfo(streamInfo);
1761 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "GetStreamInfo failed");
1762 lastReadPktPts_ = currentPosition_;
1763 isTplayLastFrame_ = false;
1764 ClearCachePacket();
1765 ret = DecoderAndSinkReset();
1766 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "DecoderAndSinkReset failed");
1767 return HI_SUCCESS;
1768 }
1769
TPlayCheckContinueLost()1770 int32_t PlayerControl::TPlayCheckContinueLost()
1771 {
1772 int32_t ret = HI_SUCCESS;
1773 if (isVidContinueLost_) {
1774 if (curSeekOffset_ < INT32_MAX / OFFSET_INCREASE_FOR_FRAME_LOST) {
1775 curSeekOffset_ *= OFFSET_INCREASE_FOR_FRAME_LOST;
1776 }
1777 MEDIA_ERR_LOG("vid dec frame slow, increase seekoffset to %d", curSeekOffset_);
1778 ret = TPlayResetBuffer();
1779 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "TPlayResetBuffer failed");
1780 isVidContinueLost_ = false;
1781 }
1782 return HI_SUCCESS;
1783 }
1784
TPlayIsFileReadEnd()1785 bool PlayerControl::TPlayIsFileReadEnd()
1786 {
1787 if (lastReadPktPts_ == 0 && tplayAttr_.direction == TPLAY_DIRECT_BACKWARD) {
1788 MEDIA_DEBUG_LOG("backward last seek pts %lld", lastReadPktPts_);
1789 return true;
1790 } else if (isTplayLastFrame_ == true && (tplayAttr_.direction == TPLAY_DIRECT_FORWARD)) {
1791 MEDIA_DEBUG_LOG("forward last seek pts %lld fmtFileInfo_.s64Duration:%lld", lastReadPktPts_,
1792 fmtFileInfo_.s64Duration);
1793 return true;
1794 }
1795 return false;
1796 }
1797
SeekInTplayMode(int64_t seekTimeInMs,FormatSeekMode seekFlag)1798 int32_t PlayerControl::SeekInTplayMode(int64_t seekTimeInMs, FormatSeekMode seekFlag)
1799 {
1800 CHECK_NULL_RETURN(playerSource_, HI_FAILURE, "playerSource_ nullptr");
1801 int32_t ret = playerSource_->Seek(fmtFileInfo_.s32UsedVideoStreamIndex, seekTimeInMs, seekFlag);
1802 if (ret != HI_SUCCESS) {
1803 // if forward tplay not find the last i frame, then seek again for backword
1804 if (tplayAttr_.direction == TPLAY_DIRECT_FORWARD) {
1805 seekFlag = FORMAT_SEEK_MODE_FORWARD_KEY;
1806 isTplayLastFrame_ = true;
1807 ret = playerSource_->Seek(fmtFileInfo_.s32UsedVideoStreamIndex, seekTimeInMs, seekFlag);
1808 }
1809 if (ret != HI_SUCCESS) {
1810 MEDIA_DEBUG_LOG("playerSource_ seek failed maybe seek to file end, ret:%d", ret);
1811 /* read end */
1812 return HI_RET_FILE_EOF;
1813 }
1814 }
1815 return ret;
1816 }
TPlayBeforeFrameRead()1817 int32_t PlayerControl::TPlayBeforeFrameRead()
1818 {
1819 int32_t ret = HI_SUCCESS;
1820 if (tplayMode_ != PLAYER_TPLAY_ONLY_I_FRAME) {
1821 return ret;
1822 }
1823
1824 ret = TPlayCheckContinueLost();
1825 if (ret != HI_SUCCESS) {
1826 return ret;
1827 }
1828 /* last packet should be skip if streamidx is not playing video stream */
1829 if (lastReadPktStrmIdx_ == (uint32_t)fmtFileInfo_.s32UsedVideoStreamIndex) {
1830 int64_t seekTimeInMs = lastReadPktPts_ + curSeekOffset_;
1831 if (TPlayIsFileReadEnd()) {
1832 return HI_RET_FILE_EOF;
1833 }
1834 FormatSeekMode seekFlag = (tplayAttr_.direction == TPLAY_DIRECT_BACKWARD) ? FORMAT_SEEK_MODE_BACKWARD_KEY :
1835 FORMAT_SEEK_MODE_FORWARD_KEY;
1836 if (seekTimeInMs < 0 && tplayAttr_.direction == TPLAY_DIRECT_BACKWARD) {
1837 seekTimeInMs = 0;
1838 isTplayLastFrame_ = true;
1839 } else if (seekTimeInMs > fmtFileInfo_.s64Duration && tplayAttr_.direction == TPLAY_DIRECT_FORWARD) {
1840 seekTimeInMs = fmtFileInfo_.s64Duration;
1841 seekFlag = FORMAT_SEEK_MODE_BACKWARD_KEY;
1842 isTplayLastFrame_ = true;
1843 } else if (lastReadPktPts_ == 0 && isTplayStartRead_ == false) {
1844 seekTimeInMs = 0;
1845 seekFlag = FORMAT_SEEK_MODE_BACKWARD_KEY;
1846 isTplayLastFrame_ = false;
1847 }
1848 ret = SeekInTplayMode(seekTimeInMs, seekFlag);
1849 if (ret != HI_SUCCESS) {
1850 return ret;
1851 }
1852 }
1853 return HI_SUCCESS;
1854 }
1855
TPlayAfterFrameRead(FormatFrame & packet)1856 int32_t PlayerControl::TPlayAfterFrameRead(FormatFrame &packet)
1857 {
1858 int32_t ret = HI_SUCCESS;
1859 bool isSkipPkt = false;
1860
1861 if ((int)packet.trackId == fmtFileInfo_.s32UsedVideoStreamIndex) {
1862 if ((packet.timestampUs == lastSendPktPts_) && (isTplayStartRead_ == true)) {
1863 lastReadPktPts_ += curSeekOffset_;
1864 isSkipPkt = true;
1865 } else {
1866 lastReadPktPts_ = packet.timestampUs;
1867 }
1868 } else {
1869 lastReadPktPts_ = packet.timestampUs;
1870 isSkipPkt = true;
1871 }
1872 if (isSkipPkt) {
1873 ret = HI_RET_SKIP_PACKET;
1874 }
1875 return ret;
1876 }
1877
FlushDecoder(void)1878 void PlayerControl::FlushDecoder(void)
1879 {
1880 ReleaseADecoderOutputFrame();
1881 ReleaseVDecoderOutputFrame();
1882 if (audioDecoder_ != nullptr) {
1883 audioDecoder_->FlushDec();
1884 }
1885 if (videoDecoder_ != nullptr) {
1886 videoDecoder_->FlushDec();
1887 }
1888 }
1889
DecoderAndSinkReset(void)1890 int32_t PlayerControl::DecoderAndSinkReset(void)
1891 {
1892 int32_t ret;
1893 bool isNeedResume = false;
1894 ret = sinkManager_->Pause();
1895 if ((ret == HI_SUCCESS) && (paused_ == false)) {
1896 isNeedResume = true;
1897 }
1898 ret = sinkManager_->Reset();
1899 if (ret != HI_SUCCESS) {
1900 MEDIA_ERR_LOG("m_render reset failed");
1901 (void)sinkManager_->Resume();
1902 return ret;
1903 }
1904 FlushDecoder();
1905 if (isNeedResume) {
1906 ret = sinkManager_->Resume();
1907 CHECK_FAILED_RETURN(ret, HI_SUCCESS, HI_FAILURE, "sinkManager_ Resume failed");
1908 }
1909 return HI_SUCCESS;
1910 }
1911
AyncSeek(int64_t seekTime)1912 int32_t PlayerControl::AyncSeek(int64_t seekTime)
1913 {
1914 CHECK_NULL_RETURN(playerSource_, HI_FAILURE, "playerSource_ nullptr");
1915 int64_t seekTimeInMs = seekTime;
1916 int32_t ret = DecoderAndSinkReset();
1917 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "DecoderAndSinkReset failed");
1918 ClearCachePacket();
1919 if (fmtFileInfo_.s32UsedVideoStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM) {
1920 ret = playerSource_->Seek(fmtFileInfo_.s32UsedVideoStreamIndex, seekTimeInMs, FORMAT_SEEK_MODE_BACKWARD_KEY);
1921 if (ret != HI_SUCCESS) {
1922 MEDIA_INFO_LOG("exec fmt_seek video stream failed, ret:%d", ret);
1923 seekTimeInMs = currentPosition_;
1924 }
1925 } else if (fmtFileInfo_.s32UsedAudioStreamIndex != HI_DEMUXER_NO_MEDIA_STREAM) {
1926 ret = playerSource_->Seek(fmtFileInfo_.s32UsedAudioStreamIndex, seekTimeInMs, FORMAT_SEEK_MODE_BACKWARD_KEY);
1927 if (ret != HI_SUCCESS) {
1928 MEDIA_INFO_LOG("exec fmt_seek audio stream failed, ret:%d", ret);
1929 seekTimeInMs = currentPosition_;
1930 }
1931 }
1932 currentPosition_ = seekTimeInMs;
1933
1934 if (tplayAttr_.speed != 1.0f) {
1935 lastReadPktPts_ = currentPosition_;
1936 isTplayStartRead_ = (currentPosition_ == 0) ? false : true;
1937 isTplayLastFrame_ = false;
1938 }
1939
1940 EventCallback(PLAYERCONTROL_EVENT_PROGRESS, ¤tPosition_);
1941 EventCallback(PLAYERCONTROL_EVENT_SEEK_END, reinterpret_cast<void *>(&seekTimeInMs));
1942 return HI_SUCCESS;
1943 }
1944
GetPlayElementEventCallBack(PlayEventCallback & callback)1945 void PlayerControl::GetPlayElementEventCallBack(PlayEventCallback &callback)
1946 {
1947 callback.onEventCallback = PlayerControlOnEvent;
1948 callback.priv = reinterpret_cast<void *>(this);
1949 }
SyncPrepare()1950 int32_t PlayerControl::SyncPrepare()
1951 {
1952 int ret;
1953
1954 playerSource_ = std::make_shared<PlayerSource>();
1955 CHECK_NULL_RETURN(playerSource_, HI_FAILURE, "new playerSource_ nullptr");
1956 playerSource_->Init();
1957
1958 if (sourceType_ == SOURCE_TYPE_FD) {
1959 playerSource_->SetSource(fd_);
1960 } else if (sourceType_ == SOURCE_TYPE_STREAM) {
1961 playerSource_->SetSource(stream_);
1962 } else {
1963 playerSource_->SetSource(filePath_.c_str());
1964 }
1965
1966 PlayEventCallback callback;
1967 GetPlayElementEventCallBack(callback);
1968 ret = playerSource_->SetCallBack(callback);
1969 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "SetCallBack failed");
1970
1971 ret = playerSource_->Prepare();
1972 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "Prepare failed");
1973 ret = playerSource_->GetFileInfo(fmtFileInfo_);
1974 CHECK_FAILED_RETURN(ret, HI_SUCCESS, ret, "GetFileInfo failed");
1975 MEDIA_INFO_LOG("used audiostream index %d", fmtFileInfo_.s32UsedAudioStreamIndex);
1976 MEDIA_INFO_LOG("used videostream index %d", fmtFileInfo_.s32UsedVideoStreamIndex);
1977 return HI_SUCCESS;
1978 }
1979
IsPlayEos()1980 bool PlayerControl::IsPlayEos()
1981 {
1982 CHECK_NULL_RETURN(stateMachine_, false, "stateMachine_ nullptr");
1983 PlayerStatus playerState = stateMachine_->GetCurState();
1984 if (playerState == PLAY_STATUS_TPLAY && hasRenderVideoEos_) {
1985 return true;
1986 }
1987 if ((!isAudioStarted_ || hasRenderAudioEos_) && (!isVideoStarted_ || hasRenderVideoEos_)) {
1988 return true;
1989 }
1990 return false;
1991 }
1992
CheckMediaType(FormatFileInfo & fmtFileInfo)1993 int32_t PlayerControl::CheckMediaType(FormatFileInfo &fmtFileInfo)
1994 {
1995 if (fmtFileInfo.s32UsedVideoStreamIndex == HI_DEMUXER_NO_MEDIA_STREAM) {
1996 return HI_SUCCESS;
1997 }
1998 if ((fmtFileInfo.enVideoType == CODEC_H264)
1999 || (fmtFileInfo.enVideoType == CODEC_H265)
2000 || (fmtFileInfo.enVideoType == CODEC_JPEG)) {
2001 return HI_SUCCESS;
2002 }
2003 MEDIA_ERR_LOG("video type: %d not supported", fmtFileInfo.enVideoType);
2004 return HI_ERR_PLAYERCONTROL_NOT_SUPPORT;
2005 }
2006
Invoke(PlayerInvoke invokeId,void * param)2007 int32_t PlayerControl::Invoke(PlayerInvoke invokeId, void *param)
2008 {
2009 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
2010 MsgInfo msg;
2011 InvokeParameter invokeParam;
2012 invokeParam.id = invokeId;
2013 invokeParam.param = param;
2014
2015 msg.what = PLAYERCONTROL_MSG_INVOKE;
2016 msg.msgData = &invokeParam;
2017 msg.msgDataLen = sizeof(InvokeParameter);
2018 return stateMachine_->Send(msg);
2019 }
2020
EnablePauseAfterPlay(bool pauseAfterPlay)2021 int32_t PlayerControl::EnablePauseAfterPlay(bool pauseAfterPlay)
2022 {
2023 PlayerStatus playerState = stateMachine_->GetCurState();
2024 if (playerState != PLAY_STATUS_IDLE && playerState != PLAY_STATUS_INIT) {
2025 MEDIA_ERR_LOG("unsupported set play mode, state:%d\n", playerState);
2026 return -1;
2027 }
2028 pauseMode_ = pauseAfterPlay;
2029 return 0;
2030 }
2031
DoInvoke(InvokeParameter & invokeParam)2032 int32_t PlayerControl::DoInvoke(InvokeParameter& invokeParam)
2033 {
2034 int32_t ret = -1;
2035
2036 switch (invokeParam.id) {
2037 case INVOKE_ENABLE_PAUSE_AFTER_PLAYER:
2038 if (invokeParam.param == nullptr) {
2039 break;
2040 }
2041 ret = EnablePauseAfterPlay((*((uint32_t *)invokeParam.param)) > 0 ? true : false);
2042 break;
2043 default:
2044 MEDIA_ERR_LOG("unsupported invoke:0x%x\n", invokeParam.id);
2045 break;
2046 }
2047 return ret;
2048 }
2049
SetAudioStreamType(int32_t type)2050 int32_t PlayerControl::SetAudioStreamType(int32_t type)
2051 {
2052 CHECK_NULL_RETURN(stateMachine_, HI_ERR_PLAYERCONTROL_NULL_PTR, "stateMachine_ nullptr");
2053 MsgInfo msg;
2054 int32_t audioStreamType = type;
2055
2056 msg.what = PLAYERCONTROL_MSG_SET_AUDIOSTREAM_TYPE;
2057 msg.msgData = &audioStreamType;
2058 msg.msgDataLen = sizeof(int32_t);
2059 return stateMachine_->Send(msg);
2060 }
2061
DoSetAudioStreamType(int32_t type)2062 int32_t PlayerControl::DoSetAudioStreamType(int32_t type)
2063 {
2064 audioStreamType_ = type;
2065 if (sinkManager_ != nullptr) {
2066 sinkManager_->SetAudioStreamType(type);
2067 }
2068 return 0;
2069 }
2070 }
2071 }
2072