1 /* 2 * Copyright (c) 2023-2024 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 #define HST_LOG_TAG "HiPlayer" 17 18 #include "hiplayer_impl.h" 19 20 #include <chrono> 21 #include <shared_mutex> 22 23 #include "audio_info.h" 24 #include "common/log.h" 25 #include "common/media_source.h" 26 #include "directory_ex.h" 27 #include "filter/filter_factory.h" 28 #include "media_errors.h" 29 #include "osal/task/jobutils.h" 30 #include "osal/task/pipeline_threadpool.h" 31 #include "osal/task/task.h" 32 #include "osal/utils/dump_buffer.h" 33 #include "plugin/plugin_time.h" 34 #include "media_dfx.h" 35 #include "media_utils.h" 36 #include "meta_utils.h" 37 #include "meta/media_types.h" 38 #include "param_wrapper.h" 39 40 namespace { 41 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, LOG_DOMAIN_SYSTEM_PLAYER, "HiPlayer" }; 42 const float MAX_MEDIA_VOLUME = 1.0f; // standard interface volume is between 0 to 1. 43 const int32_t AUDIO_SINK_MAX_LATENCY = 400; // audio sink write latency ms 44 const int32_t FRAME_RATE_UNIT_MULTIPLE = 100; // the unit of frame rate is frames per 100s 45 const int32_t PLAYING_SEEK_WAIT_TIME = 200; // wait up to 200 ms for new frame after seek in playing. 46 const int64_t PLAY_RANGE_DEFAULT_VALUE = -1; // play range default value. 47 const int64_t SAMPLE_AMPLITUDE_INTERVAL = 100; 48 const int64_t REPORT_PROGRESS_INTERVAL = 100; // progress interval is 100ms 49 const double FRAME_RATE_DEFAULT = -1.0; 50 const double FRAME_RATE_FOR_SEEK_PERFORMANCE = 2000.0; 51 constexpr int32_t BUFFERING_LOG_FREQUENCY = 5; 52 constexpr int32_t NOTIFY_BUFFERING_END_PARAM = 0; 53 constexpr int32_t INVALID_TRACK_ID = -1; 54 static const std::unordered_set<OHOS::AudioStandard::StreamUsage> FOCUS_EVENT_USAGE_SET = { 55 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN, 56 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MEDIA, 57 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MUSIC, 58 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MOVIE, 59 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_GAME, 60 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_AUDIOBOOK, 61 }; 62 } 63 64 namespace OHOS { 65 namespace Media { 66 using namespace Pipeline; 67 using namespace OHOS::Media::Plugins; 68 class PlayerEventReceiver : public EventReceiver { 69 public: PlayerEventReceiver(HiPlayerImpl * hiPlayerImpl,std::string playerId)70 explicit PlayerEventReceiver(HiPlayerImpl* hiPlayerImpl, std::string playerId) 71 { 72 MEDIA_LOG_I("PlayerEventReceiver ctor called."); 73 std::unique_lock<std::shared_mutex> lk(cbMutex_); 74 hiPlayerImpl_ = hiPlayerImpl; 75 task_ = std::make_unique<Task>("PlayerEventReceiver", playerId, TaskType::GLOBAL, 76 OHOS::Media::TaskPriority::HIGH, false); 77 } 78 OnEvent(const Event & event)79 void OnEvent(const Event &event) override 80 { 81 MEDIA_LOG_D("PlayerEventReceiver OnEvent."); 82 task_->SubmitJobOnce([this, event] { 83 std::shared_lock<std::shared_mutex> lk(cbMutex_); 84 FALSE_RETURN(hiPlayerImpl_ != nullptr); 85 hiPlayerImpl_->OnEvent(event); 86 }); 87 } 88 OnDfxEvent(const DfxEvent & event)89 void OnDfxEvent(const DfxEvent &event) override 90 { 91 MEDIA_LOG_D_SHORT("PlayerEventReceiver OnDfxEvent."); 92 std::shared_lock<std::shared_mutex> lk(cbMutex_); 93 FALSE_RETURN(hiPlayerImpl_ != nullptr); 94 hiPlayerImpl_->HandleDfxEvent(event); 95 } 96 NotifyRelease()97 void NotifyRelease() override 98 { 99 MEDIA_LOG_D_SHORT("PlayerEventReceiver NotifyRelease."); 100 std::unique_lock<std::shared_mutex> lk(cbMutex_); 101 hiPlayerImpl_ = nullptr; 102 } 103 104 private: 105 std::shared_mutex cbMutex_ {}; 106 HiPlayerImpl* hiPlayerImpl_; 107 std::unique_ptr<Task> task_; 108 }; 109 110 class PlayerFilterCallback : public FilterCallback { 111 public: PlayerFilterCallback(HiPlayerImpl * hiPlayerImpl)112 explicit PlayerFilterCallback(HiPlayerImpl* hiPlayerImpl) 113 { 114 MEDIA_LOG_I("PlayerFilterCallback ctor called."); 115 std::unique_lock<std::shared_mutex> lk(cbMutex_); 116 hiPlayerImpl_ = hiPlayerImpl; 117 } 118 OnCallback(const std::shared_ptr<Filter> & filter,FilterCallBackCommand cmd,StreamType outType)119 Status OnCallback(const std::shared_ptr<Filter>& filter, FilterCallBackCommand cmd, StreamType outType) override 120 { 121 MEDIA_LOG_I("PlayerFilterCallback OnCallback."); 122 std::shared_lock<std::shared_mutex> lk(cbMutex_); 123 FALSE_RETURN_V(hiPlayerImpl_ != nullptr, Status::OK); // hiPlayerImpl_ is destructed 124 return hiPlayerImpl_->OnCallback(filter, cmd, outType); 125 } 126 NotifyRelease()127 void NotifyRelease() override 128 { 129 MEDIA_LOG_D_SHORT("PlayerEventReceiver NotifyRelease."); 130 std::unique_lock<std::shared_mutex> lk(cbMutex_); 131 hiPlayerImpl_ = nullptr; 132 } 133 134 private: 135 std::shared_mutex cbMutex_ {}; 136 HiPlayerImpl* hiPlayerImpl_; 137 }; 138 HiPlayerImpl(int32_t appUid,int32_t appPid,uint32_t appTokenId,uint64_t appFullTokenId)139 HiPlayerImpl::HiPlayerImpl(int32_t appUid, int32_t appPid, uint32_t appTokenId, uint64_t appFullTokenId) 140 : appUid_(appUid), appPid_(appPid), appTokenId_(appTokenId), appFullTokenId_(appFullTokenId) 141 { 142 MEDIA_LOG_D("hiPlayerImpl ctor appUid " PUBLIC_LOG_D32 " appPid " PUBLIC_LOG_D32 143 " appTokenId %{private}" PRIu32 " appFullTokenId %{private}" PRIu64, 144 appUid_, appPid_, appTokenId_, appFullTokenId_); 145 playerId_ = std::string("HiPlayer_") + std::to_string(OHOS::Media::Pipeline::Pipeline::GetNextPipelineId()); 146 pipeline_ = std::make_shared<OHOS::Media::Pipeline::Pipeline>(); 147 syncManager_ = std::make_shared<MediaSyncManager>(); 148 callbackLooper_.SetPlayEngine(this, playerId_); 149 bundleName_ = GetClientBundleName(appUid); 150 dfxAgent_ = std::make_shared<DfxAgent>(playerId_, bundleName_); 151 } 152 ~HiPlayerImpl()153 HiPlayerImpl::~HiPlayerImpl() 154 { 155 MEDIA_LOG_D("~HiPlayerImpl dtor called"); 156 if (demuxer_) { 157 pipeline_->RemoveHeadFilter(demuxer_); 158 } 159 if (dfxAgent_ != nullptr) { 160 dfxAgent_.reset(); 161 } 162 if (playerEventReceiver_ != nullptr) { 163 playerEventReceiver_->NotifyRelease(); 164 } 165 if (playerFilterCallback_ != nullptr) { 166 playerFilterCallback_->NotifyRelease(); 167 } 168 PipeLineThreadPool::GetInstance().DestroyThread(playerId_); 169 } 170 ReleaseInner()171 void HiPlayerImpl::ReleaseInner() 172 { 173 pipeline_->Stop(); 174 audioSink_.reset(); 175 #ifdef SUPPORT_VIDEO 176 if (videoDecoder_) { 177 videoDecoder_.reset(); 178 } 179 #endif 180 if (subtitleSink_) { 181 subtitleSink_.reset(); 182 } 183 syncManager_.reset(); 184 if (demuxer_) { 185 pipeline_->RemoveHeadFilter(demuxer_); 186 } 187 } 188 Init()189 Status HiPlayerImpl::Init() 190 { 191 MediaTrace trace("HiPlayerImpl::Init"); 192 MEDIA_LOG_I("Init start"); 193 auto playerEventReceiver = std::make_shared<PlayerEventReceiver>(this, playerId_); 194 auto playerFilterCallback = std::make_shared<PlayerFilterCallback>(this); 195 FALSE_RETURN_V_MSG_E(playerEventReceiver != nullptr && playerFilterCallback != nullptr, Status::ERROR_NO_MEMORY, 196 "fail to allocate memory for PlayerEventReceiver or PlayerFilterCallback"); 197 playerEventReceiver_ = playerEventReceiver; 198 playerFilterCallback_ = playerFilterCallback; 199 if (syncManager_ != nullptr) { 200 syncManager_->SetEventReceiver(playerEventReceiver_); 201 } 202 MEDIA_LOG_D("pipeline init"); 203 pipeline_->Init(playerEventReceiver_, playerFilterCallback_, playerId_); 204 MEDIA_LOG_D("pipeline Init out"); 205 for (std::pair<std::string, bool>& item: completeState_) { 206 item.second = false; 207 } 208 GetDumpFlag(); 209 return Status::OK; 210 } 211 GetDumpFlag()212 void HiPlayerImpl::GetDumpFlag() 213 { 214 const std::string dumpTag = "sys.media.player.dump.enable"; 215 std::string dumpEnable; 216 int32_t dumpRes = OHOS::system::GetStringParameter(dumpTag, dumpEnable, "false"); 217 isDump_ = (dumpEnable == "true"); 218 MEDIA_LOG_I("get dump flag, dumpRes: %{public}d, isDump_: %{public}d", dumpRes, isDump_); 219 } 220 SetDefaultAudioRenderInfo(const std::vector<std::shared_ptr<Meta>> & trackInfos)221 void HiPlayerImpl::SetDefaultAudioRenderInfo(const std::vector<std::shared_ptr<Meta>> &trackInfos) 222 { 223 MEDIA_LOG_D_SHORT("SetDefaultAudioRenderInfo"); 224 bool hasVideoTrack = false; 225 for (size_t index = 0; index < trackInfos.size(); index++) { 226 std::shared_ptr<Meta> meta = trackInfos[index]; 227 if (meta == nullptr) { 228 continue; 229 } 230 std::string trackMime; 231 if (!meta->GetData(Tag::MIME_TYPE, trackMime)) { 232 continue; 233 } 234 if (trackMime.find("video/") == 0) { 235 hasVideoTrack = true; 236 } 237 } 238 Plugins::AudioRenderInfo audioRenderInfo; 239 if (hasVideoTrack) { 240 audioRenderInfo = {AudioStandard::CONTENT_TYPE_MOVIE, AudioStandard::STREAM_USAGE_MOVIE, 0}; 241 } else { 242 audioRenderInfo = {AudioStandard::CONTENT_TYPE_MUSIC, AudioStandard::STREAM_USAGE_MUSIC, 0}; 243 } 244 if (audioRenderInfo_ == nullptr) { 245 audioRenderInfo_ = std::make_shared<Meta>(); 246 audioRenderInfo_->SetData(Tag::AUDIO_RENDER_INFO, audioRenderInfo); 247 } 248 } 249 GetRealPath(const std::string & url,std::string & realUrlPath) const250 int32_t HiPlayerImpl::GetRealPath(const std::string &url, std::string &realUrlPath) const 251 { 252 std::string fileHead = "file://"; 253 std::string tempUrlPath; 254 255 if (url.find(fileHead) == 0 && url.size() > fileHead.size()) { 256 tempUrlPath = url.substr(fileHead.size()); 257 } else { 258 tempUrlPath = url; 259 } 260 if (tempUrlPath.find("..") != std::string::npos) { 261 MEDIA_LOG_E("invalid url. The Url (%{private}s) path may be invalid.", tempUrlPath.c_str()); 262 return MSERR_FILE_ACCESS_FAILED; 263 } 264 bool ret = PathToRealPath(tempUrlPath, realUrlPath); 265 if (!ret) { 266 MEDIA_LOG_E("invalid url. The Url (%{private}s) path may be invalid.", url.c_str()); 267 return MSERR_OPEN_FILE_FAILED; 268 } 269 if (access(realUrlPath.c_str(), R_OK) != 0) { 270 return MSERR_FILE_ACCESS_FAILED; 271 } 272 return MSERR_OK; 273 } 274 IsFileUrl(const std::string & url) const275 bool HiPlayerImpl::IsFileUrl(const std::string &url) const 276 { 277 return url.find("://") == std::string::npos || url.find("file://") == 0; 278 } 279 IsValidPlayRange(int64_t start,int64_t end) const280 bool HiPlayerImpl::IsValidPlayRange(int64_t start, int64_t end) const 281 { 282 if (start < PLAY_RANGE_DEFAULT_VALUE || end < PLAY_RANGE_DEFAULT_VALUE || end == 0) { 283 return false; 284 } 285 if (pipelineStates_ == PlayerStates::PLAYER_INITIALIZED) { 286 return true; 287 } 288 if ((end == PLAY_RANGE_DEFAULT_VALUE) && (start < durationMs_.load())) { 289 return true; 290 } 291 if (start >= end || start >= durationMs_.load() || end > durationMs_.load()) { 292 return false; 293 } 294 return true; 295 } 296 IsInValidSeekTime(int32_t seekPos)297 bool HiPlayerImpl::IsInValidSeekTime(int32_t seekPos) 298 { 299 if (endTimeWithMode_ == PLAY_RANGE_DEFAULT_VALUE) { 300 return false; 301 } 302 int64_t seekTime = static_cast<int64_t>(seekPos); 303 if (startTimeWithMode_ == PLAY_RANGE_DEFAULT_VALUE) { 304 if (seekTime > endTimeWithMode_) { 305 endTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE; 306 pipeline_->SetPlayRange(startTimeWithMode_, endTimeWithMode_); 307 } 308 return false; 309 } 310 return seekTime < startTimeWithMode_ || seekTime > endTimeWithMode_; 311 } 312 GetPlayStartTime()313 int64_t HiPlayerImpl::GetPlayStartTime() 314 { 315 if (playRangeStartTime_ > PLAY_RANGE_DEFAULT_VALUE) { 316 return playRangeStartTime_; 317 } 318 int64_t rePlayStartTime = 0; 319 if (startTimeWithMode_ != PLAY_RANGE_DEFAULT_VALUE && endTimeWithMode_ != PLAY_RANGE_DEFAULT_VALUE) { 320 rePlayStartTime = startTimeWithMode_; 321 } 322 return rePlayStartTime; 323 } 324 SetInstancdId(uint64_t instanceId)325 void HiPlayerImpl::SetInstancdId(uint64_t instanceId) 326 { 327 instanceId_ = instanceId; 328 if (dfxAgent_ != nullptr) { 329 dfxAgent_->SetInstanceId(std::to_string(instanceId_)); 330 } 331 } 332 SetSource(const std::string & uri)333 int32_t HiPlayerImpl::SetSource(const std::string& uri) 334 { 335 MediaTrace trace("HiPlayerImpl::SetSource uri"); 336 MEDIA_LOG_D("HiPlayerImpl SetSource uri"); 337 CreateMediaInfo(CallType::AVPLAYER, appUid_, instanceId_); 338 playStatisticalInfo_.sourceUrl = "private"; 339 playStatisticalInfo_.sourceType = static_cast<int32_t>(SourceType::SOURCE_TYPE_URI); 340 url_ = uri; 341 PlayerDfxSourceType sourceType = PlayerDfxSourceType::DFX_SOURCE_TYPE_UNKNOWN; 342 if (IsFileUrl(uri)) { 343 std::string realUriPath; 344 int32_t result = GetRealPath(uri, realUriPath); 345 if (result != MSERR_OK) { 346 CollectionErrorInfo(result, "SetSource error: GetRealPath error"); 347 return result; 348 } 349 url_ = "file://" + realUriPath; 350 sourceType = PlayerDfxSourceType::DFX_SOURCE_TYPE_URL_FILE; 351 } 352 if (url_.find("http") == 0 || url_.find("https") == 0) { 353 isNetWorkPlay_ = true; 354 sourceType = PlayerDfxSourceType::DFX_SOURCE_TYPE_URL_NETWORK; 355 } 356 if (url_.find("fd://") == 0) { 357 sourceType = PlayerDfxSourceType::DFX_SOURCE_TYPE_URL_FD; 358 } 359 if (dfxAgent_ != nullptr) { 360 dfxAgent_->SetSourceType(sourceType); 361 } 362 hasExtSub_ = false; 363 pipelineStates_ = PlayerStates::PLAYER_INITIALIZED; 364 int ret = TransStatus(Status::OK); 365 playStatisticalInfo_.errCode = ret; 366 return ret; 367 } 368 SetMediaSource(const std::shared_ptr<AVMediaSource> & mediaSource,AVPlayStrategy strategy)369 int32_t HiPlayerImpl::SetMediaSource(const std::shared_ptr<AVMediaSource> &mediaSource, AVPlayStrategy strategy) 370 { 371 MediaTrace trace("HiPlayerImpl::SetMediaSource."); 372 MEDIA_LOG_I("SetMediaSource entered media source stream"); 373 if (mediaSource == nullptr) { 374 CollectionErrorInfo(MSERR_INVALID_VAL, "mediaSource is nullptr"); 375 return MSERR_INVALID_VAL; 376 } 377 header_ = mediaSource->header; 378 url_ = mediaSource->url; 379 preferedWidth_ = strategy.preferredWidth; 380 preferedHeight_ = strategy.preferredHeight; 381 bufferDuration_ = strategy.preferredBufferDuration; 382 preferHDR_ = strategy.preferredHdr; 383 audioLanguage_ = strategy.preferredAudioLanguage; 384 subtitleLanguage_ = strategy.preferredSubtitleLanguage; 385 386 playStatisticalInfo_.errCode = MSERR_OK; 387 388 mimeType_ = mediaSource->GetMimeType(); 389 PlayerDfxSourceType sourceType = PlayerDfxSourceType::DFX_SOURCE_TYPE_MEDIASOURCE_LOCAL; 390 if (mimeType_ != AVMimeTypes::APPLICATION_M3U8 && IsFileUrl(url_)) { 391 std::string realUriPath; 392 int32_t result = GetRealPath(url_, realUriPath); 393 if (result != MSERR_OK) { 394 MEDIA_LOG_E("SetSource error: GetRealPath error"); 395 return result; 396 } 397 url_ = "file://" + realUriPath; 398 } 399 if (url_.find("http") == 0 || url_.find("https") == 0) { 400 isNetWorkPlay_ = true; 401 sourceType = PlayerDfxSourceType::DFX_SOURCE_TYPE_MEDIASOURCE_NETWORK; 402 } 403 if (dfxAgent_ != nullptr) { 404 dfxAgent_->SetSourceType(sourceType); 405 } 406 407 pipelineStates_ = PlayerStates::PLAYER_INITIALIZED; 408 return TransStatus(Status::OK); 409 } 410 SetSource(const std::shared_ptr<IMediaDataSource> & dataSrc)411 int32_t HiPlayerImpl::SetSource(const std::shared_ptr<IMediaDataSource>& dataSrc) 412 { 413 MediaTrace trace("HiPlayerImpl::SetSource dataSrc"); 414 MEDIA_LOG_I("SetSource in source stream"); 415 if (dataSrc == nullptr) { 416 MEDIA_LOG_E("SetSource error: dataSrc is null"); 417 } 418 if (dfxAgent_ != nullptr) { 419 dfxAgent_->SetSourceType(PlayerDfxSourceType::DFX_SOURCE_TYPE_DATASRC); 420 } 421 playStatisticalInfo_.sourceType = static_cast<int32_t>(SourceType::SOURCE_TYPE_STREAM); 422 dataSrc_ = dataSrc; 423 hasExtSub_ = false; 424 pipelineStates_ = PlayerStates::PLAYER_INITIALIZED; 425 int ret = TransStatus(Status::OK); 426 playStatisticalInfo_.errCode = ret; 427 return ret; 428 } 429 AddSubSource(const std::string & url)430 int32_t HiPlayerImpl::AddSubSource(const std::string &url) 431 { 432 MediaTrace trace("HiPlayerImpl::AddSubSource uri"); 433 MEDIA_LOG_I("AddSubSource entered source uri: %{private}s", url.c_str()); 434 subUrl_ = url; 435 if (IsFileUrl(url)) { 436 std::string realUriPath; 437 int32_t result = GetRealPath(url, realUriPath); 438 if (result != MSERR_OK) { 439 MEDIA_LOG_E("AddSubSource error: GetRealPath error"); 440 return result; 441 } 442 subUrl_ = "file://" + realUriPath; 443 } 444 445 hasExtSub_ = true; 446 return TransStatus(Status::OK); 447 } 448 ResetIfSourceExisted()449 void HiPlayerImpl::ResetIfSourceExisted() 450 { 451 FALSE_RETURN(demuxer_ != nullptr); 452 MEDIA_LOG_I("Source is existed, reset the relatived objects"); 453 ReleaseInner(); 454 if (pipeline_ != nullptr) { 455 pipeline_.reset(); 456 } 457 if (audioDecoder_ != nullptr) { 458 audioDecoder_.reset(); 459 } 460 461 pipeline_ = std::make_shared<OHOS::Media::Pipeline::Pipeline>(); 462 syncManager_ = std::make_shared<MediaSyncManager>(); 463 if (syncManager_ != nullptr) { 464 syncManager_->SetEventReceiver(playerEventReceiver_); 465 } 466 MEDIA_LOG_I("Reset the relatived objects end"); 467 } 468 Prepare()469 int32_t HiPlayerImpl::Prepare() 470 { 471 return TransStatus(Status::OK); 472 } 473 SetPlayRange(int64_t start,int64_t end)474 int32_t HiPlayerImpl::SetPlayRange(int64_t start, int64_t end) 475 { 476 if (!IsValidPlayRange(start, end)) { 477 MEDIA_LOG_E("SetPlayRange failed! start: " PUBLIC_LOG_D64 ", end: " PUBLIC_LOG_D64, 478 start, end); 479 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 480 return TransStatus(Status::ERROR_INVALID_OPERATION); 481 } 482 playRangeStartTime_ = start; 483 playRangeEndTime_ = end; 484 485 if (pipeline_ != nullptr) { 486 pipeline_->SetPlayRange(playRangeStartTime_, playRangeEndTime_); 487 } 488 489 MEDIA_LOG_I("SetPlayRange success! start: " PUBLIC_LOG_D64 ", end: " PUBLIC_LOG_D64, 490 playRangeStartTime_, playRangeEndTime_); 491 return TransStatus(Status::OK); 492 } 493 SetPlayRangeWithMode(int64_t start,int64_t end,PlayerSeekMode mode)494 int32_t HiPlayerImpl::SetPlayRangeWithMode(int64_t start, int64_t end, PlayerSeekMode mode) 495 { 496 Status rtv = Status::OK; 497 if (!IsValidPlayRange(start, end)) { 498 MEDIA_LOG_E("SetPlayRangeWithMode failed! start: " PUBLIC_LOG_D64 ", end: " 499 PUBLIC_LOG_D64, start, end); 500 rtv = Status::ERROR_INVALID_PARAMETER; 501 OnEvent({"engine", EventType::EVENT_ERROR, TransStatus(rtv)}); 502 return TransStatus(rtv); 503 } 504 startTimeWithMode_ = start; 505 endTimeWithMode_ = end; 506 playRangeSeekMode_ = mode; 507 isSetPlayRange_ = true; 508 if (pipelineStates_ == PlayerStates::PLAYER_INITIALIZED || 509 pipelineStates_ == PlayerStates::PLAYER_STOPPED) { 510 MEDIA_LOG_I("current state is initialized/stopped SetPlayRangeWithMode start: " 511 PUBLIC_LOG_D64 ", end: " PUBLIC_LOG_D64, startTimeWithMode_, endTimeWithMode_); 512 return TransStatus(rtv); 513 } 514 if (pipeline_ != nullptr && demuxer_ != nullptr) { 515 pipeline_->SetPlayRange(startTimeWithMode_, endTimeWithMode_); 516 int64_t seekTimeMs = 0; 517 if (startTimeWithMode_ > PLAY_RANGE_DEFAULT_VALUE) { 518 seekTimeMs = startTimeWithMode_; 519 } 520 MEDIA_LOG_I("seek to start time: " PUBLIC_LOG_D64, seekTimeMs); 521 pipeline_->Flush(); 522 rtv = doSeek(seekTimeMs, playRangeSeekMode_); 523 if (rtv != Status::OK) { 524 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 525 MEDIA_LOG_E("seek failed to start time: " PUBLIC_LOG_D64, seekTimeMs); 526 return TransStatus(rtv); 527 } 528 if (demuxer_->IsRenderNextVideoFrameSupported() && !demuxer_->IsVideoEos()) { 529 rtv = pipeline_->Preroll(true); 530 } 531 if (pipelineStates_ == PlayerStates::PLAYER_PLAYBACK_COMPLETE) { 532 isDoCompletedSeek_ = true; 533 OnStateChanged(PlayerStateId::PAUSE); 534 } 535 Format format; 536 callbackLooper_.OnInfo(INFO_TYPE_POSITION_UPDATE, static_cast<int32_t>(seekTimeMs), format); 537 } 538 MEDIA_LOG_I("SetPlayRangeWithMode start: " PUBLIC_LOG_D64 ", end: " PUBLIC_LOG_D64, 539 startTimeWithMode_, endTimeWithMode_); 540 return TransStatus(rtv); 541 } 542 GetPlayRangeStartTime()543 int64_t HiPlayerImpl::GetPlayRangeStartTime() 544 { 545 return startTimeWithMode_ != PLAY_RANGE_DEFAULT_VALUE ? startTimeWithMode_ : playRangeStartTime_; 546 } 547 GetPlayRangeEndTime()548 int64_t HiPlayerImpl::GetPlayRangeEndTime() 549 { 550 return endTimeWithMode_ != PLAY_RANGE_DEFAULT_VALUE ? endTimeWithMode_ : playRangeEndTime_; 551 } 552 GetPlayRangeSeekMode()553 int32_t HiPlayerImpl::GetPlayRangeSeekMode() 554 { 555 return playRangeSeekMode_; 556 } 557 SetRenderFirstFrame(bool display)558 int32_t HiPlayerImpl::SetRenderFirstFrame(bool display) 559 { 560 MEDIA_LOG_I("SetRenderFirstFrame in, display: " PUBLIC_LOG_D32, display); 561 renderFirstFrame_ = display; 562 return TransStatus(Status::OK); 563 } 564 PrepareAsync()565 int32_t HiPlayerImpl::PrepareAsync() 566 { 567 MediaTrace trace("HiPlayerImpl::PrepareAsync"); 568 MEDIA_LOG_D("HiPlayerImpl PrepareAsync"); 569 if (!(pipelineStates_ == PlayerStates::PLAYER_INITIALIZED || pipelineStates_ == PlayerStates::PLAYER_STOPPED)) { 570 CollectionErrorInfo(MSERR_INVALID_OPERATION, "PrepareAsync pipelineStates not initialized or stopped"); 571 return MSERR_INVALID_OPERATION; 572 } 573 auto ret = Init(); 574 if (ret != Status::OK || isInterruptNeeded_.load()) { 575 auto errCode = TransStatus(Status::ERROR_UNSUPPORTED_FORMAT); 576 CollectionErrorInfo(errCode, "PrepareAsync error: init error"); 577 return errCode; 578 } 579 DoSetMediaSource(ret); 580 if (ret != Status::OK && !isInterruptNeeded_.load()) { 581 auto errCode = TransStatus(Status::ERROR_UNSUPPORTED_FORMAT); 582 CollectionErrorInfo(errCode, "PrepareAsync error: DoSetSource error"); 583 OnEvent({"engine", EventType::EVENT_ERROR, MSERR_UNSUPPORT_CONTAINER_TYPE}); 584 return errCode; 585 } 586 FALSE_RETURN_V(!BreakIfInterruptted(), TransStatus(Status::OK)); 587 NotifyBufferingUpdate(PlayerKeys::PLAYER_BUFFERING_START, 0); 588 MEDIA_LOG_I("PrepareAsync in, current pipeline state: " PUBLIC_LOG_S, 589 StringnessPlayerState(pipelineStates_).c_str()); 590 OnStateChanged(PlayerStateId::PREPARING); 591 ret = pipeline_->Prepare(); 592 if (ret != Status::OK) { 593 MEDIA_LOG_E("PrepareAsync failed with error " PUBLIC_LOG_D32, ret); 594 auto errCode = TransStatus(ret); 595 CollectionErrorInfo(errCode, "pipeline PrepareAsync failed"); 596 return errCode; 597 } 598 InitDuration(); 599 ret = DoSetPlayRange(); 600 FALSE_RETURN_V_MSG_E(ret == Status::OK, TransStatus(ret), "DoSetPlayRange failed"); 601 if (demuxer_ != nullptr && demuxer_->IsRenderNextVideoFrameSupported() 602 && IsAppEnableRenderFirstFrame(appUid_)) { 603 ret = pipeline_->Preroll(renderFirstFrame_); 604 auto code = TransStatus(ret); 605 if (ret != Status::OK) { 606 CollectionErrorInfo(code, "PrepareFrame failed."); 607 return code; 608 } 609 } 610 UpdatePlayerStateAndNotify(); 611 MEDIA_LOG_I("PrepareAsync End"); 612 return TransStatus(ret); 613 } 614 CollectionErrorInfo(int32_t errCode,const std::string & errMsg)615 void HiPlayerImpl::CollectionErrorInfo(int32_t errCode, const std::string& errMsg) 616 { 617 MEDIA_LOG_E("Error: " PUBLIC_LOG_S, errMsg.c_str()); 618 playStatisticalInfo_.errCode = errCode; 619 playStatisticalInfo_.errMsg = errMsg; 620 } 621 DoSetMediaSource(Status & ret)622 void HiPlayerImpl::DoSetMediaSource(Status& ret) 623 { 624 if (dataSrc_ != nullptr) { 625 ret = DoSetSource(std::make_shared<MediaSource>(dataSrc_)); 626 } else { 627 if (!header_.empty()) { 628 MEDIA_LOG_I("DoSetSource header"); 629 ret = DoSetSource(std::make_shared<MediaSource>(url_, header_)); 630 } else { 631 MEDIA_LOG_I("DoSetSource url"); 632 ret = DoSetSource(std::make_shared<MediaSource>(url_)); 633 } 634 } 635 } 636 DoSetPlayRange()637 Status HiPlayerImpl::DoSetPlayRange() 638 { 639 Status ret = Status::OK; 640 int64_t rangeStartTime = GetPlayRangeStartTime(); 641 int64_t rangeEndTime = GetPlayRangeEndTime(); 642 if (!IsValidPlayRange(rangeStartTime, rangeEndTime)) { 643 MEDIA_LOG_E("DoSetPlayRange failed! start: " PUBLIC_LOG_D64 ", end: " PUBLIC_LOG_D64, 644 rangeStartTime, rangeEndTime); 645 ret = Status::ERROR_INVALID_PARAMETER; 646 OnEvent({"engine", EventType::EVENT_ERROR, TransStatus(ret)}); 647 return ret; 648 } 649 if ((pipeline_ != nullptr) && (rangeEndTime > PLAY_RANGE_DEFAULT_VALUE)) { 650 pipeline_->SetPlayRange(rangeStartTime, rangeEndTime); 651 } 652 if ((pipeline_ != nullptr) && (rangeStartTime > PLAY_RANGE_DEFAULT_VALUE)) { 653 MEDIA_LOG_I("seek to start time: " PUBLIC_LOG_D64, rangeStartTime); 654 pipeline_ -> Flush(); 655 ret = doSeek(rangeStartTime, playRangeSeekMode_); 656 if (ret != Status::OK) { 657 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 658 MEDIA_LOG_E("seek failed to start time: " PUBLIC_LOG_D64, rangeStartTime); 659 return ret; 660 } 661 Format format; 662 callbackLooper_.OnInfo(INFO_TYPE_POSITION_UPDATE, static_cast<int32_t>(rangeStartTime), format); 663 } 664 return ret; 665 } 666 UpdatePlayerStateAndNotify()667 void HiPlayerImpl::UpdatePlayerStateAndNotify() 668 { 669 NotifyBufferingUpdate(PlayerKeys::PLAYER_BUFFERING_END, 0); 670 if (durationMs_ <= 0) { 671 HandleIsLiveStreamEvent(true); 672 } 673 NotifyDurationUpdate(PlayerKeys::PLAYER_CACHED_DURATION, durationMs_.load()); 674 InitVideoWidthAndHeight(); 675 NotifyResolutionChange(); 676 NotifyPositionUpdate(); 677 DoInitializeForHttp(); 678 UpdateMediaFirstPts(); 679 OnStateChanged(PlayerStateId::READY); 680 } 681 UpdateMediaFirstPts()682 void HiPlayerImpl::UpdateMediaFirstPts() 683 { 684 FALSE_RETURN(syncManager_ != nullptr); 685 std::string mime; 686 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 687 int64_t startTime = 0; 688 for (const auto& trackInfo : metaInfo) { 689 if (trackInfo == nullptr || !(trackInfo->GetData(Tag::MIME_TYPE, mime))) { 690 MEDIA_LOG_W("TrackInfo is null or get mime fail"); 691 continue; 692 } 693 if (!(mime.find("audio/") == 0 || mime.find("video/") == 0)) { 694 MEDIA_LOG_W("Not audio or video track"); 695 continue; 696 } 697 if (trackInfo->GetData(Tag::MEDIA_START_TIME, startTime)) { 698 syncManager_->SetMediaStartPts(startTime); 699 } 700 } 701 startTime = syncManager_->GetMediaStartPts(); 702 if (startTime != HST_TIME_NONE) { 703 mediaStartPts_ = startTime; 704 } 705 } 706 BreakIfInterruptted()707 bool HiPlayerImpl::BreakIfInterruptted() 708 { 709 if (isInterruptNeeded_.load()) { 710 OnStateChanged(PlayerStateId::READY); 711 return true; 712 } 713 return false; 714 } 715 SetInterruptState(bool isInterruptNeeded)716 void HiPlayerImpl::SetInterruptState(bool isInterruptNeeded) 717 { 718 MEDIA_LOG_I("SetInterrupt"); 719 isInterruptNeeded_ = isInterruptNeeded; 720 if (demuxer_ != nullptr) { 721 demuxer_->SetInterruptState(isInterruptNeeded); 722 } 723 if (seekAgent_ != nullptr) { 724 seekAgent_->SetInterruptState(isInterruptNeeded); 725 } 726 if (videoDecoder_ != nullptr) { 727 videoDecoder_->SetInterruptState(isInterruptNeeded); 728 } 729 } 730 SelectBitRate(uint32_t bitRate)731 int32_t HiPlayerImpl::SelectBitRate(uint32_t bitRate) 732 { 733 MEDIA_LOG_D("HiPlayerImpl:: Select BitRate %{public}d", bitRate); 734 FALSE_RETURN_V_MSG_E(demuxer_ != nullptr, 735 MSERR_INVALID_OPERATION, "SelectBitRate failed, demuxer_ is null"); 736 Status ret = demuxer_->SelectBitRate(bitRate); 737 if (ret == Status::OK) { 738 Format bitRateFormat; 739 callbackLooper_.OnInfo(INFO_TYPE_BITRATEDONE, bitRate, bitRateFormat); 740 MEDIA_LOG_I("SelectBitRate success"); 741 return MSERR_OK; 742 } 743 MEDIA_LOG_I("SelectBitRate failed"); 744 return MSERR_INVALID_OPERATION; 745 } 746 DoInitializeForHttp()747 void HiPlayerImpl::DoInitializeForHttp() 748 { 749 if (!isNetWorkPlay_) { 750 MEDIA_LOG_E("DoInitializeForHttp failed, not network play"); 751 return; 752 } 753 std::vector<uint32_t> vBitRates; 754 MEDIA_LOG_I("DoInitializeForHttp"); 755 auto ret = demuxer_->GetBitRates(vBitRates); 756 if (ret == Status::OK && vBitRates.size() > 0) { 757 int mSize = static_cast<int>(vBitRates.size()); 758 const int size = mSize; 759 uint32_t* bitrates = vBitRates.data(); 760 Format bitRateFormat; 761 (void)bitRateFormat.PutBuffer(std::string(PlayerKeys::PLAYER_AVAILABLE_BITRATES), 762 static_cast<uint8_t *>(static_cast<void *>(bitrates)), size * sizeof(uint32_t)); 763 callbackLooper_.OnInfo(INFO_TYPE_BITRATE_COLLECT, 0, bitRateFormat); 764 MEDIA_LOG_I("OnInfo INFO_TYPE_BITRATE_COLLEC"); 765 } else { 766 MEDIA_LOG_D("GetBitRates failed, ret %{public}d", ret); 767 } 768 } 769 Play()770 int32_t HiPlayerImpl::Play() 771 { 772 MediaTrace trace("HiPlayerImpl::Play"); 773 MEDIA_LOG_I("Play entered."); 774 startTime_ = GetCurrentMillisecond(); 775 playStartTime_ = GetCurrentMillisecond(); 776 int32_t ret = MSERR_INVALID_VAL; 777 if (!IsValidPlayRange(playRangeStartTime_, playRangeEndTime_)) { 778 MEDIA_LOG_E("SetPlayRange failed! start: " PUBLIC_LOG_D64 ", end: " PUBLIC_LOG_D64, 779 playRangeStartTime_, playRangeEndTime_); 780 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 781 return TransStatus(Status::ERROR_INVALID_OPERATION); 782 } 783 if (pipelineStates_ == PlayerStates::PLAYER_PLAYBACK_COMPLETE) { 784 isStreaming_ = true; 785 ret = ((GetPlayRangeStartTime() > PLAY_RANGE_DEFAULT_VALUE) ? 786 TransStatus(Seek(GetPlayStartTime(), playRangeSeekMode_, false)) : 787 TransStatus(Seek(0, PlayerSeekMode::SEEK_PREVIOUS_SYNC, false))); 788 callbackLooper_.StartReportMediaProgress(REPORT_PROGRESS_INTERVAL); 789 callbackLooper_.StartCollectMaxAmplitude(SAMPLE_AMPLITUDE_INTERVAL); 790 } else if (pipelineStates_ == PlayerStates::PLAYER_PAUSED) { 791 if (playRangeStartTime_ > PLAY_RANGE_DEFAULT_VALUE) { 792 ret = TransStatus(Seek(playRangeStartTime_, PlayerSeekMode::SEEK_PREVIOUS_SYNC, false)); 793 } 794 callbackLooper_.StartReportMediaProgress(REPORT_PROGRESS_INTERVAL); 795 callbackLooper_.StartCollectMaxAmplitude(SAMPLE_AMPLITUDE_INTERVAL); 796 ret = TransStatus(Resume()); 797 } else { 798 if (playRangeStartTime_ > PLAY_RANGE_DEFAULT_VALUE) { 799 ret = TransStatus(Seek(playRangeStartTime_, PlayerSeekMode::SEEK_PREVIOUS_SYNC, false)); 800 } 801 callbackLooper_.StartReportMediaProgress(REPORT_PROGRESS_INTERVAL); 802 callbackLooper_.StartCollectMaxAmplitude(SAMPLE_AMPLITUDE_INTERVAL); 803 syncManager_->Resume(); 804 ret = TransStatus(pipeline_->Start()); 805 if (ret != MSERR_OK) { 806 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 807 } 808 } 809 if (ret == MSERR_OK) { 810 if (!isInitialPlay_) { 811 OnStateChanged(PlayerStateId::PLAYING); 812 } else { 813 MEDIA_LOG_I("InitialPlay, pending to change state of playing"); 814 } 815 } else { 816 CollectionErrorInfo(ret, "Play failed"); 817 } 818 return ret; 819 } 820 Pause(bool isSystemOperation)821 int32_t HiPlayerImpl::Pause(bool isSystemOperation) 822 { 823 MediaTrace trace("HiPlayerImpl::Pause"); 824 MEDIA_LOG_I("Pause in"); 825 FALSE_RETURN_V_MSG_E(pipelineStates_ != PlayerStates::PLAYER_PLAYBACK_COMPLETE, 826 TransStatus(Status::OK), "completed not allow pause"); 827 Status ret = Status::OK; 828 ret = pipeline_->Pause(); 829 syncManager_->Pause(); 830 if (ret != Status::OK) { 831 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 832 } 833 callbackLooper_.StopReportMediaProgress(); 834 callbackLooper_.StopCollectMaxAmplitude(); 835 callbackLooper_.ManualReportMediaProgressOnce(); 836 OnStateChanged(PlayerStateId::PAUSE, isSystemOperation); 837 if (startTime_ != -1) { 838 playTotalDuration_ += GetCurrentMillisecond() - startTime_; 839 } 840 startTime_ = -1; 841 return TransStatus(ret); 842 } 843 PauseDemuxer()844 int32_t HiPlayerImpl::PauseDemuxer() 845 { 846 MediaTrace trace("HiPlayerImpl::PauseDemuxer"); 847 MEDIA_LOG_I("PauseDemuxer in"); 848 callbackLooper_.StopReportMediaProgress(); 849 callbackLooper_.StopCollectMaxAmplitude(); 850 callbackLooper_.ManualReportMediaProgressOnce(); 851 Status ret = demuxer_->PauseDemuxerReadLoop(); 852 return TransStatus(ret); 853 } 854 ResumeDemuxer()855 int32_t HiPlayerImpl::ResumeDemuxer() 856 { 857 MediaTrace trace("HiPlayerImpl::ResumeDemuxer"); 858 MEDIA_LOG_I("ResumeDemuxer in"); 859 FALSE_RETURN_V_MSG_E(pipelineStates_ != PlayerStates::PLAYER_STATE_ERROR, 860 TransStatus(Status::OK), "PLAYER_STATE_ERROR not allow ResumeDemuxer"); 861 callbackLooper_.StartReportMediaProgress(REPORT_PROGRESS_INTERVAL); 862 callbackLooper_.ManualReportMediaProgressOnce(); 863 callbackLooper_.StartCollectMaxAmplitude(SAMPLE_AMPLITUDE_INTERVAL); 864 Status ret = demuxer_->ResumeDemuxerReadLoop(); 865 return TransStatus(ret); 866 } 867 GetCurrentMillisecond()868 int64_t HiPlayerImpl::GetCurrentMillisecond() 869 { 870 std::chrono::system_clock::duration duration = std::chrono::system_clock::now().time_since_epoch(); 871 int64_t time = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count(); 872 return time; 873 } 874 Stop()875 int32_t HiPlayerImpl::Stop() 876 { 877 MediaTrace trace("HiPlayerImpl::Stop"); 878 MEDIA_LOG_I("Stop entered."); 879 880 // triger drm waiting condition 881 if (isDrmProtected_) { 882 std::unique_lock<std::mutex> drmLock(drmMutex_); 883 stopWaitingDrmConfig_ = true; 884 drmConfigCond_.notify_all(); 885 } 886 AutoLock lock(handleCompleteMutex_); 887 UpdatePlayStatistics(); 888 callbackLooper_.StopReportMediaProgress(); 889 callbackLooper_.StopCollectMaxAmplitude(); 890 // close demuxer first to avoid concurrent problem 891 auto ret = Status::ERROR_UNKNOWN; 892 if (pipeline_ != nullptr) { 893 ret = pipeline_->Stop(); 894 } 895 if (audioDecoder_ != nullptr) { 896 audioDecoder_->Flush(); 897 } 898 if (audioSink_ != nullptr) { 899 audioSink_->Flush(); 900 } 901 if (videoDecoder_ != nullptr) { 902 videoDecoder_->Flush(); 903 } 904 if (subtitleSink_ != nullptr) { 905 subtitleSink_->Flush(); 906 } 907 for (std::pair<std::string, bool>& item: completeState_) { 908 item.second = false; 909 } 910 911 ResetPlayRangeParameter(); 912 if (pipelineStates_ != PlayerStates::PLAYER_PREPARED) { 913 AppendPlayerMediaInfo(); 914 } 915 OnStateChanged(PlayerStateId::STOPPED); 916 ReportMediaInfo(instanceId_); 917 return TransStatus(ret); 918 } 919 ResetPlayRangeParameter()920 void HiPlayerImpl::ResetPlayRangeParameter() 921 { 922 playRangeStartTime_ = PLAY_RANGE_DEFAULT_VALUE; 923 playRangeEndTime_ = PLAY_RANGE_DEFAULT_VALUE; 924 startTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE; 925 endTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE; 926 isSetPlayRange_ = false; 927 playRangeSeekMode_ = PlayerSeekMode::SEEK_PREVIOUS_SYNC; 928 } 929 UpdatePlayStatistics()930 void HiPlayerImpl::UpdatePlayStatistics() 931 { 932 MEDIA_LOG_I("HiPlayerImpl UpdatePlayStatistics"); 933 playStatisticalInfo_.isDrmProtected = isDrmProtected_; 934 if (demuxer_ != nullptr) { 935 DownloadInfo downLoadInfo; 936 auto ret = demuxer_->GetDownloadInfo(downLoadInfo); 937 if (ret == Status::OK) { 938 MEDIA_LOG_I("GetDownloadInfo success"); 939 playStatisticalInfo_.avgDownloadRate = downLoadInfo.avgDownloadRate; 940 playStatisticalInfo_.avgDownloadSpeed = downLoadInfo.avgDownloadSpeed; 941 playStatisticalInfo_.totalDownLoadBits = downLoadInfo.totalDownLoadBits; 942 playStatisticalInfo_.isTimeOut = downLoadInfo.isTimeOut; 943 } else { 944 MEDIA_LOG_E("GetDownloadInfo failed with error " PUBLIC_LOG_D32, ret); 945 } 946 } else { 947 MEDIA_LOG_E("GetDownloadInfo failed demuxer is null"); 948 } 949 if (videoDecoder_ != nullptr) { 950 auto ret = videoDecoder_->GetLagInfo(playStatisticalInfo_.lagTimes, playStatisticalInfo_.maxLagDuration, 951 playStatisticalInfo_.avgLagDuration); 952 if (ret == Status::OK) { 953 MEDIA_LOG_I("GetLagInfo success"); 954 } else { 955 MEDIA_LOG_E("GetLagInfo failed with error " PUBLIC_LOG_D32, ret); 956 } 957 } else { 958 MEDIA_LOG_E("GetLagInfo failed videoDecoder is null error"); 959 } 960 } 961 AppendPlayerMediaInfo()962 void HiPlayerImpl::AppendPlayerMediaInfo() 963 { 964 MEDIA_LOG_I("AppendPlayerMediaInfo entered."); 965 if (startTime_ != -1) { 966 playTotalDuration_ += GetCurrentMillisecond() - startTime_; 967 } 968 startTime_ = -1; 969 playStatisticalInfo_.playDuration = static_cast<int32_t>(playTotalDuration_); 970 playStatisticalInfo_.maxSeekLatency = static_cast<int32_t>(maxSeekLatency_); 971 playStatisticalInfo_.maxAccurateSeekLatency = static_cast<int32_t>(maxAccurateSeekLatency_); 972 playStatisticalInfo_.maxSurfaceSwapLatency = static_cast<int32_t>(maxSurfaceSwapLatency_); 973 std::shared_ptr<Meta> meta = std::make_shared<Meta>(); 974 playStatisticalInfo_.containerMime = playStatisticalInfo_.videoMime + " : " + playStatisticalInfo_.audioMime; 975 meta->SetData(Tag::AV_PLAYER_ERR_CODE, playStatisticalInfo_.errCode); 976 meta->SetData(Tag::AV_PLAYER_ERR_MSG, playStatisticalInfo_.errMsg); 977 meta->SetData(Tag::AV_PLAYER_PLAY_DURATION, playStatisticalInfo_.playDuration); 978 meta->SetData(Tag::AV_PLAYER_SOURCE_TYPE, playStatisticalInfo_.sourceType); 979 meta->SetData(Tag::MEDIA_FILE_URI, playStatisticalInfo_.sourceUrl); 980 meta->SetData(Tag::AV_PLAYER_AVG_DOWNLOAD_RATE, playStatisticalInfo_.avgDownloadRate); 981 meta->SetData(Tag::AV_PLAYER_AVG_DOWNLOAD_SPEED, playStatisticalInfo_.avgDownloadSpeed); 982 meta->SetData(Tag::AV_PLAYER_DOWNLOAD_TOTAL_BITS, playStatisticalInfo_.totalDownLoadBits); 983 meta->SetData(Tag::AV_PLAYER_DOWNLOAD_TIME_OUT, playStatisticalInfo_.isTimeOut); 984 meta->SetData(Tag::AV_PLAYER_CONTAINER_MIME, playStatisticalInfo_.containerMime); 985 meta->SetData(Tag::AV_PLAYER_VIDEO_MIME, playStatisticalInfo_.videoMime); 986 meta->SetData(Tag::AV_PLAYER_VIDEO_RESOLUTION, playStatisticalInfo_.videoResolution); 987 meta->SetData(Tag::AV_PLAYER_VIDEO_BITRATE, playStatisticalInfo_.videoBitrate); 988 meta->SetData(Tag::AV_PLAYER_VIDEO_FRAMERATE, playStatisticalInfo_.videoFrameRate); 989 meta->SetData(Tag::AV_PLAYER_HDR_TYPE, playStatisticalInfo_.hdrType); 990 meta->SetData(Tag::AV_PLAYER_AUDIO_MIME, playStatisticalInfo_.audioMime); 991 meta->SetData(Tag::AUDIO_SAMPLE_RATE, playStatisticalInfo_.audioSampleRate); 992 meta->SetData(Tag::AUDIO_CHANNEL_COUNT, playStatisticalInfo_.audioChannelCount); 993 meta->SetData(Tag::AV_PLAYER_AUDIO_BITRATE, playStatisticalInfo_.audioBitrate); 994 meta->SetData(Tag::AV_PLAYER_IS_DRM_PROTECTED, playStatisticalInfo_.isDrmProtected); 995 meta->SetData(Tag::AV_PLAYER_START_LATENCY, playStatisticalInfo_.startLatency); 996 meta->SetData(Tag::AV_PLAYER_MAX_SEEK_LATENCY, playStatisticalInfo_.maxSeekLatency); 997 meta->SetData(Tag::AV_PLAYER_MAX_ACCURATE_SEEK_LATENCY, playStatisticalInfo_.maxAccurateSeekLatency); 998 meta->SetData(Tag::AV_PLAYER_LAG_TIMES, playStatisticalInfo_.lagTimes); 999 meta->SetData(Tag::AV_PLAYER_MAX_LAG_DURATION, playStatisticalInfo_.maxLagDuration); 1000 meta->SetData(Tag::AV_PLAYER_AVG_LAG_DURATION, playStatisticalInfo_.avgLagDuration); 1001 meta->SetData(Tag::AV_PLAYER_MAX_SURFACESWAP_LATENCY, playStatisticalInfo_.maxSurfaceSwapLatency); 1002 AppendMediaInfo(meta, instanceId_); 1003 } 1004 Reset()1005 int32_t HiPlayerImpl::Reset() 1006 { 1007 MediaTrace trace("HiPlayerImpl::Reset"); 1008 if (pipelineStates_ == PlayerStates::PLAYER_STOPPED) { 1009 return TransStatus(Status::OK); 1010 } 1011 singleLoop_ = false; 1012 auto ret = Stop(); 1013 if (syncManager_ != nullptr) { 1014 syncManager_->ResetMediaStartPts(); 1015 syncManager_->Reset(); 1016 } 1017 if (dfxAgent_ != nullptr) { 1018 dfxAgent_->SetSourceType(PlayerDfxSourceType::DFX_SOURCE_TYPE_UNKNOWN); 1019 dfxAgent_->ResetAgent(); 1020 } 1021 OnStateChanged(PlayerStateId::STOPPED); 1022 return ret; 1023 } 1024 SeekToCurrentTime(int32_t mSeconds,PlayerSeekMode mode)1025 int32_t HiPlayerImpl::SeekToCurrentTime(int32_t mSeconds, PlayerSeekMode mode) 1026 { 1027 MEDIA_LOG_I("SeekToCurrentTime in. mSeconds : " PUBLIC_LOG_D32 ", seekMode : " PUBLIC_LOG_D32, 1028 mSeconds, static_cast<int32_t>(mode)); 1029 return Seek(mSeconds, mode); 1030 } 1031 HandleEosPlay()1032 int32_t HiPlayerImpl::HandleEosPlay() 1033 { 1034 Plugins::AudioRenderInfo audioRenderInfo; 1035 FALSE_RETURN_V(audioRenderInfo_ && 1036 audioRenderInfo_->GetData(Tag::AUDIO_RENDER_INFO, audioRenderInfo), MSERR_INVALID_VAL); 1037 FALSE_RETURN_V(audioRenderInfo.streamUsage > AudioStandard::StreamUsage::STREAM_USAGE_INVALID && 1038 audioRenderInfo.streamUsage < AudioStandard::StreamUsage::STREAM_USAGE_MAX, MSERR_INVALID_VAL); 1039 auto it = FOCUS_EVENT_USAGE_SET.find(static_cast<AudioStandard::StreamUsage>(audioRenderInfo.streamUsage)); 1040 FALSE_RETURN_V(it == FOCUS_EVENT_USAGE_SET.end(), MSERR_INVALID_VAL); 1041 FALSE_RETURN_V(dfxAgent_ != nullptr, MSERR_INVALID_STATE); 1042 DfxEvent event = { .type = DfxEventType::DFX_INFO_PLAYER_EOS_SEEK, .param = appUid_ }; 1043 dfxAgent_->OnDfxEvent(event); 1044 return MSERR_OK; 1045 } 1046 Seek(int64_t mSeconds,PlayerSeekMode mode,bool notifySeekDone)1047 Status HiPlayerImpl::Seek(int64_t mSeconds, PlayerSeekMode mode, bool notifySeekDone) 1048 { 1049 MediaTrace trace("HiPlayerImpl::Seek"); 1050 MEDIA_LOG_I("Seek entered. mSeconds : " PUBLIC_LOG_D64 ", seekMode : " PUBLIC_LOG_D32, 1051 mSeconds, static_cast<int32_t>(mode)); 1052 if (IsSeekInSitu(mSeconds)) { 1053 MEDIA_LOG_I("Return and already at curPosMs: " PUBLIC_LOG_D64, mSeconds); 1054 NotifySeek(Status::OK, notifySeekDone, mSeconds); 1055 return Status::OK; 1056 } 1057 int64_t seekStartTime = GetCurrentMillisecond(); 1058 if (audioSink_ != nullptr) { 1059 audioSink_->SetIsTransitent(true); 1060 } 1061 FALSE_RETURN_V_MSG_E(durationMs_.load() > 0, Status::ERROR_INVALID_PARAMETER, 1062 "Seek, invalid operation, source is unseekable or invalid"); 1063 isSeek_ = true; 1064 int64_t seekPos = std::max(static_cast<int64_t>(0), std::min(mSeconds, static_cast<int64_t>(durationMs_.load()))); 1065 auto rtv = seekPos >= 0 ? Status::OK : Status::ERROR_INVALID_PARAMETER; 1066 if (rtv == Status::OK) { 1067 rtv = HandleSeek(seekPos, mode); 1068 } 1069 NotifySeek(rtv, notifySeekDone, seekPos); 1070 if (audioSink_ != nullptr) { 1071 audioSink_->SetIsTransitent(false); 1072 } 1073 isSeek_ = false; 1074 UpdateMaxSeekLatency(mode, seekStartTime); 1075 return rtv; 1076 } 1077 HandleSeek(int64_t seekPos,PlayerSeekMode mode)1078 Status HiPlayerImpl::HandleSeek(int64_t seekPos, PlayerSeekMode mode) 1079 { 1080 switch (pipelineStates_) { 1081 case PlayerStates::PLAYER_STARTED: { 1082 return doStartedSeek(seekPos, mode); 1083 } 1084 case PlayerStates::PLAYER_PAUSED: { 1085 return doPausedSeek(seekPos, mode); 1086 } 1087 case PlayerStates::PLAYER_PLAYBACK_COMPLETE: { 1088 return doCompletedSeek(seekPos, mode); 1089 } 1090 case PlayerStates::PLAYER_PREPARED: { 1091 return doPreparedSeek(seekPos, mode); 1092 } 1093 default: 1094 MEDIA_LOG_I_SHORT("Seek in error pipelineStates: " PUBLIC_LOG_D32, 1095 static_cast<int32_t>(pipelineStates_)); 1096 return Status::ERROR_WRONG_STATE; 1097 } 1098 } 1099 IsSeekInSitu(int64_t mSeconds)1100 bool HiPlayerImpl::IsSeekInSitu(int64_t mSeconds) 1101 { 1102 int32_t curPosMs = 0; 1103 GetCurrentTime(curPosMs); 1104 int64_t currentMs = static_cast<int64_t>(curPosMs); 1105 if (pipelineStates_ == PlayerStates::PLAYER_PREPARED || pipelineStates_ == PlayerStates::PLAYER_PAUSED) { 1106 return mSeconds == currentMs; 1107 } 1108 return false; 1109 } 1110 UpdateMaxSeekLatency(PlayerSeekMode mode,int64_t seekStartTime)1111 void HiPlayerImpl::UpdateMaxSeekLatency(PlayerSeekMode mode, int64_t seekStartTime) 1112 { 1113 int64_t seekDiffTime = GetCurrentMillisecond() - seekStartTime; 1114 if (mode == PlayerSeekMode::SEEK_CLOSEST) { 1115 maxAccurateSeekLatency_ = (maxAccurateSeekLatency_ > seekDiffTime) ? maxAccurateSeekLatency_ : seekDiffTime; 1116 } else { 1117 maxSeekLatency_ = (maxSeekLatency_ > seekDiffTime) ? maxSeekLatency_ : seekDiffTime; 1118 } 1119 } 1120 NotifySeek(Status rtv,bool flag,int64_t seekPos)1121 void HiPlayerImpl::NotifySeek(Status rtv, bool flag, int64_t seekPos) 1122 { 1123 if (rtv != Status::OK) { 1124 MEDIA_LOG_E("Seek done, seek error"); 1125 // change player state to PLAYER_STATE_ERROR when seek error. 1126 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 1127 Format format; 1128 callbackLooper_.OnInfo(INFO_TYPE_SEEKDONE, -1, format); 1129 } else if (flag) { 1130 // only notify seekDone for external call. 1131 NotifySeekDone(seekPos); 1132 } 1133 } 1134 Seek(int32_t mSeconds,PlayerSeekMode mode)1135 int32_t HiPlayerImpl::Seek(int32_t mSeconds, PlayerSeekMode mode) 1136 { 1137 MediaTrace trace("HiPlayerImpl::Seek."); 1138 if (IsInValidSeekTime(mSeconds)) { 1139 MEDIA_LOG_E("Current seek time is not at playRange"); 1140 auto errCode = TransStatus(Status::ERROR_INVALID_PARAMETER); 1141 OnEvent({"engine", EventType::EVENT_ERROR, errCode}); 1142 return errCode; 1143 } 1144 MEDIA_LOG_I("Seek."); 1145 return TransStatus(Seek(mSeconds, mode, true)); 1146 } 1147 doPreparedSeek(int64_t seekPos,PlayerSeekMode mode)1148 Status HiPlayerImpl::doPreparedSeek(int64_t seekPos, PlayerSeekMode mode) 1149 { 1150 MEDIA_LOG_I("doPreparedSeek."); 1151 pipeline_ -> Flush(); 1152 auto rtv = doSeek(seekPos, mode); 1153 if ((rtv == Status::OK) && demuxer_->IsRenderNextVideoFrameSupported() && !demuxer_->IsVideoEos()) { 1154 rtv = pipeline_->Preroll(true); 1155 } 1156 return rtv; 1157 } 1158 doStartedSeek(int64_t seekPos,PlayerSeekMode mode)1159 Status HiPlayerImpl::doStartedSeek(int64_t seekPos, PlayerSeekMode mode) 1160 { 1161 MEDIA_LOG_I("doStartedSeek"); 1162 pipeline_ -> Pause(); 1163 pipeline_ -> Flush(); 1164 auto rtv = doSeek(seekPos, mode); 1165 pipeline_ -> Resume(); 1166 inEosSeek_ = false; 1167 return rtv; 1168 } 1169 doPausedSeek(int64_t seekPos,PlayerSeekMode mode)1170 Status HiPlayerImpl::doPausedSeek(int64_t seekPos, PlayerSeekMode mode) 1171 { 1172 MEDIA_LOG_I("doPausedSeek."); 1173 pipeline_ -> Pause(); 1174 pipeline_ -> Flush(); 1175 auto rtv = doSeek(seekPos, mode); 1176 inEosSeek_ = false; 1177 if ((rtv == Status::OK) && demuxer_->IsRenderNextVideoFrameSupported() && !demuxer_->IsVideoEos()) { 1178 rtv = pipeline_->Preroll(true); 1179 } 1180 return rtv; 1181 } 1182 doCompletedSeek(int64_t seekPos,PlayerSeekMode mode)1183 Status HiPlayerImpl::doCompletedSeek(int64_t seekPos, PlayerSeekMode mode) 1184 { 1185 MEDIA_LOG_D("doCompletedSeek"); 1186 pipeline_ -> Flush(); 1187 auto rtv = doSeek(seekPos, mode); 1188 if (mode != SEEK_CLOSEST && audioSink_ != nullptr) { 1189 audioSink_->SetSeekTime(0); 1190 } 1191 if (isStreaming_) { 1192 MEDIA_LOG_D("doCompletedSeek isStreaming_ is true"); 1193 pipeline_->Resume(); 1194 syncManager_->Resume(); 1195 } else { 1196 if ((rtv == Status::OK) && demuxer_->IsRenderNextVideoFrameSupported() && !demuxer_->IsVideoEos()) { 1197 rtv = pipeline_->Preroll(true); 1198 } 1199 isDoCompletedSeek_ = true; 1200 callbackLooper_.StopReportMediaProgress(); 1201 callbackLooper_.StopCollectMaxAmplitude(); 1202 callbackLooper_.ManualReportMediaProgressOnce(); 1203 OnStateChanged(PlayerStateId::PAUSE); 1204 } 1205 return rtv; 1206 } 1207 InnerDoSeek(int64_t seekTimeUs,int64_t seekPos,PlayerSeekMode mode)1208 Status HiPlayerImpl::InnerDoSeek(int64_t seekTimeUs, int64_t seekPos, PlayerSeekMode mode) 1209 { 1210 if (mode == PlayerSeekMode::SEEK_CLOSEST) { // reset mode 1211 mode = PlayerSeekMode::SEEK_NEXT_SYNC; 1212 if (audioSink_) { 1213 audioSink_->SetSeekTime(seekTimeUs); 1214 } 1215 } 1216 if (videoDecoder_ != nullptr) { 1217 videoDecoder_->ResetSeekInfo(); 1218 } 1219 int64_t realSeekTime = seekPos; 1220 auto seekMode = Transform2SeekMode(mode); 1221 auto rtv = demuxer_->SeekTo(seekPos, seekMode, realSeekTime); 1222 // if it has no next key frames, seek previous. 1223 if (rtv != Status::OK && mode == PlayerSeekMode::SEEK_NEXT_SYNC) { 1224 seekMode = Transform2SeekMode(PlayerSeekMode::SEEK_PREVIOUS_SYNC); 1225 rtv = demuxer_->SeekTo(seekPos, seekMode, realSeekTime); 1226 } 1227 if (rtv == Status::OK) { 1228 syncManager_->Seek(seekTimeUs); 1229 if (subtitleSink_ != nullptr) { 1230 subtitleSink_->NotifySeek(); 1231 } 1232 } 1233 return rtv; 1234 } 1235 NeedSeekClosest()1236 bool HiPlayerImpl::NeedSeekClosest() 1237 { 1238 MEDIA_LOG_D("NeedSeekClosest begin"); 1239 std::vector<Format> trackInfo; 1240 GetAudioTrackInfo(trackInfo); 1241 if (trackInfo.size() == 0) { 1242 MEDIA_LOG_D("NeedSeekClosest end true"); 1243 return true; 1244 } 1245 for (size_t i = 0; i < trackInfo.size(); i++) { 1246 int32_t trackIndex = -1; 1247 trackInfo[i].GetIntValue("track_index", trackIndex); 1248 if (trackIndex != currentAudioTrackId_) { 1249 continue; 1250 } 1251 std::string mime = ""; 1252 trackInfo[i].GetStringValue("codec_mime", mime); 1253 if (mime == "audio/x-ape") { 1254 MEDIA_LOG_D("NeedSeekClosest end false"); 1255 return false; 1256 } 1257 } 1258 MEDIA_LOG_D("NeedSeekClosest end true"); 1259 return true; 1260 } 1261 doSeek(int64_t seekPos,PlayerSeekMode mode)1262 Status HiPlayerImpl::doSeek(int64_t seekPos, PlayerSeekMode mode) 1263 { 1264 MEDIA_LOG_D("doSeek"); 1265 int64_t seekTimeUs = 0; 1266 FALSE_RETURN_V_MSG_E(Plugins::Us2HstTime(seekPos, seekTimeUs), 1267 Status::ERROR_INVALID_PARAMETER, "Invalid seekPos: %{public}" PRId64, seekPos); 1268 if (mode == PlayerSeekMode::SEEK_CLOSEST && NeedSeekClosest()) { 1269 return HandleSeekClosest(seekPos, seekTimeUs); 1270 } 1271 return InnerDoSeek(seekTimeUs, seekPos, mode); 1272 } 1273 HandleSeekClosest(int64_t seekPos,int64_t seekTimeUs)1274 Status HiPlayerImpl::HandleSeekClosest(int64_t seekPos, int64_t seekTimeUs) 1275 { 1276 MEDIA_LOG_I_SHORT("doSeek SEEK_CLOSEST"); 1277 isSeekClosest_.store(true); 1278 if (videoDecoder_ != nullptr) { 1279 videoDecoder_->SetSeekTime(seekTimeUs + mediaStartPts_); 1280 } 1281 if (audioSink_ != nullptr) { 1282 audioSink_->SetIsCancelStart(true); 1283 } 1284 seekAgent_ = std::make_shared<SeekAgent>(demuxer_, mediaStartPts_); 1285 SetFrameRateForSeekPerformance(FRAME_RATE_FOR_SEEK_PERFORMANCE); 1286 bool timeout = false; 1287 auto res = seekAgent_->Seek(seekPos, timeout); 1288 SetFrameRateForSeekPerformance(FRAME_RATE_DEFAULT); 1289 MEDIA_LOG_I_SHORT("seekAgent_ Seek end"); 1290 if (res != Status::OK) { 1291 MEDIA_LOG_E_SHORT("Seek closest failed"); 1292 } else { 1293 syncManager_->Seek(seekTimeUs, true); 1294 if (timeout && videoDecoder_ != nullptr) { 1295 videoDecoder_->ResetSeekInfo(); 1296 } 1297 } 1298 if (audioSink_ != nullptr) { 1299 audioSink_->SetIsCancelStart(false); 1300 } 1301 if (subtitleSink_ != nullptr) { 1302 subtitleSink_->NotifySeek(); 1303 } 1304 seekAgent_.reset(); 1305 return res; 1306 } 1307 SetVolume(float leftVolume,float rightVolume)1308 int32_t HiPlayerImpl::SetVolume(float leftVolume, float rightVolume) 1309 { 1310 MEDIA_LOG_D("SetVolume in"); 1311 FALSE_RETURN_V_MSG_E(!(leftVolume < 0 || leftVolume > MAX_MEDIA_VOLUME 1312 || rightVolume < 0 || rightVolume > MAX_MEDIA_VOLUME), 1313 (int32_t)Status::ERROR_INVALID_PARAMETER, "volume not valid, should be in range [0,100]"); 1314 float volume = 0.0f; 1315 if (leftVolume < 1e-6 && rightVolume >= 1e-6) { // 1e-6 1316 volume = rightVolume; 1317 } else if (rightVolume < 1e-6 && leftVolume >= 1e-6) { // 1e-6 1318 volume = leftVolume; 1319 } else { 1320 volume = (leftVolume + rightVolume) / 2; // 2 1321 } 1322 volume /= MAX_MEDIA_VOLUME; // normalize to 0~1 1323 FALSE_RETURN_V_MSG_E(audioSink_ != nullptr, (int32_t)TransStatus(Status::ERROR_INVALID_OPERATION), 1324 "Set volume failed, audio sink is nullptr"); 1325 MEDIA_LOG_D("Sink SetVolume"); 1326 Status ret = audioSink_->SetVolume(volume); 1327 if (ret != Status::OK) { 1328 MEDIA_LOG_E("SetVolume failed with error " PUBLIC_LOG_D32, static_cast<int>(ret)); 1329 } 1330 return TransStatus(ret); 1331 } 1332 SetVideoSurface(sptr<Surface> surface)1333 int32_t HiPlayerImpl::SetVideoSurface(sptr<Surface> surface) 1334 { 1335 MEDIA_LOG_D("SetVideoSurface in"); 1336 #ifdef SUPPORT_VIDEO 1337 int64_t startSetSurfaceTime = GetCurrentMillisecond(); 1338 FALSE_RETURN_V_MSG_E(surface != nullptr, (int32_t)(Status::ERROR_INVALID_PARAMETER), 1339 "Set video surface failed, surface == nullptr"); 1340 surface_ = surface; 1341 if (videoDecoder_ != nullptr && 1342 pipelineStates_ != PlayerStates::PLAYER_STOPPED && 1343 pipelineStates_ != PlayerStates::PLAYER_STATE_ERROR) { 1344 return TransStatus(videoDecoder_->SetVideoSurface(surface)); 1345 } 1346 int64_t endSetSurfaceTime = GetCurrentMillisecond(); 1347 int64_t diffTime = endSetSurfaceTime - startSetSurfaceTime; 1348 maxSurfaceSwapLatency_ = maxSurfaceSwapLatency_ > diffTime ? maxSurfaceSwapLatency_ : diffTime; 1349 #endif 1350 return TransStatus(Status::OK); 1351 } 1352 SetDecryptConfig(const sptr<OHOS::DrmStandard::IMediaKeySessionService> & keySessionProxy,bool svp)1353 int32_t HiPlayerImpl::SetDecryptConfig(const sptr<OHOS::DrmStandard::IMediaKeySessionService> &keySessionProxy, 1354 bool svp) 1355 { 1356 MEDIA_LOG_I("SetDecryptConfig in"); 1357 #ifdef SUPPORT_AVPLAYER_DRM 1358 FALSE_RETURN_V_MSG_E(keySessionProxy != nullptr, (int32_t)(Status::ERROR_INVALID_PARAMETER), 1359 "SetDecryptConfig failed, keySessionProxy == nullptr"); 1360 keySessionServiceProxy_ = keySessionProxy; 1361 if (svp) { 1362 svpMode_ = HiplayerSvpMode::SVP_TRUE; 1363 } else { 1364 svpMode_ = HiplayerSvpMode::SVP_FALSE; 1365 } 1366 1367 std::unique_lock<std::mutex> drmLock(drmMutex_); 1368 MEDIA_LOG_I("For Drmcond SetDecryptConfig will trig drmPreparedCond"); 1369 isDrmPrepared_ = true; 1370 drmConfigCond_.notify_all(); 1371 #endif 1372 return TransStatus(Status::OK); 1373 } 1374 SetLooping(bool loop)1375 int32_t HiPlayerImpl::SetLooping(bool loop) 1376 { 1377 MEDIA_LOG_I("SetLooping in, loop: " PUBLIC_LOG_D32, loop); 1378 singleLoop_ = loop; 1379 return TransStatus(Status::OK); 1380 } 1381 SetParameter(const Format & params)1382 int32_t HiPlayerImpl::SetParameter(const Format& params) 1383 { 1384 MediaTrace trace("HiPlayerImpl::SetParameter"); 1385 #ifdef SUPPORT_VIDEO 1386 if (params.ContainKey(PlayerKeys::VIDEO_SCALE_TYPE)) { 1387 int32_t videoScaleType = 0; 1388 params.GetIntValue(PlayerKeys::VIDEO_SCALE_TYPE, videoScaleType); 1389 return SetVideoScaleType(VideoScaleType(videoScaleType)); 1390 } 1391 #endif 1392 if (params.ContainKey(PlayerKeys::CONTENT_TYPE) && params.ContainKey(PlayerKeys::STREAM_USAGE)) { 1393 int32_t contentType; 1394 int32_t streamUsage; 1395 int32_t rendererFlag; 1396 params.GetIntValue(PlayerKeys::CONTENT_TYPE, contentType); 1397 params.GetIntValue(PlayerKeys::STREAM_USAGE, streamUsage); 1398 params.GetIntValue(PlayerKeys::RENDERER_FLAG, rendererFlag); 1399 return SetAudioRendererInfo(contentType, streamUsage, rendererFlag); 1400 } 1401 if (params.ContainKey(PlayerKeys::AUDIO_INTERRUPT_MODE)) { 1402 int32_t interruptMode = 0; 1403 params.GetIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, interruptMode); 1404 return SetAudioInterruptMode(interruptMode); 1405 } 1406 return TransStatus(Status::OK); 1407 } 1408 SetObs(const std::weak_ptr<IPlayerEngineObs> & obs)1409 int32_t HiPlayerImpl::SetObs(const std::weak_ptr<IPlayerEngineObs>& obs) 1410 { 1411 MEDIA_LOG_I("SetObs"); 1412 callbackLooper_.StartWithPlayerEngineObs(obs); 1413 return TransStatus(Status::OK); 1414 } 1415 GetCurrentTime(int32_t & currentPositionMs)1416 int32_t HiPlayerImpl::GetCurrentTime(int32_t& currentPositionMs) 1417 { 1418 if (!isSetPlayRange_ && (curState_ == PlayerStateId::EOS || inEosSeek_)) { 1419 currentPositionMs = durationMs_.load(); 1420 return TransStatus(Status::OK); 1421 } 1422 if (isSeek_.load()) { 1423 return TransStatus(Status::ERROR_UNKNOWN); 1424 } 1425 FALSE_RETURN_V(syncManager_ != nullptr, TransStatus(Status::ERROR_NULL_POINTER)); 1426 currentPositionMs = Plugins::HstTime2Us32(syncManager_->GetMediaTimeNow()); 1427 MEDIA_LOG_D("GetCurrentTime currentPositionMs: " PUBLIC_LOG_D32, currentPositionMs); 1428 if (currentPositionMs < 0) { 1429 currentPositionMs = 0; 1430 } 1431 if (durationMs_.load() > 0 && currentPositionMs > durationMs_.load()) { 1432 currentPositionMs = durationMs_.load(); 1433 } 1434 return TransStatus(Status::OK); 1435 } 1436 GetDuration(int32_t & durationMs)1437 int32_t HiPlayerImpl::GetDuration(int32_t& durationMs) 1438 { 1439 durationMs = durationMs_.load(); 1440 MEDIA_LOG_I("GetDuration " PUBLIC_LOG_D32, durationMs); 1441 return TransStatus(Status::OK); 1442 } 1443 InitDuration()1444 int32_t HiPlayerImpl::InitDuration() 1445 { 1446 FALSE_RETURN_V_MSG_E(demuxer_ != nullptr, 1447 TransStatus(Status::ERROR_WRONG_STATE), "Get media duration failed, demuxer is not ready"); 1448 int64_t duration = 0; 1449 bool found = false; 1450 if (demuxer_->GetDuration(duration)) { 1451 found = true; 1452 } else { 1453 MEDIA_LOG_W("Get media duration failed"); 1454 } 1455 if (found && duration > 0 && duration != durationMs_.load()) { 1456 durationMs_ = Plugins::HstTime2Us(duration); 1457 } 1458 durationMs_ = std::max(durationMs_.load(), 0); 1459 MEDIA_LOG_D("duration: " PUBLIC_LOG_D32, durationMs_.load()); 1460 return TransStatus(Status::OK); 1461 } 1462 SetBundleName(std::string bundleName)1463 void HiPlayerImpl::SetBundleName(std::string bundleName) 1464 { 1465 if (!bundleName.empty()) { 1466 MEDIA_LOG_I("SetBundleName bundleName: " PUBLIC_LOG_S, bundleName.c_str()); 1467 demuxer_->SetBundleName(bundleName); 1468 } else { 1469 MEDIA_LOG_I("SetBundleName failed"); 1470 } 1471 } 1472 InitVideoWidthAndHeight()1473 int32_t HiPlayerImpl::InitVideoWidthAndHeight() 1474 { 1475 #ifdef SUPPORT_VIDEO 1476 std::vector<Format> videoTrackInfo; 1477 GetVideoTrackInfo(videoTrackInfo); 1478 if (videoTrackInfo.size() == 0) { 1479 MEDIA_LOG_E("InitVideoWidthAndHeight failed, as videoTrackInfo is empty!"); 1480 return TransStatus(Status::ERROR_INVALID_OPERATION); 1481 } 1482 int32_t currentVideoTrackId = demuxer_->GetCurrentVideoTrackId(); 1483 FALSE_RETURN_V_MSG_E(currentVideoTrackId != INVALID_TRACK_ID, TransStatus(Status::ERROR_INVALID_OPERATION), 1484 "InitVideoWidthAndHeight failed, as currentVideoTrackId is invalid!"); 1485 for (auto& videoTrack : videoTrackInfo) { 1486 int32_t videoTrackId = INVALID_TRACK_ID; 1487 videoTrack.GetIntValue("track_index", videoTrackId); 1488 if (videoTrackId != currentVideoTrackId) { 1489 continue; 1490 } 1491 int32_t height; 1492 videoTrack.GetIntValue("height", height); 1493 int32_t width; 1494 videoTrack.GetIntValue("width", width); 1495 if (height <= 0 && width <= 0) { 1496 continue; 1497 } 1498 int32_t rotation = 0; 1499 needSwapWH_ = videoTrack.GetIntValue(Tag::VIDEO_ROTATION, rotation) 1500 && (rotation == rotation90 || rotation == rotation270); 1501 MEDIA_LOG_D("rotation %{public}d", rotation); 1502 videoWidth_ = !needSwapWH_.load() ? width : height; 1503 videoHeight_ = !needSwapWH_.load() ? height : width; 1504 MEDIA_LOG_D("InitVideo width %{public}d, height %{public}d", 1505 videoWidth_.load(), videoHeight_.load()); 1506 break; 1507 } 1508 #endif 1509 return TransStatus(Status::OK); 1510 } 1511 InitAudioDefaultTrackIndex()1512 Status HiPlayerImpl::InitAudioDefaultTrackIndex() 1513 { 1514 if (!demuxer_) { 1515 return Status::ERROR_UNKNOWN; 1516 } 1517 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1518 std::string mime; 1519 for (size_t trackIndex = 0; trackIndex < metaInfo.size(); trackIndex++) { 1520 auto trackInfo = metaInfo[trackIndex]; 1521 if (!(trackInfo->GetData(Tag::MIME_TYPE, mime))) { 1522 MEDIA_LOG_W("Get MIME fail"); 1523 continue; 1524 } 1525 if (IsAudioMime(mime)) { 1526 defaultAudioTrackId_ = static_cast<int32_t>(trackIndex); 1527 break; 1528 } 1529 } 1530 currentAudioTrackId_ = defaultAudioTrackId_; 1531 return Status::OK; 1532 } 1533 InitVideoDefaultTrackIndex()1534 Status HiPlayerImpl::InitVideoDefaultTrackIndex() 1535 { 1536 if (!demuxer_) { 1537 return Status::ERROR_UNKNOWN; 1538 } 1539 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1540 std::string mime; 1541 for (size_t trackIndex = 0; trackIndex < metaInfo.size(); trackIndex++) { 1542 auto trackInfo = metaInfo[trackIndex]; 1543 if (!(trackInfo->GetData(Tag::MIME_TYPE, mime))) { 1544 MEDIA_LOG_W("Get MIME fail"); 1545 continue; 1546 } 1547 if (IsVideoMime(mime)) { 1548 defaultVideoTrackId_ = static_cast<int32_t>(trackIndex); 1549 break; 1550 } 1551 } 1552 currentVideoTrackId_ = defaultVideoTrackId_; 1553 return Status::OK; 1554 } 1555 InitSubtitleDefaultTrackIndex()1556 Status HiPlayerImpl::InitSubtitleDefaultTrackIndex() 1557 { 1558 if (!demuxer_) { 1559 return Status::ERROR_UNKNOWN; 1560 } 1561 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1562 std::string mime; 1563 for (size_t trackIndex = 0; trackIndex < metaInfo.size(); trackIndex++) { 1564 auto trackInfo = metaInfo[trackIndex]; 1565 if (!(trackInfo->GetData(Tag::MIME_TYPE, mime))) { 1566 MEDIA_LOG_W("Get MIME fail"); 1567 continue; 1568 } 1569 if (IsSubtitleMime(mime)) { 1570 defaultSubtitleTrackId_ = static_cast<int32_t>(trackIndex); 1571 break; 1572 } 1573 } 1574 currentSubtitleTrackId_ = defaultSubtitleTrackId_; 1575 return Status::OK; 1576 } 1577 SetAudioEffectMode(int32_t effectMode)1578 int32_t HiPlayerImpl::SetAudioEffectMode(int32_t effectMode) 1579 { 1580 MEDIA_LOG_I("SetAudioEffectMode in"); 1581 Status res = Status::OK; 1582 if (audioSink_ != nullptr) { 1583 res = audioSink_->SetAudioEffectMode(effectMode); 1584 } 1585 if (res != Status::OK) { 1586 MEDIA_LOG_E("audioSink set AudioEffectMode error"); 1587 return MSERR_UNKNOWN; 1588 } 1589 return MSERR_OK; 1590 } 1591 GetAudioEffectMode(int32_t & effectMode)1592 int32_t HiPlayerImpl::GetAudioEffectMode(int32_t &effectMode) 1593 { 1594 MEDIA_LOG_I("GetAudioEffectMode in"); 1595 Status res = Status::OK; 1596 if (audioSink_ != nullptr) { 1597 res = audioSink_->GetAudioEffectMode(effectMode); 1598 } 1599 FALSE_RETURN_V_MSG_E(res == Status::OK, 1600 MSERR_UNKNOWN, "audioSink get AudioEffectMode error"); 1601 return MSERR_OK; 1602 } 1603 GetMaxAmplitude()1604 float HiPlayerImpl::GetMaxAmplitude() 1605 { 1606 float maxAmplitude = 0.0f; 1607 if (audioSink_ != nullptr) { 1608 maxAmplitude = audioSink_->GetMaxAmplitude(); 1609 } 1610 return maxAmplitude; 1611 } 1612 SetPlaybackSpeed(PlaybackRateMode mode)1613 int32_t HiPlayerImpl::SetPlaybackSpeed(PlaybackRateMode mode) 1614 { 1615 MEDIA_LOG_I("SetPlaybackSpeed %{public}d", mode); 1616 Status res = Status::OK; 1617 float speed = TransformPlayRate2Float(mode); 1618 if (audioSink_ != nullptr) { 1619 res = audioSink_->SetSpeed(speed); 1620 } 1621 if (subtitleSink_ != nullptr) { 1622 res = subtitleSink_->SetSpeed(speed); 1623 } 1624 if (res != Status::OK) { 1625 MEDIA_LOG_E("SetPlaybackSpeed audioSink set speed error"); 1626 return MSERR_UNKNOWN; 1627 } 1628 if (syncManager_ != nullptr) { 1629 res = syncManager_->SetPlaybackRate(speed); 1630 } 1631 if (res != Status::OK) { 1632 MEDIA_LOG_E("SetPlaybackSpeed syncManager set audio speed error"); 1633 return MSERR_UNKNOWN; 1634 } 1635 if (demuxer_ != nullptr) { 1636 demuxer_->SetSpeed(speed); 1637 } 1638 playbackRateMode_ = mode; 1639 Format format; 1640 callbackLooper_.OnInfo(INFO_TYPE_SPEEDDONE, mode, format); 1641 MEDIA_LOG_I("SetPlaybackSpeed end"); 1642 return MSERR_OK; 1643 } 1644 GetPlaybackSpeed(PlaybackRateMode & mode)1645 int32_t HiPlayerImpl::GetPlaybackSpeed(PlaybackRateMode& mode) 1646 { 1647 MEDIA_LOG_I("GetPlaybackSpeed in"); 1648 mode = playbackRateMode_.load(); 1649 MEDIA_LOG_I("GetPlaybackSpeed end, mode is " PUBLIC_LOG_D32, mode); 1650 return MSERR_OK; 1651 } 1652 IsVideoMime(const std::string & mime)1653 bool HiPlayerImpl::IsVideoMime(const std::string& mime) 1654 { 1655 return mime.find("video/") == 0; 1656 } 1657 IsAudioMime(const std::string & mime)1658 bool HiPlayerImpl::IsAudioMime(const std::string& mime) 1659 { 1660 return mime.find("audio/") == 0; 1661 } 1662 IsSubtitleMime(const std::string & mime)1663 bool HiPlayerImpl::IsSubtitleMime(const std::string& mime) 1664 { 1665 if (mime == "application/x-subrip" || mime == "text/vtt") { 1666 return true; 1667 } 1668 return false; 1669 } 1670 GetCurrentTrack(int32_t trackType,int32_t & index)1671 int32_t HiPlayerImpl::GetCurrentTrack(int32_t trackType, int32_t &index) 1672 { 1673 FALSE_RETURN_V_MSG_W(trackType >= OHOS::Media::MediaType::MEDIA_TYPE_AUD && 1674 trackType <= OHOS::Media::MediaType::MEDIA_TYPE_SUBTITLE, 1675 MSERR_INVALID_VAL, "Invalid trackType %{public}d", trackType); 1676 if (trackType == OHOS::Media::MediaType::MEDIA_TYPE_AUD) { 1677 if (currentAudioTrackId_ < 0) { 1678 if (Status::OK != InitAudioDefaultTrackIndex()) { 1679 return MSERR_UNKNOWN; 1680 } 1681 } 1682 index = currentAudioTrackId_; 1683 } else if (trackType == OHOS::Media::MediaType::MEDIA_TYPE_VID) { 1684 if (currentVideoTrackId_ < 0) { 1685 if (Status::OK != InitVideoDefaultTrackIndex()) { 1686 return MSERR_UNKNOWN; 1687 } 1688 } 1689 index = currentVideoTrackId_; 1690 } else if (trackType == OHOS::Media::MediaType::MEDIA_TYPE_SUBTITLE) { 1691 if (currentSubtitleTrackId_ < 0) { 1692 if (Status::OK != InitSubtitleDefaultTrackIndex()) { 1693 return MSERR_UNKNOWN; 1694 } 1695 } 1696 index = currentSubtitleTrackId_; 1697 } else { 1698 (void)index; 1699 } 1700 1701 return MSERR_OK; 1702 } 1703 InnerSelectTrack(std::string mime,int32_t trackId,PlayerSwitchMode mode)1704 int32_t HiPlayerImpl::InnerSelectTrack(std::string mime, int32_t trackId, PlayerSwitchMode mode) 1705 { 1706 if (Status::OK != demuxer_->SelectTrack(trackId)) { 1707 MEDIA_LOG_E_SHORT("SelectTrack error. trackId is " PUBLIC_LOG_D32, trackId); 1708 return MSERR_UNKNOWN; 1709 } 1710 if (IsAudioMime(mime)) { 1711 currentAudioTrackId_ = trackId; 1712 } else if (IsSubtitleMime(mime)) { 1713 currentSubtitleTrackId_ = trackId; 1714 } else if (IsVideoMime(mime)) { 1715 currentVideoTrackId_ = trackId; 1716 int32_t curPosMs = 0; 1717 GetCurrentTime(curPosMs); 1718 if (mode == PlayerSwitchMode::SWITCH_SEGMENT) { 1719 MEDIA_LOG_I("SelectTrack seek begin SWITCH_SEGMENT " PUBLIC_LOG_D32, trackId); 1720 return TransStatus(Seek(curPosMs, PlayerSeekMode::SEEK_PREVIOUS_SYNC, false)); 1721 } else if (mode == PlayerSwitchMode::SWITCH_CLOSEST) { 1722 MEDIA_LOG_I("SelectTrack seek begin SWITCH_CLOSEST " PUBLIC_LOG_D32, trackId); 1723 return TransStatus(Seek(curPosMs, PlayerSeekMode::SEEK_CLOSEST, false)); 1724 } 1725 } 1726 return MSERR_OK; 1727 } 1728 SelectTrack(int32_t trackId,PlayerSwitchMode mode)1729 int32_t HiPlayerImpl::SelectTrack(int32_t trackId, PlayerSwitchMode mode) 1730 { 1731 MEDIA_LOG_I("SelectTrack begin trackId is " PUBLIC_LOG_D32, trackId); 1732 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1733 std::string mime; 1734 FALSE_RETURN_V_MSG_W(trackId >= 0 && trackId < static_cast<int32_t>(metaInfo.size()), 1735 MSERR_INVALID_VAL, "SelectTrack trackId invalid"); 1736 if (!(metaInfo[trackId]->GetData(Tag::MIME_TYPE, mime))) { 1737 MEDIA_LOG_E("SelectTrack trackId " PUBLIC_LOG_D32 "get mime error", trackId); 1738 return MSERR_INVALID_VAL; 1739 } 1740 if (IsAudioMime(mime)) { 1741 FALSE_RETURN_V_MSG_W(trackId != currentAudioTrackId_, MSERR_INVALID_VAL, "SelectTrack trackId invalid"); 1742 if (currentAudioTrackId_ < 0) { 1743 if (Status::OK != InitAudioDefaultTrackIndex()) { 1744 MEDIA_LOG_W("Init audio default track index fail"); 1745 } 1746 } 1747 } else if (IsVideoMime(mime)) { 1748 FALSE_RETURN_V_MSG_W(trackId != currentVideoTrackId_, MSERR_INVALID_VAL, "SelectTrack trackId invalid"); 1749 if (currentVideoTrackId_ < 0) { 1750 if (Status::OK != InitVideoDefaultTrackIndex()) { 1751 MEDIA_LOG_W("Init video default track index fail"); 1752 } 1753 } 1754 } else if (IsSubtitleMime(mime)) { 1755 FALSE_RETURN_V_MSG_W(trackId != currentSubtitleTrackId_, MSERR_INVALID_VAL, "SelectTrack trackId invalid"); 1756 if (currentVideoTrackId_ < 0) { 1757 if (Status::OK != InitSubtitleDefaultTrackIndex()) { 1758 MEDIA_LOG_W("Init video default track index fail"); 1759 } 1760 } 1761 } else { 1762 MEDIA_LOG_E("SelectTrack invalid mimeType. trackId is " PUBLIC_LOG_D32, trackId); 1763 return MSERR_UNKNOWN; 1764 } 1765 return InnerSelectTrack(mime, trackId, mode); 1766 } 1767 DeselectTrack(int32_t trackId)1768 int32_t HiPlayerImpl::DeselectTrack(int32_t trackId) 1769 { 1770 MEDIA_LOG_I("DeselectTrack trackId is " PUBLIC_LOG_D32, trackId); 1771 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1772 FALSE_RETURN_V_MSG_W(trackId >= 0 && trackId < static_cast<int32_t>(metaInfo.size()), 1773 MSERR_INVALID_VAL, "DeselectTrack trackId invalid"); 1774 std::string mime; 1775 if (!(metaInfo[trackId]->GetData(Tag::MIME_TYPE, mime))) { 1776 MEDIA_LOG_E("DeselectTrack trackId " PUBLIC_LOG_D32 "get mime error", trackId); 1777 return MSERR_INVALID_VAL; 1778 } 1779 if (IsAudioMime(mime)) { 1780 FALSE_RETURN_V_MSG_W(trackId == currentAudioTrackId_ && currentAudioTrackId_ >= 0, 1781 MSERR_INVALID_VAL, "DeselectTrack trackId invalid"); 1782 return SelectTrack(defaultAudioTrackId_, PlayerSwitchMode::SWITCH_SMOOTH); 1783 } else if (IsVideoMime(mime)) { 1784 FALSE_RETURN_V_MSG_W(trackId == currentVideoTrackId_ && currentVideoTrackId_ >= 0, 1785 MSERR_INVALID_VAL, "DeselectTrack trackId invalid"); 1786 return SelectTrack(defaultVideoTrackId_, PlayerSwitchMode::SWITCH_SMOOTH); 1787 } else if (IsSubtitleMime(mime)) { 1788 FALSE_RETURN_V_MSG_W(trackId == currentSubtitleTrackId_ && currentSubtitleTrackId_ >= 0, 1789 MSERR_INVALID_VAL, "DeselectTrack trackId invalid"); 1790 if (needUpdateSubtitle_.load()) { 1791 needUpdateSubtitle_.store(false); 1792 } else { 1793 needUpdateSubtitle_.store(true); 1794 } 1795 } else {} 1796 return MSERR_OK; 1797 } 1798 GetVideoTrackInfo(std::vector<Format> & videoTrack)1799 int32_t HiPlayerImpl::GetVideoTrackInfo(std::vector<Format>& videoTrack) 1800 { 1801 MEDIA_LOG_D("GetVideoTrackInfo in"); 1802 std::string mime; 1803 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1804 for (size_t trackIndex = 0; trackIndex < metaInfo.size(); trackIndex++) { 1805 auto trackInfo = metaInfo[trackIndex]; 1806 if (!(trackInfo->GetData(Tag::MIME_TYPE, mime)) || mime.find("invalid") == 0) { 1807 MEDIA_LOG_W("Get MIME fail"); 1808 continue; 1809 } 1810 if (IsVideoMime(mime)) { 1811 Format videoTrackInfo {}; 1812 playStatisticalInfo_.videoMime = mime; 1813 videoTrackInfo.PutStringValue("codec_mime", mime); 1814 videoTrackInfo.PutIntValue("track_type", static_cast<int32_t>(OHOS::Media::Plugins::MediaType::VIDEO)); 1815 videoTrackInfo.PutIntValue("track_index", trackIndex); 1816 int64_t bitRate; 1817 trackInfo->GetData(Tag::MEDIA_BITRATE, bitRate); 1818 playStatisticalInfo_.videoBitrate = static_cast<int32_t>(bitRate); 1819 videoTrackInfo.PutLongValue("bitrate", bitRate); 1820 double frameRate; 1821 trackInfo->GetData(Tag::VIDEO_FRAME_RATE, frameRate); 1822 playStatisticalInfo_.videoFrameRate = static_cast<float>(frameRate); 1823 videoTrackInfo.PutDoubleValue("frame_rate", frameRate * FRAME_RATE_UNIT_MULTIPLE); 1824 int32_t height = GetSarVideoHeight(trackInfo); 1825 videoTrackInfo.PutIntValue("height", height); 1826 int32_t width = GetSarVideoWidth(trackInfo); 1827 playStatisticalInfo_.videoResolution = std::to_string(width) + "x" + std::to_string(height); 1828 videoTrackInfo.PutIntValue("width", width); 1829 Plugins::VideoRotation rotation; 1830 trackInfo->Get<Tag::VIDEO_ROTATION>(rotation); 1831 videoTrackInfo.PutIntValue(Tag::VIDEO_ROTATION, rotation); 1832 videoTrackInfo.PutStringValue("track_name", "video"); 1833 bool isHdr = false; 1834 trackInfo->GetData(Tag::VIDEO_IS_HDR_VIVID, isHdr); 1835 if (isHdr) { 1836 playStatisticalInfo_.hdrType = static_cast<int8_t>(VideoHdrType::VIDEO_HDR_TYPE_VIVID); 1837 videoTrackInfo.PutIntValue("hdr_type", 1); 1838 } else { 1839 playStatisticalInfo_.hdrType = static_cast<int8_t>(VideoHdrType::VIDEO_HDR_TYPE_NONE); 1840 videoTrackInfo.PutIntValue("hdr_type", 0); 1841 } 1842 videoTrack.emplace_back(std::move(videoTrackInfo)); 1843 } 1844 } 1845 return TransStatus(Status::OK); 1846 } 1847 GetSarVideoWidth(std::shared_ptr<Meta> trackInfo)1848 int32_t HiPlayerImpl::GetSarVideoWidth(std::shared_ptr<Meta> trackInfo) 1849 { 1850 int32_t width; 1851 trackInfo->GetData(Tag::VIDEO_WIDTH, width); 1852 double videoSar; 1853 bool ret = trackInfo->GetData(Tag::VIDEO_SAR, videoSar); 1854 if (ret && videoSar < 1) { 1855 width = static_cast<int32_t>(width * videoSar); 1856 } 1857 return width; 1858 } 1859 GetSarVideoHeight(std::shared_ptr<Meta> trackInfo)1860 int32_t HiPlayerImpl::GetSarVideoHeight(std::shared_ptr<Meta> trackInfo) 1861 { 1862 int32_t height; 1863 trackInfo->GetData(Tag::VIDEO_HEIGHT, height); 1864 double videoSar; 1865 bool ret = trackInfo->GetData(Tag::VIDEO_SAR, videoSar); 1866 if (ret && videoSar > 1) { 1867 height = static_cast<int32_t>(height / videoSar); 1868 } 1869 return height; 1870 } 1871 GetPlaybackInfo(Format & playbackInfo)1872 int32_t HiPlayerImpl::GetPlaybackInfo(Format& playbackInfo) 1873 { 1874 MEDIA_LOG_D("GetPlaybackInfo in"); 1875 1876 PlaybackInfo playbackInfoTmp; 1877 auto ret = demuxer_->GetPlaybackInfo(playbackInfoTmp); 1878 if (ret == Status::OK) { 1879 playbackInfo.PutStringValue("server_ip_address", playbackInfoTmp.serverIpAddress); 1880 playbackInfo.PutLongValue("average_download_rate", playbackInfoTmp.averageDownloadRate); 1881 playbackInfo.PutLongValue("download_rate", playbackInfoTmp.downloadRate); 1882 playbackInfo.PutIntValue("is_downloading", playbackInfoTmp.isDownloading); 1883 playbackInfo.PutLongValue("buffer_duration", playbackInfoTmp.bufferDuration); 1884 } 1885 return TransStatus(Status::OK); 1886 } 1887 GetAudioTrackInfo(std::vector<Format> & audioTrack)1888 int32_t HiPlayerImpl::GetAudioTrackInfo(std::vector<Format>& audioTrack) 1889 { 1890 MEDIA_LOG_I("GetAudioTrackInfo in"); 1891 std::string mime; 1892 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1893 for (size_t trackIndex = 0; trackIndex < metaInfo.size(); trackIndex++) { 1894 auto trackInfo = metaInfo[trackIndex]; 1895 if (!(trackInfo->GetData(Tag::MIME_TYPE, mime)) || mime.find("invalid") == 0) { 1896 MEDIA_LOG_W("Get MIME fail"); 1897 continue; 1898 } 1899 if (IsAudioMime(mime)) { 1900 playStatisticalInfo_.audioMime = mime; 1901 Format audioTrackInfo {}; 1902 audioTrackInfo.PutStringValue("codec_mime", mime); 1903 audioTrackInfo.PutIntValue("track_type", static_cast<int32_t>(OHOS::Media::Plugins::MediaType::AUDIO)); 1904 audioTrackInfo.PutIntValue("track_index", static_cast<int32_t>(trackIndex)); 1905 int64_t bitRate = 0; 1906 trackInfo->GetData(Tag::MEDIA_BITRATE, bitRate); 1907 playStatisticalInfo_.audioBitrate = static_cast<int32_t>(bitRate); 1908 audioTrackInfo.PutLongValue("bitrate", bitRate); 1909 int32_t audioChannels = 0; 1910 trackInfo->GetData(Tag::AUDIO_CHANNEL_COUNT, audioChannels); 1911 playStatisticalInfo_.audioChannelCount = audioChannels; 1912 audioTrackInfo.PutIntValue("channel_count", audioChannels); 1913 int32_t audioSampleRate = 0; 1914 trackInfo->GetData(Tag::AUDIO_SAMPLE_RATE, audioSampleRate); 1915 playStatisticalInfo_.audioSampleRate = audioSampleRate; 1916 audioTrackInfo.PutIntValue("sample_rate", audioSampleRate); 1917 int32_t sampleDepth = 0; 1918 bool isHasData = trackInfo->GetData(Tag::AUDIO_BITS_PER_CODED_SAMPLE, sampleDepth); 1919 if (!isHasData || sampleDepth <= 0) { 1920 trackInfo->GetData(Tag::AUDIO_BITS_PER_RAW_SAMPLE, sampleDepth); 1921 } 1922 audioTrackInfo.PutIntValue("sample_depth", sampleDepth); 1923 std::string lang; 1924 trackInfo->GetData(Tag::MEDIA_LANGUAGE, lang); 1925 audioTrackInfo.PutStringValue("language", lang); 1926 audioTrackInfo.PutStringValue("track_name", "audio"); 1927 audioTrack.emplace_back(std::move(audioTrackInfo)); 1928 } 1929 } 1930 return TransStatus(Status::OK); 1931 } 1932 GetSubtitleTrackInfo(std::vector<Format> & subtitleTrack)1933 int32_t HiPlayerImpl::GetSubtitleTrackInfo(std::vector<Format>& subtitleTrack) 1934 { 1935 MEDIA_LOG_I("GetSubtitleTrackInfo in"); 1936 std::string mime; 1937 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 1938 for (size_t trackIndex = 0; trackIndex < metaInfo.size(); trackIndex++) { 1939 auto trackInfo = metaInfo[trackIndex]; 1940 if (!(trackInfo->GetData(Tag::MIME_TYPE, mime)) || mime.find("invalid") == 0) { 1941 MEDIA_LOG_W("Get MIME fail"); 1942 continue; 1943 } 1944 if (IsSubtitleMime(mime)) { 1945 playStatisticalInfo_.subtitleMime = mime; 1946 Format subtitleTrackInfo {}; 1947 subtitleTrackInfo.PutStringValue("codec_mime", mime); 1948 subtitleTrackInfo.PutIntValue("track_type", 1949 static_cast<int32_t>(OHOS::Media::Plugins::MediaType::SUBTITLE)); 1950 subtitleTrackInfo.PutIntValue("track_index", static_cast<int32_t>(trackIndex)); 1951 1952 std::string lang; 1953 trackInfo->GetData(Tag::MEDIA_LANGUAGE, lang); 1954 subtitleTrackInfo.PutStringValue("language", lang); 1955 subtitleTrackInfo.PutStringValue("track_name", "subtitle"); 1956 1957 subtitleTrack.emplace_back(std::move(subtitleTrackInfo)); 1958 } 1959 } 1960 return TransStatus(Status::OK); 1961 } 1962 GetVideoWidth()1963 int32_t HiPlayerImpl::GetVideoWidth() 1964 { 1965 #ifdef SUPPORT_VIDEO 1966 MEDIA_LOG_I("GetVideoWidth in. video width: " PUBLIC_LOG_D32, videoWidth_.load()); 1967 #endif 1968 return videoWidth_.load(); 1969 } 1970 GetVideoHeight()1971 int32_t HiPlayerImpl::GetVideoHeight() 1972 { 1973 #ifdef SUPPORT_VIDEO 1974 MEDIA_LOG_I("GetVideoHeight in. video height: " PUBLIC_LOG_D32, videoHeight_.load()); 1975 #endif 1976 return videoHeight_.load(); 1977 } 1978 SetVideoScaleType(OHOS::Media::VideoScaleType videoScaleType)1979 int32_t HiPlayerImpl::SetVideoScaleType(OHOS::Media::VideoScaleType videoScaleType) 1980 { 1981 MEDIA_LOG_I("SetVideoScaleType " PUBLIC_LOG_D32, videoScaleType); 1982 #ifdef SUPPORT_VIDEO 1983 auto meta = std::make_shared<Meta>(); 1984 meta->Set<Tag::VIDEO_SCALE_TYPE>(static_cast<int32_t>(videoScaleType)); 1985 if (videoDecoder_) { 1986 videoDecoder_->SetParameter(meta); 1987 } 1988 return TransStatus(Status::OK); 1989 #else 1990 return TransStatus(Status::OK); 1991 #endif 1992 } 1993 SetFrameRateForSeekPerformance(double frameRate)1994 int32_t HiPlayerImpl::SetFrameRateForSeekPerformance(double frameRate) 1995 { 1996 MEDIA_LOG_I("SetFrameRateForSeekPerformance, frameRate: %{public}f", frameRate); 1997 #ifdef SUPPORT_VIDEO 1998 auto meta = std::make_shared<Meta>(); 1999 meta->Set<Tag::VIDEO_FRAME_RATE>(frameRate); 2000 if (videoDecoder_) { 2001 videoDecoder_->SetParameter(meta); 2002 } 2003 return TransStatus(Status::OK); 2004 #else 2005 return TransStatus(Status::OK); 2006 #endif 2007 } 2008 SetAudioRendererInfo(const int32_t contentType,const int32_t streamUsage,const int32_t rendererFlag)2009 int32_t HiPlayerImpl::SetAudioRendererInfo(const int32_t contentType, const int32_t streamUsage, 2010 const int32_t rendererFlag) 2011 { 2012 MEDIA_LOG_I("SetAudioRendererInfo in, coutentType: " PUBLIC_LOG_D32 ", streamUsage: " PUBLIC_LOG_D32 2013 ", rendererFlag: " PUBLIC_LOG_D32, contentType, streamUsage, rendererFlag); 2014 Plugins::AudioRenderInfo audioRenderInfo {contentType, streamUsage, rendererFlag}; 2015 if (audioRenderInfo_ == nullptr) { 2016 audioRenderInfo_ = std::make_shared<Meta>(); 2017 } 2018 audioRenderInfo_->SetData(Tag::AUDIO_RENDER_SET_FLAG, true); 2019 audioRenderInfo_->SetData(Tag::AUDIO_RENDER_INFO, audioRenderInfo); 2020 if (audioSink_ != nullptr) { 2021 audioSink_->SetParameter(audioRenderInfo_); 2022 } 2023 return TransStatus(Status::OK); 2024 } 2025 SetAudioInterruptMode(const int32_t interruptMode)2026 int32_t HiPlayerImpl::SetAudioInterruptMode(const int32_t interruptMode) 2027 { 2028 MEDIA_LOG_I("SetAudioInterruptMode in"); 2029 audioInterruptMode_ = std::make_shared<Meta>(); 2030 audioInterruptMode_->SetData(Tag::AUDIO_INTERRUPT_MODE, interruptMode); 2031 if (audioSink_ != nullptr) { 2032 audioSink_->SetParameter(audioInterruptMode_); 2033 } 2034 return TransStatus(Status::OK); 2035 } 2036 OnEvent(const Event & event)2037 void HiPlayerImpl::OnEvent(const Event &event) 2038 { 2039 MEDIA_LOG_D("OnEvent entered, event type is: %{public}d", event.type); 2040 switch (event.type) { 2041 case EventType::EVENT_IS_LIVE_STREAM: { 2042 HandleIsLiveStreamEvent(AnyCast<bool>(event.param)); 2043 break; 2044 } 2045 case EventType::EVENT_ERROR: { 2046 OnStateChanged(PlayerStateId::ERROR); 2047 HandleErrorEvent(AnyCast<int32_t>(event.param)); 2048 break; 2049 } 2050 case EventType::EVENT_READY: { 2051 OnStateChanged(PlayerStateId::READY); 2052 break; 2053 } 2054 case EventType::EVENT_COMPLETE: { 2055 HandleCompleteEvent(event); 2056 break; 2057 } 2058 case EventType::EVENT_AUDIO_INTERRUPT: { 2059 NotifyAudioInterrupt(event); 2060 break; 2061 } 2062 case EventType::EVENT_AUDIO_FIRST_FRAME: { 2063 NotifyAudioFirstFrame(event); 2064 HandleInitialPlayingStateChange(event.type); 2065 break; 2066 } 2067 case EventType::EVENT_DRM_INFO_UPDATED: { 2068 HandleDrmInfoUpdatedEvent(event); 2069 break; 2070 } 2071 case EventType::EVENT_VIDEO_RENDERING_START: { 2072 MEDIA_LOG_I("video first frame reneder received"); 2073 Format format; 2074 callbackLooper_.OnInfo(INFO_TYPE_MESSAGE, PlayerMessageType::PLAYER_INFO_VIDEO_RENDERING_START, format); 2075 HandleInitialPlayingStateChange(event.type); 2076 break; 2077 } 2078 case EventType::EVENT_RESOLUTION_CHANGE: { 2079 MEDIA_LOG_I("resolution change event received"); 2080 HandleResolutionChangeEvent(event); 2081 break; 2082 } 2083 default: 2084 break; 2085 } 2086 OnEventSub(event); 2087 } 2088 OnEventSub(const Event & event)2089 void HiPlayerImpl::OnEventSub(const Event &event) 2090 { 2091 switch (event.type) { 2092 case EventType::EVENT_AUDIO_DEVICE_CHANGE : { 2093 NotifyAudioDeviceChange(event); 2094 break; 2095 } 2096 case EventType::EVENT_AUDIO_SERVICE_DIED : { 2097 NotifyAudioServiceDied(); 2098 break; 2099 } 2100 case EventType::BUFFERING_END : { 2101 if (!isBufferingStartNotified_.load() || isSeekClosest_.load()) { 2102 MEDIA_LOGI_LIMIT(BUFFERING_LOG_FREQUENCY, "BUFFERING_END BLOCKED"); 2103 break; 2104 } 2105 MEDIA_LOG_I_SHORT("BUFFERING_END PLAYING"); 2106 NotifyBufferingEnd(AnyCast<int32_t>(event.param)); 2107 break; 2108 } 2109 case EventType::BUFFERING_START : { 2110 if (isBufferingStartNotified_.load()) { 2111 MEDIA_LOGI_LIMIT(BUFFERING_LOG_FREQUENCY, "BUFFERING_START BLOCKED"); 2112 break; 2113 } 2114 MEDIA_LOG_I_SHORT("BUFFERING_START PAUSE"); 2115 NotifyBufferingStart(AnyCast<int32_t>(event.param)); 2116 break; 2117 } 2118 case EventType::EVENT_SOURCE_BITRATE_START: { 2119 HandleBitrateStartEvent(event); 2120 break; 2121 } 2122 case EventType::EVENT_SUBTITLE_TEXT_UPDATE: { 2123 NotifySubtitleUpdate(event); 2124 break; 2125 } 2126 case EventType::EVENT_CACHED_DURATION: { 2127 NotifyCachedDuration(AnyCast<int32_t>(event.param)); 2128 break; 2129 } 2130 case EventType::EVENT_BUFFER_PROGRESS: { 2131 NotifyBufferingUpdate(PlayerKeys::PLAYER_BUFFERING_PERCENT, AnyCast<int32_t>(event.param)); 2132 break; 2133 } 2134 default: 2135 break; 2136 } 2137 OnEventSubTrackChange(event); 2138 } 2139 OnEventSubTrackChange(const Event & event)2140 void HiPlayerImpl::OnEventSubTrackChange(const Event &event) 2141 { 2142 switch (event.type) { 2143 case EventType::EVENT_AUDIO_TRACK_CHANGE: { 2144 HandleAudioTrackChangeEvent(event); 2145 break; 2146 } 2147 case EventType::EVENT_VIDEO_TRACK_CHANGE: { 2148 HandleVideoTrackChangeEvent(event); 2149 break; 2150 } 2151 case EventType::EVENT_SUBTITLE_TRACK_CHANGE: { 2152 HandleSubtitleTrackChangeEvent(event); 2153 break; 2154 } 2155 default: 2156 break; 2157 } 2158 } 2159 HandleInitialPlayingStateChange(const EventType & eventType)2160 void HiPlayerImpl::HandleInitialPlayingStateChange(const EventType& eventType) 2161 { 2162 AutoLock lock(initialPlayingEventMutex_); 2163 MEDIA_LOG_I("HandleInitialPlayingStateChange"); 2164 if (!isInitialPlay_) { 2165 return; 2166 } 2167 for (std::pair<EventType, bool>& item : initialAVStates_) { 2168 if (item.first == eventType) { 2169 MEDIA_LOG_I("HandleInitialPlayingStateChange event type received = " PUBLIC_LOG_D32, 2170 static_cast<int32_t>(eventType)); 2171 item.second = true; 2172 } 2173 } 2174 2175 for (auto item : initialAVStates_) { 2176 if (item.second == false) { 2177 MEDIA_LOG_I("HandleInitialPlayingStateChange another event type not received " PUBLIC_LOG_D32, 2178 static_cast<int32_t>(item.first)); 2179 return; 2180 } 2181 } 2182 2183 MEDIA_LOG_D("av first frame reneder all received"); 2184 2185 isInitialPlay_ = false; 2186 OnStateChanged(PlayerStateId::PLAYING); 2187 2188 int64_t nowTimeMs = GetCurrentMillisecond(); 2189 playStatisticalInfo_.startLatency = static_cast<int32_t>(nowTimeMs - playStartTime_); 2190 } 2191 DoSetPlayStrategy(const std::shared_ptr<MediaSource> source)2192 void HiPlayerImpl::DoSetPlayStrategy(const std::shared_ptr<MediaSource> source) 2193 { 2194 std::shared_ptr<PlayStrategy> playStrategy = std::make_shared<PlayStrategy>(); 2195 playStrategy->width = preferedWidth_; 2196 playStrategy->height = preferedHeight_; 2197 playStrategy->duration = bufferDuration_; 2198 playStrategy->preferHDR = preferHDR_; 2199 playStrategy->audioLanguage = audioLanguage_; 2200 playStrategy->subtitleLanguage = subtitleLanguage_; 2201 if (source) { 2202 source->SetPlayStrategy(playStrategy); 2203 source->SetAppUid(appUid_); 2204 } 2205 } 2206 DoSetSource(const std::shared_ptr<MediaSource> source)2207 Status HiPlayerImpl::DoSetSource(const std::shared_ptr<MediaSource> source) 2208 { 2209 MediaTrace trace("HiPlayerImpl::DoSetSource"); 2210 ResetIfSourceExisted(); 2211 completeState_.clear(); 2212 demuxer_ = FilterFactory::Instance().CreateFilter<DemuxerFilter>("builtin.player.demuxer", 2213 FilterType::FILTERTYPE_DEMUXER); 2214 FALSE_RETURN_V(demuxer_ != nullptr, Status::ERROR_NULL_POINTER); 2215 demuxer_->SetInterruptState(isInterruptNeeded_); 2216 pipeline_->AddHeadFilters({demuxer_}); 2217 demuxer_->Init(playerEventReceiver_, playerFilterCallback_); 2218 DoSetPlayStrategy(source); 2219 if (!mimeType_.empty()) { 2220 source->SetMimeType(mimeType_); 2221 } 2222 if (surface_ == nullptr) { 2223 demuxer_->DisableMediaTrack(OHOS::Media::Plugins::MediaType::VIDEO); 2224 } 2225 demuxer_->SetIsEnableReselectVideoTrack(true); 2226 auto ret = demuxer_->SetDataSource(source); 2227 if (demuxer_ != nullptr) { 2228 demuxer_->SetCallerInfo(instanceId_, bundleName_); 2229 demuxer_->SetDumpFlag(isDump_); 2230 } 2231 if (ret == Status::OK && !MetaUtils::CheckFileType(demuxer_->GetGlobalMetaInfo())) { 2232 MEDIA_LOG_W("0x%{public}06 " PRIXPTR "SetSource unsupport", FAKE_POINTER(this)); 2233 ret = Status::ERROR_INVALID_DATA; 2234 } 2235 if (ret != Status::OK) { 2236 return ret; 2237 } 2238 std::unique_lock<std::mutex> lock(drmMutex_); 2239 isDrmProtected_ = demuxer_->IsDrmProtected(); 2240 MEDIA_LOG_I("Is the source drm-protected : %{public}d", isDrmProtected_); 2241 lock.unlock(); 2242 if (hasExtSub_) { 2243 demuxer_->SetSubtitleSource(std::make_shared<MediaSource>(subUrl_)); 2244 } 2245 SetBundleName(bundleName_); 2246 demuxer_->OptimizeDecodeSlow(IsEnableOptimizeDecode()); 2247 return ret; 2248 } 2249 Resume()2250 Status HiPlayerImpl::Resume() 2251 { 2252 MediaTrace trace("HiPlayerImpl::Resume"); 2253 MEDIA_LOG_I("Resume entered."); 2254 Status ret = Status::OK; 2255 syncManager_->Resume(); 2256 ret = pipeline_->Resume(); 2257 if (ret != Status::OK) { 2258 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 2259 } 2260 startTime_ = GetCurrentMillisecond(); 2261 return ret; 2262 } 2263 HandleIsLiveStreamEvent(bool isLiveStream)2264 void HiPlayerImpl::HandleIsLiveStreamEvent(bool isLiveStream) 2265 { 2266 Format format; 2267 callbackLooper_.OnInfo(INFO_TYPE_IS_LIVE_STREAM, isLiveStream, format); 2268 } 2269 HandleErrorEvent(int32_t errorCode)2270 void HiPlayerImpl::HandleErrorEvent(int32_t errorCode) 2271 { 2272 callbackLooper_.OnError(PLAYER_ERROR, errorCode); 2273 } 2274 NotifyBufferingStart(int32_t param)2275 void HiPlayerImpl::NotifyBufferingStart(int32_t param) 2276 { 2277 Format format; 2278 isBufferingStartNotified_.store(true); 2279 (void)format.PutIntValue(std::string(PlayerKeys::PLAYER_BUFFERING_START), 1); 2280 callbackLooper_.OnInfo(INFO_TYPE_BUFFERING_UPDATE, param, format); 2281 } 2282 NotifyBufferingEnd(int32_t param)2283 void HiPlayerImpl::NotifyBufferingEnd(int32_t param) 2284 { 2285 MEDIA_LOG_I("NotifyBufferingEnd"); 2286 Format format; 2287 isBufferingStartNotified_.store(false); 2288 (void)format.PutIntValue(std::string(PlayerKeys::PLAYER_BUFFERING_END), 1); 2289 callbackLooper_.OnInfo(INFO_TYPE_BUFFERING_UPDATE, param, format); 2290 } 2291 NotifyCachedDuration(int32_t param)2292 void HiPlayerImpl::NotifyCachedDuration(int32_t param) 2293 { 2294 MEDIA_LOG_D("NotifyCachedDuration"); 2295 Format format; 2296 (void)format.PutIntValue(std::string(PlayerKeys::PLAYER_CACHED_DURATION), param); 2297 callbackLooper_.OnInfo(INFO_TYPE_BUFFERING_UPDATE, param, format); 2298 } 2299 HandleEosFlagState(const Event & event)2300 void HiPlayerImpl::HandleEosFlagState(const Event& event) 2301 { 2302 for (std::pair<std::string, bool>& item: completeState_) { 2303 if (item.first == event.srcFilter) { 2304 MEDIA_LOG_I("one eos event received " PUBLIC_LOG_S, item.first.c_str()); 2305 item.second = true; 2306 } 2307 } 2308 } 2309 HandleCompleteEvent(const Event & event)2310 void HiPlayerImpl::HandleCompleteEvent(const Event& event) 2311 { 2312 MEDIA_LOG_D_SHORT("HandleCompleteEvent"); 2313 AutoLock lock(handleCompleteMutex_); 2314 if (curState_ == PlayerStateId::STOPPED) { 2315 MEDIA_LOG_I("The Complete Task don't run, current status is Stopped."); 2316 return; 2317 } 2318 HandleEosFlagState(event); 2319 for (auto item : completeState_) { 2320 if (item.second == false) { 2321 MEDIA_LOG_I("expect receive eos event " PUBLIC_LOG_S, item.first.c_str()); 2322 return; 2323 } 2324 } 2325 MEDIA_LOG_I("OnComplete looping: " PUBLIC_LOG_D32 ".", singleLoop_.load()); 2326 isStreaming_ = false; 2327 Format format; 2328 int32_t curPosMs = 0; 2329 GetCurrentTime(curPosMs); 2330 if ((GetPlayRangeEndTime() == PLAY_RANGE_DEFAULT_VALUE) && 2331 (durationMs_.load() > curPosMs && abs(durationMs_.load() - curPosMs) < AUDIO_SINK_MAX_LATENCY)) { 2332 MEDIA_LOG_I("OnComplete durationMs - curPosMs: " PUBLIC_LOG_D32, durationMs_.load() - curPosMs); 2333 } 2334 if (!singleLoop_.load()) { 2335 callbackLooper_.StopReportMediaProgress(); 2336 callbackLooper_.StopCollectMaxAmplitude(); 2337 } else { 2338 inEosSeek_ = true; 2339 } 2340 callbackLooper_.DoReportCompletedTime(); 2341 pipeline_->Pause(); 2342 if (isSetPlayRange_ && (startTimeWithMode_ == PLAY_RANGE_DEFAULT_VALUE || 2343 endTimeWithMode_ == PLAY_RANGE_DEFAULT_VALUE)) { 2344 startTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE; 2345 endTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE; 2346 pipeline_->SetPlayRange(startTimeWithMode_, endTimeWithMode_); 2347 } 2348 callbackLooper_.ReportRemainedMaxAmplitude(); 2349 if (!singleLoop_.load()) { 2350 OnStateChanged(PlayerStateId::EOS); 2351 } 2352 if (startTime_ != -1) { 2353 playTotalDuration_ += GetCurrentMillisecond() - startTime_; 2354 } 2355 startTime_ = -1; 2356 callbackLooper_.OnInfo(INFO_TYPE_EOS, static_cast<int32_t>(singleLoop_.load()), format); 2357 for (std::pair<std::string, bool>& item: completeState_) { 2358 item.second = false; 2359 } 2360 } 2361 HandleDrmInfoUpdatedEvent(const Event & event)2362 void HiPlayerImpl::HandleDrmInfoUpdatedEvent(const Event& event) 2363 { 2364 MEDIA_LOG_I("HandleDrmInfoUpdatedEvent"); 2365 2366 std::multimap<std::string, std::vector<uint8_t>> drmInfo = 2367 AnyCast<std::multimap<std::string, std::vector<uint8_t>>>(event.param); 2368 uint32_t infoCount = drmInfo.size(); 2369 if (infoCount > DrmConstant::DRM_MAX_DRM_INFO_COUNT || infoCount == 0) { 2370 MEDIA_LOG_E("HandleDrmInfoUpdatedEvent info count is invalid"); 2371 return; 2372 } 2373 DrmInfoItem *drmInfoArray = new DrmInfoItem[infoCount]; 2374 if (drmInfoArray == nullptr) { 2375 MEDIA_LOG_E("HandleDrmInfoUpdatedEvent new drm info failed"); 2376 return; 2377 } 2378 int32_t i = 0; 2379 for (auto item : drmInfo) { 2380 uint32_t step = 2; 2381 for (uint32_t j = 0; j < item.first.size(); j += step) { 2382 std::string byteString = item.first.substr(j, step); 2383 unsigned char byte = (unsigned char)strtol(byteString.c_str(), NULL, 16); 2384 drmInfoArray[i].uuid[j / step] = byte; 2385 } 2386 2387 errno_t ret = memcpy_s(drmInfoArray[i].pssh, sizeof(drmInfoArray[i].pssh), 2388 item.second.data(), item.second.size()); 2389 if (ret != EOK) { 2390 MEDIA_LOG_E("HandleDrmInfoUpdatedEvent memcpy drm info pssh failed"); 2391 delete []drmInfoArray; 2392 return; 2393 } 2394 drmInfoArray[i].psshLen = item.second.size(); 2395 i++; 2396 } 2397 2398 // report event 2399 Format format; 2400 size_t drmInfoSize = static_cast<size_t>(infoCount) * sizeof(DrmInfoItem); 2401 (void) format.PutBuffer(PlayerKeys::PLAYER_DRM_INFO_ADDR, 2402 reinterpret_cast<const uint8_t *>(drmInfoArray), drmInfoSize); 2403 (void) format.PutIntValue(PlayerKeys::PLAYER_DRM_INFO_COUNT, static_cast<int32_t>(infoCount)); 2404 callbackLooper_.OnInfo(INFO_TYPE_DRM_INFO_UPDATED, static_cast<int32_t>(singleLoop_.load()), format); 2405 2406 delete []drmInfoArray; 2407 } 2408 HandleResolutionChangeEvent(const Event & event)2409 void HiPlayerImpl::HandleResolutionChangeEvent(const Event& event) 2410 { 2411 #ifdef SUPPORT_VIDEO 2412 // update new video size 2413 std::pair<int32_t, int32_t> videoSize = AnyCast<std::pair<int32_t, int32_t>>(event.param); 2414 int32_t width = videoSize.first; 2415 int32_t height = videoSize.second; 2416 videoWidth_ = !needSwapWH_.load() ? width : height; 2417 videoHeight_ = !needSwapWH_.load() ? height : width; 2418 2419 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 2420 if (currentVideoTrackId_ >= 0 && currentVideoTrackId_ < static_cast<int32_t>(metaInfo.size())) { 2421 double videoSar; 2422 bool ret = metaInfo[currentVideoTrackId_]->GetData(Tag::VIDEO_SAR, videoSar); 2423 if (ret) { 2424 height = (videoSar > 1) ? static_cast<int32_t>(height / videoSar) : height; 2425 width = (videoSar < 1) ? static_cast<int32_t>(width * videoSar) : width; 2426 } 2427 } 2428 2429 MEDIA_LOG_I("HandleResolutionChangeEvent, width = %{public}d, height = %{public}d", 2430 videoWidth_.load(), videoHeight_.load()); 2431 // notify size change 2432 NotifyResolutionChange(); 2433 #endif 2434 } 2435 HandleBitrateStartEvent(const Event & event)2436 void HiPlayerImpl::HandleBitrateStartEvent(const Event& event) 2437 { 2438 #ifdef SUPPORT_VIDEO 2439 uint32_t bitrate = AnyCast<uint32_t>(event.param); 2440 MEDIA_LOG_I("HandleBitrateStartEvent in, bitrate is " PUBLIC_LOG_U32, bitrate); 2441 FALSE_RETURN(videoDecoder_ != nullptr); 2442 videoDecoder_->SetBitrateStart(); 2443 #endif 2444 } 2445 NotifySubtitleUpdate(const Event & event)2446 void HiPlayerImpl::NotifySubtitleUpdate(const Event& event) 2447 { 2448 Format format = AnyCast<Format>(event.param); 2449 if (needUpdateSubtitle_.load()) { 2450 callbackLooper_.OnInfo(INFO_TYPE_SUBTITLE_UPDATE_INFO, 0, format); 2451 } 2452 } 2453 UpdateStateNoLock(PlayerStates newState,bool notifyUpward,bool isSystemOperation)2454 void HiPlayerImpl::UpdateStateNoLock(PlayerStates newState, bool notifyUpward, bool isSystemOperation) 2455 { 2456 if (pipelineStates_ == newState) { 2457 return; 2458 } 2459 pipelineStates_ = newState; 2460 if (pipelineStates_ == PlayerStates::PLAYER_IDLE || pipelineStates_ == PlayerStates::PLAYER_PREPARING) { 2461 MEDIA_LOG_W("do not report idle and preparing since av player doesn't need report idle and preparing"); 2462 return; 2463 } 2464 if (notifyUpward) { 2465 if (callbackLooper_.IsStarted()) { 2466 Format format; 2467 if (isSystemOperation) { 2468 format.PutIntValue(PlayerKeys::PLAYER_STATE_CHANGED_REASON, StateChangeReason::BACKGROUND); 2469 } 2470 while (!pendingStates_.empty()) { 2471 auto pendingState = pendingStates_.front(); 2472 pendingStates_.pop(); 2473 MEDIA_LOG_I("sending pending state change: " PUBLIC_LOG_S, StringnessPlayerState(pendingState).c_str()); 2474 callbackLooper_.OnInfo(INFO_TYPE_STATE_CHANGE, pendingState, format); 2475 } 2476 MEDIA_LOG_I("sending newest state change: " PUBLIC_LOG_S, 2477 StringnessPlayerState(pipelineStates_.load()).c_str()); 2478 callbackLooper_.OnInfo(INFO_TYPE_STATE_CHANGE, pipelineStates_, format); 2479 } else { 2480 pendingStates_.push(newState); 2481 } 2482 } 2483 } 2484 NotifyBufferingUpdate(const std::string_view & type,int32_t param)2485 void HiPlayerImpl::NotifyBufferingUpdate(const std::string_view& type, int32_t param) 2486 { 2487 Format format; 2488 format.PutIntValue(std::string(type), param); 2489 MEDIA_LOG_D("NotifyBufferingUpdate param " PUBLIC_LOG_D32, param); 2490 callbackLooper_.OnInfo(INFO_TYPE_BUFFERING_UPDATE, durationMs_.load(), format); 2491 } 2492 NotifyDurationUpdate(const std::string_view & type,int32_t param)2493 void HiPlayerImpl::NotifyDurationUpdate(const std::string_view& type, int32_t param) 2494 { 2495 Format format; 2496 format.PutIntValue(std::string(type), param); 2497 MEDIA_LOG_I("NotifyDurationUpdate " PUBLIC_LOG_D64, durationMs_.load()); 2498 callbackLooper_.OnInfo(INFO_TYPE_DURATION_UPDATE, durationMs_.load(), format); 2499 } 2500 NotifySeekDone(int32_t seekPos)2501 void HiPlayerImpl::NotifySeekDone(int32_t seekPos) 2502 { 2503 MediaTrace trace(std::string("HiPlayerImpl::NotifySeekDone, seekPos: ") + to_string(seekPos)); 2504 Format format; 2505 // Report position firstly to make sure that client can get real position when seek done in playing state. 2506 if (curState_ == PlayerStateId::PLAYING) { 2507 std::unique_lock<std::mutex> lock(seekMutex_); 2508 syncManager_->seekCond_.wait_for( 2509 lock, 2510 std::chrono::milliseconds(PLAYING_SEEK_WAIT_TIME), 2511 [this]() { 2512 return !syncManager_->InSeeking(); 2513 }); 2514 } 2515 auto startTime = std::chrono::steady_clock::now(); 2516 demuxer_->WaitForBufferingEnd(); 2517 auto endTime = std::chrono::steady_clock::now(); 2518 auto waitTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count(); 2519 MEDIA_LOG_D_SHORT("NotifySeekDone WaitForBufferingEnd: %{public}d ms", int(waitTime)); 2520 if (isSeekClosest_.load()) { 2521 isSeekClosest_.store(false); 2522 if (isBufferingStartNotified_.load()) { 2523 MEDIA_LOG_I_SHORT("SEEK_CLOSEST BUFFERING_END PLAYING"); 2524 NotifyBufferingEnd(NOTIFY_BUFFERING_END_PARAM); 2525 } 2526 } 2527 2528 MEDIA_LOG_D_SHORT("NotifySeekDone seekPos: %{public}d", seekPos); 2529 callbackLooper_.OnInfo(INFO_TYPE_POSITION_UPDATE, seekPos, format); 2530 callbackLooper_.OnInfo(INFO_TYPE_SEEKDONE, seekPos, format); 2531 } 2532 NotifyAudioInterrupt(const Event & event)2533 void HiPlayerImpl::NotifyAudioInterrupt(const Event& event) 2534 { 2535 MEDIA_LOG_I("NotifyAudioInterrupt"); 2536 Format format; 2537 auto interruptEvent = AnyCast<AudioStandard::InterruptEvent>(event.param); 2538 int32_t hintType = interruptEvent.hintType; 2539 int32_t forceType = interruptEvent.forceType; 2540 int32_t eventType = interruptEvent.eventType; 2541 if (forceType == OHOS::AudioStandard::INTERRUPT_FORCE) { 2542 if (hintType == OHOS::AudioStandard::INTERRUPT_HINT_PAUSE 2543 || hintType == OHOS::AudioStandard::INTERRUPT_HINT_STOP) { 2544 Status ret = Status::OK; 2545 ret = pipeline_->Pause(); 2546 syncManager_->Pause(); 2547 if (audioSink_ != nullptr) { 2548 audioSink_->Pause(); 2549 } 2550 if (ret != Status::OK) { 2551 UpdateStateNoLock(PlayerStates::PLAYER_STATE_ERROR); 2552 } 2553 callbackLooper_.StopReportMediaProgress(); 2554 callbackLooper_.StopCollectMaxAmplitude(); 2555 } 2556 } 2557 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_TYPE, eventType); 2558 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_FORCE, forceType); 2559 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_HINT, hintType); 2560 callbackLooper_.OnInfo(INFO_TYPE_INTERRUPT_EVENT, hintType, format); 2561 if (forceType == OHOS::AudioStandard::INTERRUPT_FORCE) { 2562 if (hintType == OHOS::AudioStandard::INTERRUPT_HINT_PAUSE 2563 || hintType == OHOS::AudioStandard::INTERRUPT_HINT_STOP) { 2564 callbackLooper_.OnSystemOperation(OPERATION_TYPE_PAUSE, OPERATION_REASON_AUDIO_INTERRUPT); 2565 } 2566 } 2567 } 2568 NotifyAudioDeviceChange(const Event & event)2569 void HiPlayerImpl::NotifyAudioDeviceChange(const Event& event) 2570 { 2571 MEDIA_LOG_I("NotifyAudioDeviceChange"); 2572 auto [deviceInfo, reason] = AnyCast<std::pair<AudioStandard::DeviceInfo, 2573 AudioStandard::AudioStreamDeviceChangeReason>>(event.param); 2574 Format format; 2575 Parcel parcel; 2576 deviceInfo.Marshalling(parcel); 2577 auto parcelSize = parcel.GetReadableBytes(); 2578 (void)format.PutBuffer(PlayerKeys::AUDIO_DEVICE_CHANGE, 2579 parcel.ReadBuffer(parcelSize), parcelSize); 2580 format.PutIntValue(PlayerKeys::AUDIO_DEVICE_CHANGE_REASON, static_cast<int32_t>(reason)); 2581 callbackLooper_.OnInfo(INFO_TYPE_AUDIO_DEVICE_CHANGE, static_cast<int32_t>(reason), format); 2582 } 2583 NotifyAudioServiceDied()2584 void HiPlayerImpl::NotifyAudioServiceDied() 2585 { 2586 Format format; 2587 callbackLooper_.OnInfo(INFO_TYPE_ERROR_MSG, MSERR_EXT_API9_IO, format); 2588 } 2589 NotifyAudioFirstFrame(const Event & event)2590 void HiPlayerImpl::NotifyAudioFirstFrame(const Event& event) 2591 { 2592 uint64_t latency = AnyCast<uint64_t>(event.param); 2593 MEDIA_LOG_I("Audio first frame event in latency " PUBLIC_LOG_U64, latency); 2594 Format format; 2595 (void)format.PutLongValue(PlayerKeys::AUDIO_FIRST_FRAME, latency); 2596 callbackLooper_.OnInfo(INFO_TYPE_AUDIO_FIRST_FRAME, 0, format); 2597 } 2598 NotifyResolutionChange()2599 void HiPlayerImpl::NotifyResolutionChange() 2600 { 2601 #ifdef SUPPORT_VIDEO 2602 Format format; 2603 int32_t width = videoWidth_.load(); 2604 int32_t height = videoHeight_.load(); 2605 (void)format.PutIntValue(std::string(PlayerKeys::PLAYER_WIDTH), width); 2606 (void)format.PutIntValue(std::string(PlayerKeys::PLAYER_HEIGHT), height); 2607 MEDIA_LOG_I("video size change, width %{public}d, height %{public}d", width, height); 2608 callbackLooper_.OnInfo(INFO_TYPE_RESOLUTION_CHANGE, 0, format); 2609 #endif 2610 } 2611 NotifyPositionUpdate()2612 void HiPlayerImpl::NotifyPositionUpdate() 2613 { 2614 int32_t currentPosMs = 0; 2615 GetCurrentTime(currentPosMs); 2616 MEDIA_LOG_D("NotifyPositionUpdate currentPosMs: %{public}d", currentPosMs); 2617 Format format; 2618 callbackLooper_.OnInfo(INFO_TYPE_POSITION_UPDATE, currentPosMs, format); 2619 } 2620 NotifyUpdateTrackInfo()2621 void HiPlayerImpl::NotifyUpdateTrackInfo() 2622 { 2623 std::vector<Format> trackInfo; 2624 GetVideoTrackInfo(trackInfo); 2625 GetAudioTrackInfo(trackInfo); 2626 GetSubtitleTrackInfo(trackInfo); 2627 2628 Format body; 2629 body.PutFormatVector(std::string(PlayerKeys::PLAYER_TRACK_INFO), trackInfo); 2630 MEDIA_LOG_I("NotifyUpdateTrackInfo"); 2631 2632 callbackLooper_.OnInfo(INFO_TYPE_TRACK_INFO_UPDATE, 0, body); 2633 } 2634 HandleAudioTrackChangeEvent(const Event & event)2635 void HiPlayerImpl::HandleAudioTrackChangeEvent(const Event& event) 2636 { 2637 int32_t trackId = AnyCast<int32_t>(event.param); 2638 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 2639 std::string mime; 2640 FALSE_RETURN_MSG(trackId >= 0 && trackId < static_cast<int32_t>(metaInfo.size()), 2641 "HandleAudioTrackChangeEvent trackId invalid"); 2642 if (!(metaInfo[trackId]->GetData(Tag::MIME_TYPE, mime))) { 2643 MEDIA_LOG_E("HandleAudioTrackChangeEvent trackId " PUBLIC_LOG_D32 "get mime error", trackId); 2644 return; 2645 } 2646 if (IsAudioMime(mime)) { 2647 if (Status::OK != audioDecoder_->ChangePlugin(metaInfo[trackId])) { 2648 MEDIA_LOG_E("HandleAudioTrackChangeEvent audioDecoder change plugin error"); 2649 return; 2650 } 2651 if (Status::OK != audioSink_->ChangeTrack(metaInfo[trackId])) { 2652 MEDIA_LOG_E("HandleAudioTrackChangeEvent audioSink change track error"); 2653 return; 2654 } 2655 if (Status::OK != demuxer_->StartTask(trackId)) { 2656 MEDIA_LOG_E("HandleAudioTrackChangeEvent StartTask error. trackId is " PUBLIC_LOG_D32, trackId); 2657 return; 2658 } 2659 Format audioTrackInfo {}; 2660 audioTrackInfo.PutIntValue("track_index", static_cast<int32_t>(trackId)); 2661 audioTrackInfo.PutIntValue("track_is_select", 1); 2662 callbackLooper_.OnInfo(INFO_TYPE_TRACKCHANGE, 0, audioTrackInfo); 2663 currentAudioTrackId_ = trackId; 2664 2665 NotifyUpdateTrackInfo(); 2666 } 2667 return; 2668 } 2669 HandleVideoTrackChangeEvent(const Event & event)2670 void HiPlayerImpl::HandleVideoTrackChangeEvent(const Event& event) 2671 { 2672 #ifdef SUPPORT_VIDEO 2673 int32_t trackId = AnyCast<int32_t>(event.param); 2674 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 2675 std::string mime; 2676 FALSE_RETURN_MSG(trackId >= 0 && trackId < static_cast<int32_t>(metaInfo.size()), 2677 "HandleVideoTrackChangeEvent trackId invalid"); 2678 if (!(metaInfo[trackId]->GetData(Tag::MIME_TYPE, mime))) { 2679 MEDIA_LOG_E("HandleVideoTrackChangeEvent trackId " PUBLIC_LOG_D32 "get mime error", trackId); 2680 return; 2681 } 2682 if (IsVideoMime(mime)) { 2683 if (Status::OK != demuxer_->StartTask(trackId)) { 2684 MEDIA_LOG_E("HandleVideoTrackChangeEvent StartTask error. trackId is " PUBLIC_LOG_D32, trackId); 2685 return; 2686 } 2687 Format videoTrackInfo {}; 2688 videoTrackInfo.PutIntValue("track_index", static_cast<int32_t>(trackId)); 2689 videoTrackInfo.PutIntValue("track_is_select", 1); 2690 callbackLooper_.OnInfo(INFO_TYPE_TRACKCHANGE, 0, videoTrackInfo); 2691 currentVideoTrackId_ = trackId; 2692 } 2693 #endif 2694 return; 2695 } 2696 HandleSubtitleTrackChangeEvent(const Event & event)2697 void HiPlayerImpl::HandleSubtitleTrackChangeEvent(const Event& event) 2698 { 2699 int32_t trackId = AnyCast<int32_t>(event.param); 2700 std::vector<std::shared_ptr<Meta>> metaInfo = demuxer_->GetStreamMetaInfo(); 2701 std::string mime; 2702 FALSE_RETURN_MSG(trackId >= 0 && trackId < static_cast<int32_t>(metaInfo.size()), 2703 "HandleSubtitleTrackChangeEvent trackId invalid"); 2704 if (!(metaInfo[trackId]->GetData(Tag::MIME_TYPE, mime))) { 2705 MEDIA_LOG_E("HandleSubtitleTrackChangeEvent trackId " PUBLIC_LOG_D32 "get mime error", trackId); 2706 return; 2707 } 2708 if (IsSubtitleMime(mime)) { 2709 if (Status::OK != subtitleSink_->DoFlush()) { 2710 MEDIA_LOG_E("HandleSubtitleTrackChangeEvent DoFlush error"); 2711 return; 2712 } 2713 if (Status::OK != demuxer_->StartTask(trackId)) { 2714 MEDIA_LOG_E("HandleSubtitleTrackChangeEvent StartTask error. trackId is " PUBLIC_LOG_D32, trackId); 2715 return; 2716 } 2717 Format subtitleTrackInfo {}; 2718 subtitleTrackInfo.PutIntValue("track_index", static_cast<int32_t>(trackId)); 2719 subtitleTrackInfo.PutIntValue("track_is_select", 1); 2720 callbackLooper_.OnInfo(INFO_TYPE_TRACKCHANGE, 0, subtitleTrackInfo); 2721 currentSubtitleTrackId_ = trackId; 2722 needUpdateSubtitle_.store(true); 2723 } 2724 return; 2725 } 2726 OnStateChanged(PlayerStateId state,bool isSystemOperation)2727 void __attribute__((no_sanitize("cfi"))) HiPlayerImpl::OnStateChanged(PlayerStateId state, bool isSystemOperation) 2728 { 2729 { 2730 AutoLock lockEos(stateChangeMutex_); 2731 if (isDoCompletedSeek_.load()) { 2732 isDoCompletedSeek_ = false; 2733 } else if ((curState_ == PlayerStateId::EOS) && (state == PlayerStateId::PAUSE)) { 2734 MEDIA_LOG_E("already at completed and not allow pause"); 2735 return; 2736 } 2737 curState_ = state; 2738 } 2739 MEDIA_LOG_D("OnStateChanged " PUBLIC_LOG_D32 " > " PUBLIC_LOG_D32, pipelineStates_.load(), 2740 TransStateId2PlayerState(state)); 2741 UpdateStateNoLock(TransStateId2PlayerState(state), true, isSystemOperation); 2742 { 2743 AutoLock lock(stateMutex_); 2744 cond_.NotifyOne(); 2745 } 2746 } 2747 OnCallback(std::shared_ptr<Filter> filter,const FilterCallBackCommand cmd,StreamType outType)2748 Status HiPlayerImpl::OnCallback(std::shared_ptr<Filter> filter, const FilterCallBackCommand cmd, StreamType outType) 2749 { 2750 MEDIA_LOG_I("HiPlayerImpl::OnCallback filter, outType: %{public}d", outType); 2751 if (cmd == FilterCallBackCommand::NEXT_FILTER_NEEDED) { 2752 switch (outType) { 2753 case StreamType::STREAMTYPE_SUBTITLE: 2754 return LinkSubtitleSinkFilter(filter, outType); 2755 case StreamType::STREAMTYPE_RAW_AUDIO: 2756 return LinkAudioSinkFilter(filter, outType); 2757 case StreamType::STREAMTYPE_ENCODED_AUDIO: 2758 return LinkAudioDecoderFilter(filter, outType); 2759 #ifdef SUPPORT_VIDEO 2760 case StreamType::STREAMTYPE_RAW_VIDEO: 2761 break; 2762 case StreamType::STREAMTYPE_ENCODED_VIDEO: 2763 return LinkVideoDecoderFilter(filter, outType); 2764 #endif 2765 default: 2766 break; 2767 } 2768 } 2769 return Status::OK; 2770 } 2771 OnDumpInfo(int32_t fd)2772 void HiPlayerImpl::OnDumpInfo(int32_t fd) 2773 { 2774 MEDIA_LOG_D("HiPlayerImpl::OnDumpInfo called."); 2775 if (audioDecoder_ != nullptr) { 2776 audioDecoder_->OnDumpInfo(fd); 2777 } 2778 if (demuxer_ != nullptr) { 2779 demuxer_->OnDumpInfo(fd); 2780 } 2781 #ifdef SUPPORT_VIDEO 2782 if (videoDecoder_ != nullptr) { 2783 videoDecoder_->OnDumpInfo(fd); 2784 } 2785 #endif 2786 } 2787 LinkAudioDecoderFilter(const std::shared_ptr<Filter> & preFilter,StreamType type)2788 Status HiPlayerImpl::LinkAudioDecoderFilter(const std::shared_ptr<Filter>& preFilter, StreamType type) 2789 { 2790 MediaTrace trace("HiPlayerImpl::LinkAudioDecoderFilter"); 2791 MEDIA_LOG_I_SHORT("HiPlayerImpl::LinkAudioDecoderFilter"); 2792 FALSE_RETURN_V(audioDecoder_ == nullptr, Status::OK); 2793 2794 audioDecoder_ = FilterFactory::Instance().CreateFilter<AudioDecoderFilter>("player.audiodecoder", 2795 FilterType::FILTERTYPE_ADEC); 2796 FALSE_RETURN_V(audioDecoder_ != nullptr, Status::ERROR_NULL_POINTER); 2797 audioDecoder_->Init(playerEventReceiver_, playerFilterCallback_); 2798 2799 audioDecoder_->SetCallerInfo(instanceId_, bundleName_); 2800 audioDecoder_->SetDumpFlag(isDump_); 2801 // set decrypt config for drm audios 2802 if (isDrmProtected_) { 2803 MEDIA_LOG_D("HiPlayerImpl::LinkAudioDecoderFilter will SetDecryptConfig"); 2804 std::unique_lock<std::mutex> lock(drmMutex_); 2805 static constexpr int32_t timeout = 5; 2806 bool notTimeout = drmConfigCond_.wait_for(lock, std::chrono::seconds(timeout), [this]() { 2807 return this->isDrmPrepared_ || this->stopWaitingDrmConfig_; 2808 }); 2809 if (notTimeout && isDrmPrepared_) { 2810 MEDIA_LOG_I("LinkAudioDecoderFilter will SetDecryptConfig"); 2811 bool svpFlag = svpMode_ == HiplayerSvpMode::SVP_TRUE ? true : false; 2812 audioDecoder_->SetDecryptionConfig(keySessionServiceProxy_, svpFlag); 2813 } else { 2814 MEDIA_LOG_E("HiPlayerImpl Drmcond wait timeout or has been stopped! Play drm protected audio failed!"); 2815 return Status::ERROR_INVALID_OPERATION; 2816 } 2817 } else { 2818 MEDIA_LOG_D("HiPlayerImpl::LinkAudioDecoderFilter, and it's not drm-protected."); 2819 } 2820 return pipeline_->LinkFilters(preFilter, {audioDecoder_}, type); 2821 } 2822 LinkAudioSinkFilter(const std::shared_ptr<Filter> & preFilter,StreamType type)2823 Status HiPlayerImpl::LinkAudioSinkFilter(const std::shared_ptr<Filter>& preFilter, StreamType type) 2824 { 2825 MediaTrace trace("HiPlayerImpl::LinkAudioSinkFilter"); 2826 MEDIA_LOG_I("HiPlayerImpl::LinkAudioSinkFilter"); 2827 FALSE_RETURN_V(audioSink_ == nullptr, Status::OK); 2828 2829 audioSink_ = FilterFactory::Instance().CreateFilter<AudioSinkFilter>("player.audiosink", 2830 FilterType::FILTERTYPE_ASINK); 2831 FALSE_RETURN_V(audioSink_ != nullptr, Status::ERROR_NULL_POINTER); 2832 audioSink_->Init(playerEventReceiver_, playerFilterCallback_); 2833 audioSink_->SetMaxAmplitudeCbStatus(maxAmplitudeCbStatus_); 2834 if (demuxer_ != nullptr && audioRenderInfo_ == nullptr) { 2835 std::vector<std::shared_ptr<Meta>> trackInfos = demuxer_->GetStreamMetaInfo(); 2836 SetDefaultAudioRenderInfo(trackInfos); 2837 } 2838 if (audioRenderInfo_ != nullptr) { 2839 audioSink_->SetParameter(audioRenderInfo_); 2840 } 2841 if (audioInterruptMode_ != nullptr) { 2842 audioSink_->SetParameter(audioInterruptMode_); 2843 } 2844 std::shared_ptr<Meta> globalMeta = std::make_shared<Meta>(); 2845 if (demuxer_ != nullptr) { 2846 globalMeta = demuxer_->GetGlobalMetaInfo(); 2847 } 2848 if (globalMeta != nullptr) { 2849 globalMeta->SetData(Tag::APP_PID, appPid_); 2850 globalMeta->SetData(Tag::APP_UID, appUid_); 2851 if (audioRenderInfo_ != nullptr) { 2852 for (MapIt iter = audioRenderInfo_->begin(); iter != audioRenderInfo_->end(); iter++) { 2853 globalMeta->SetData(iter->first, iter->second); 2854 } 2855 } 2856 audioSink_->SetParameter(globalMeta); 2857 } 2858 audioSink_->SetSyncCenter(syncManager_); 2859 2860 completeState_.emplace_back(std::make_pair("AudioSink", false)); 2861 initialAVStates_.emplace_back(std::make_pair(EventType::EVENT_AUDIO_FIRST_FRAME, false)); 2862 auto res = pipeline_->LinkFilters(preFilter, {audioSink_}, type); 2863 if (mutedMediaType_ == OHOS::Media::MediaType::MEDIA_TYPE_AUD) { 2864 audioSink_->SetMuted(true); 2865 } 2866 return res; 2867 } 2868 2869 #ifdef SUPPORT_VIDEO LinkVideoDecoderFilter(const std::shared_ptr<Filter> & preFilter,StreamType type)2870 Status HiPlayerImpl::LinkVideoDecoderFilter(const std::shared_ptr<Filter>& preFilter, StreamType type) 2871 { 2872 MediaTrace trace("HiPlayerImpl::LinkVideoDecoderFilter"); 2873 MEDIA_LOG_I("LinkVideoDecoderFilter"); 2874 if (videoDecoder_ == nullptr) { 2875 videoDecoder_ = FilterFactory::Instance().CreateFilter<DecoderSurfaceFilter>("player.videodecoder", 2876 FilterType::FILTERTYPE_VDEC); 2877 FALSE_RETURN_V(videoDecoder_ != nullptr, Status::ERROR_NULL_POINTER); 2878 videoDecoder_->Init(playerEventReceiver_, playerFilterCallback_); 2879 videoDecoder_->SetSyncCenter(syncManager_); 2880 videoDecoder_->SetCallingInfo(appUid_, appPid_, bundleName_, instanceId_); 2881 if (surface_ != nullptr) { 2882 videoDecoder_->SetVideoSurface(surface_); 2883 } 2884 2885 // set decrypt config for drm videos 2886 if (isDrmProtected_) { 2887 std::unique_lock<std::mutex> lock(drmMutex_); 2888 static constexpr int32_t timeout = 5; 2889 bool notTimeout = drmConfigCond_.wait_for(lock, std::chrono::seconds(timeout), [this]() { 2890 return this->isDrmPrepared_ || this->stopWaitingDrmConfig_; 2891 }); 2892 if (notTimeout && isDrmPrepared_) { 2893 MEDIA_LOG_I("LinkVideoDecoderFilter will SetDecryptConfig"); 2894 bool svpFlag = svpMode_ == HiplayerSvpMode::SVP_TRUE ? true : false; 2895 videoDecoder_->SetDecryptConfig(keySessionServiceProxy_, svpFlag); 2896 } else { 2897 MEDIA_LOG_E("HiPlayerImpl Drmcond wait timeout or has been stopped! Play drm protected video failed!"); 2898 return Status::ERROR_INVALID_OPERATION; 2899 } 2900 } else { 2901 MEDIA_LOG_D("HiPlayerImpl::LinkVideoDecoderFilter, and it's not drm-protected."); 2902 } 2903 } 2904 completeState_.emplace_back(std::make_pair("VideoSink", false)); 2905 initialAVStates_.emplace_back(std::make_pair(EventType::EVENT_VIDEO_RENDERING_START, false)); 2906 return pipeline_->LinkFilters(preFilter, {videoDecoder_}, type); 2907 } 2908 #endif 2909 LinkSubtitleSinkFilter(const std::shared_ptr<Filter> & preFilter,StreamType type)2910 Status HiPlayerImpl::LinkSubtitleSinkFilter(const std::shared_ptr<Filter>& preFilter, StreamType type) 2911 { 2912 MediaTrace trace("HiPlayerImpl::LinkSubtitleSinkFilter"); 2913 FALSE_RETURN_V(subtitleSink_ == nullptr, Status::OK); 2914 subtitleSink_ = FilterFactory::Instance().CreateFilter<SubtitleSinkFilter>("player.subtitlesink", 2915 FilterType::FILTERTYPE_SSINK); 2916 FALSE_RETURN_V(subtitleSink_ != nullptr, Status::ERROR_NULL_POINTER); 2917 subtitleSink_->Init(playerEventReceiver_, playerFilterCallback_); 2918 std::shared_ptr<Meta> globalMeta = std::make_shared<Meta>(); 2919 if (demuxer_ != nullptr) { 2920 globalMeta = demuxer_->GetGlobalMetaInfo(); 2921 } 2922 if (globalMeta != nullptr) { 2923 subtitleSink_->SetParameter(globalMeta); 2924 } 2925 subtitleSink_->SetSyncCenter(syncManager_); 2926 return pipeline_->LinkFilters(preFilter, {subtitleSink_}, type); 2927 } 2928 SetMediaMuted(OHOS::Media::MediaType mediaType,bool isMuted)2929 int32_t HiPlayerImpl::SetMediaMuted(OHOS::Media::MediaType mediaType, bool isMuted) 2930 { 2931 MEDIA_LOG_D("SetMediaMuted %{public}d", static_cast<int32_t>(mediaType)); 2932 FALSE_RETURN_V(mediaType == OHOS::Media::MediaType::MEDIA_TYPE_AUD, MSERR_INVALID_VAL); 2933 FALSE_RETURN_V(audioSink_ != nullptr, MSERR_NO_MEMORY); 2934 auto res = audioSink_->SetMuted(isMuted); 2935 return res == Status::OK ? MSERR_OK : MSERR_INVALID_OPERATION; 2936 } 2937 SetPlaybackStrategy(AVPlayStrategy playbackStrategy)2938 int32_t HiPlayerImpl::SetPlaybackStrategy(AVPlayStrategy playbackStrategy) 2939 { 2940 mutedMediaType_ = playbackStrategy.mutedMediaType; 2941 preferedWidth_ = playbackStrategy.preferredWidth; 2942 preferedHeight_ = playbackStrategy.preferredHeight; 2943 bufferDuration_ = playbackStrategy.preferredBufferDuration; 2944 preferHDR_ = playbackStrategy.preferredHdr; 2945 return MSERR_OK; 2946 } 2947 SeekContinous(int32_t mSeconds,int64_t seekContinousBatchNo)2948 int32_t HiPlayerImpl::SeekContinous(int32_t mSeconds, int64_t seekContinousBatchNo) 2949 { 2950 std::lock_guard<std::mutex> lock(seekContinousMutex_); 2951 FALSE_RETURN_V(demuxer_ && videoDecoder_, TransStatus(Status::OK)); 2952 FALSE_RETURN_V(!isNetWorkPlay_, TransStatus(Status::OK)); 2953 FALSE_RETURN_V(seekContinousBatchNo_.load() <= seekContinousBatchNo, TransStatus(Status::OK)); 2954 lastSeekContinousPos_ = mSeconds; 2955 if (seekContinousBatchNo_.load() == seekContinousBatchNo) { 2956 FALSE_RETURN_V(draggingPlayerAgent_ != nullptr, TransStatus(Status::OK)); 2957 draggingPlayerAgent_->UpdateSeekPos(mSeconds); 2958 MEDIA_LOG_I("HiPlayerImpl::SeekContinous in " PUBLIC_LOG_D32, mSeconds); 2959 return TransStatus(Status::OK); 2960 } 2961 seekContinousBatchNo_.store(seekContinousBatchNo); 2962 auto res = StartSeekContinous(); 2963 FALSE_RETURN_V_MSG_E(res == Status::OK && draggingPlayerAgent_ != nullptr, TransStatus(res), 2964 "StartSeekContinous failed"); 2965 draggingPlayerAgent_->UpdateSeekPos(mSeconds); 2966 MEDIA_LOG_I("HiPlayerImpl::SeekContinous start " PUBLIC_LOG_D32, mSeconds); 2967 return TransStatus(Status::OK); 2968 } 2969 StartSeekContinous()2970 Status HiPlayerImpl::StartSeekContinous() 2971 { 2972 FALSE_RETURN_V(!draggingPlayerAgent_, Status::OK); 2973 FALSE_RETURN_V(demuxer_ && videoDecoder_, Status::OK); 2974 draggingPlayerAgent_ = DraggingPlayerAgent::Create(); 2975 FALSE_RETURN_V_MSG_E(draggingPlayerAgent_ != nullptr, Status::ERROR_INVALID_OPERATION, "failed to create agent"); 2976 bool demuxerEOS = demuxer_->HasEosTrack(); 2977 bool decoderEOS = false; 2978 for (std::pair<std::string, bool>& item: completeState_) { 2979 if (item.second) { 2980 decoderEOS = true; 2981 break; 2982 } 2983 } 2984 bool playerEOS = pipelineStates_ == PlayerStates::PLAYER_PLAYBACK_COMPLETE; 2985 if (demuxerEOS || decoderEOS || playerEOS) { 2986 MEDIA_LOG_I("flush first when eos"); 2987 pipeline_->Flush(); 2988 curState_ = PlayerStateId::PAUSE; 2989 pipelineStates_ = TransStateId2PlayerState(PlayerStateId::PAUSE); 2990 for (std::pair<std::string, bool>& item: completeState_) { 2991 item.second = false; 2992 } 2993 } 2994 Status res = draggingPlayerAgent_->Init(demuxer_, videoDecoder_, playerId_); 2995 if (res != Status::OK) { 2996 draggingPlayerAgent_ = nullptr; 2997 return res; 2998 } 2999 SetFrameRateForSeekPerformance(FRAME_RATE_FOR_SEEK_PERFORMANCE); 3000 // Drive the head node to start the video channel. 3001 res = demuxer_->ResumeDragging(); 3002 FALSE_LOG_MSG(res == Status::OK, "ResumeDragging failed"); 3003 return res; 3004 } 3005 ExitSeekContinous(bool align,int64_t seekContinousBatchNo)3006 int32_t HiPlayerImpl::ExitSeekContinous(bool align, int64_t seekContinousBatchNo) 3007 { 3008 std::lock_guard<std::mutex> lock(seekContinousMutex_); 3009 FALSE_RETURN_V(demuxer_ && videoDecoder_, TransStatus(Status::OK)); 3010 FALSE_RETURN_V(!isNetWorkPlay_, TransStatus(Status::OK)); 3011 seekContinousBatchNo_.store(seekContinousBatchNo); 3012 if (draggingPlayerAgent_ == nullptr) { 3013 if (align) { 3014 Seek(lastSeekContinousPos_, PlayerSeekMode::SEEK_CLOSEST, false); 3015 } 3016 return TransStatus(Status::OK); 3017 } 3018 draggingPlayerAgent_->Release(); 3019 draggingPlayerAgent_ = nullptr; 3020 SetFrameRateForSeekPerformance(FRAME_RATE_DEFAULT); 3021 int64_t seekTimeUs = 0; 3022 FALSE_RETURN_V_MSG_E(Plugins::Us2HstTime(lastSeekContinousPos_, seekTimeUs), 3023 TransStatus(Status::OK), "Invalid lastSeekContinousPos_: %{public}" PRId64, lastSeekContinousPos_); 3024 syncManager_->Seek(seekTimeUs, true); 3025 if (align) { 3026 seekAgent_ = std::make_shared<SeekAgent>(demuxer_); 3027 auto res = seekAgent_->AlignAudioPosition(lastSeekContinousPos_); 3028 FALSE_LOG_MSG(res == Status::OK, "AlignAudioPosition failed"); 3029 MEDIA_LOG_I_SHORT("seekAgent_ AlignAudioPosition end"); 3030 seekAgent_.reset(); 3031 } 3032 return TransStatus(Status::OK); 3033 } 3034 HandleDfxEvent(const DfxEvent & event)3035 void HiPlayerImpl::HandleDfxEvent(const DfxEvent &event) 3036 { 3037 FALSE_RETURN(dfxAgent_ != nullptr); 3038 dfxAgent_->OnDfxEvent(event); 3039 } 3040 SetMaxAmplitudeCbStatus(bool status)3041 int32_t HiPlayerImpl::SetMaxAmplitudeCbStatus(bool status) 3042 { 3043 maxAmplitudeCbStatus_ = status; 3044 if (audioSink_ != nullptr) { 3045 return audioSink_->SetMaxAmplitudeCbStatus(maxAmplitudeCbStatus_); 3046 } 3047 return MSERR_OK; 3048 } 3049 IsSeekContinuousSupported(bool & isSeekContinuousSupported)3050 int32_t HiPlayerImpl::IsSeekContinuousSupported(bool &isSeekContinuousSupported) 3051 { 3052 FALSE_RETURN_V_MSG_E(demuxer_ != nullptr && videoDecoder_ != nullptr, TransStatus(Status::ERROR_WRONG_STATE), 3053 "demuxer or decoder is null"); 3054 isSeekContinuousSupported = DraggingPlayerAgent::IsDraggingSupported(demuxer_, videoDecoder_); 3055 return TransStatus(Status::OK); 3056 } 3057 } // namespace Media 3058 } // namespace OHOS 3059