1 /*
2 * Copyright (C) 2021-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "player_server.h"
17 #include <map>
18 #include <unistd.h>
19 #include <unordered_set>
20 #include <cmath>
21 #include "media_log.h"
22 #include "media_errors.h"
23 #include "engine_factory_repo.h"
24 #include "player_server_state.h"
25 #include "media_dfx.h"
26 #include "media_utils.h"
27 #include "ipc_skeleton.h"
28 #include "media_permission.h"
29 #include "accesstoken_kit.h"
30 #include "av_common.h"
31 #include "parameter.h"
32 #include "parameters.h"
33 #include "qos.h"
34 #include "player_server_event_receiver.h"
35 #include "common/media_source.h"
36 #include "audio_info.h"
37 #include "osal/utils/steady_clock.h"
38 #include "common/event.h"
39
40 using namespace OHOS::QOS;
41
42 namespace {
43 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_PLAYER, "PlayerServer"};
44 constexpr int32_t MAX_SUBTITLE_TRACK_NUN = 8;
45 constexpr int32_t MEMORY_USAGE_VERSION_ISOLATION = 20;
46 static bool g_isFirstInit = true;
47 }
48
49 namespace OHOS {
50 namespace Media {
51 using namespace OHOS::HiviewDFX;
52 using namespace OHOS::Media::Plugins;
53 const std::string START_TAG = "PlayerCreate->Start";
54 const std::string STOP_TAG = "PlayerStop->Destroy";
55 static const std::unordered_map<int32_t, std::string> STATUS_TO_STATUS_DESCRIPTION_TABLE = {
56 {PLAYER_STATE_ERROR, "PLAYER_STATE_ERROR"},
57 {PLAYER_IDLE, "PLAYER_IDLE"},
58 {PLAYER_INITIALIZED, "PLAYER_INITIALIZED"},
59 {PLAYER_PREPARING, "PLAYER_PREPARING"},
60 {PLAYER_PREPARED, "PLAYER_PREPARED"},
61 {PLAYER_STARTED, "PLAYER_STARTED"},
62 {PLAYER_PAUSED, "PLAYER_PAUSED"},
63 {PLAYER_STOPPED, "PLAYER_STOPPED"},
64 {PLAYER_PLAYBACK_COMPLETE, "PLAYER_PLAYBACK_COMPLETE"},
65 };
Create()66 std::shared_ptr<IPlayerService> PlayerServer::Create()
67 {
68 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
69 CHECK_AND_RETURN_RET_LOG(server != nullptr, nullptr, "failed to new PlayerServer");
70 (void)server->Init();
71 return server;
72 }
73
PlayerServer()74 PlayerServer::PlayerServer()
75 {
76 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
77 instanceId_ = HiviewDFX::HiTraceChain::GetId().GetChainId();
78 }
79
~PlayerServer()80 PlayerServer::~PlayerServer()
81 {
82 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
83 }
84
Init()85 int32_t PlayerServer::Init()
86 {
87 MediaTrace trace("PlayerServer::Init");
88
89 idleState_ = std::make_shared<IdleState>(*this);
90 initializedState_ = std::make_shared<InitializedState>(*this);
91 preparingState_ = std::make_shared<PreparingState>(*this);
92 preparedState_ = std::make_shared<PreparedState>(*this);
93 playingState_ = std::make_shared<PlayingState>(*this);
94 pausedState_ = std::make_shared<PausedState>(*this);
95 stoppedState_ = std::make_shared<StoppedState>(*this);
96 playbackCompletedState_ = std::make_shared<PlaybackCompletedState>(*this);
97 appTokenId_ = IPCSkeleton::GetCallingTokenID();
98 appUid_ = IPCSkeleton::GetCallingUid();
99 appPid_ = IPCSkeleton::GetCallingPid();
100 appName_ = GetClientBundleName(appUid_);
101 uint64_t tokenId = IPCSkeleton::GetCallingFullTokenID();
102 isCalledBySystemApp_ = OHOS::Security::AccessToken::AccessTokenKit::IsSystemAppByFullTokenID(tokenId);
103 if (g_isFirstInit) {
104 MEDIA_LOGI("appUid: %{public}d, appPid: %{public}d, appName: %{public}s", appUid_, appPid_, appName_.c_str());
105 g_isFirstInit = false;
106 } else {
107 MEDIA_LOGD("appUid: %{public}d, appPid: %{public}d, appName: %{public}s", appUid_, appPid_, appName_.c_str());
108 }
109 apiVersion_ = GetApiInfo(appUid_, appName_);
110
111 PlayerServerStateMachine::Init(idleState_);
112 MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances create 0x%{public}06" PRIXPTR,
113 FAKE_POINTER(this), FAKE_POINTER(GetCurrState().get()));
114
115 std::string bootState = system::GetParameter("bootevent.boot.completed", "false");
116 isBootCompleted_.store(bootState == "true");
117 if (isBootCompleted_.load() && appUid_ != 0) {
118 int32_t userId = -1;
119 AccountSA::OsAccountManager::GetOsAccountLocalIdFromUid(appUid_, userId);
120 userId_.store(userId);
121 std::weak_ptr<PlayerServer> server = std::static_pointer_cast<PlayerServer>(shared_from_this());
122 commonEventReceiver_ = std::make_shared<PlayerServerCommonEventReceiver>(server);
123 }
124 MEDIA_LOGI("0x%{public}06" PRIXPTR "Dump Info: lastOpStatus: %{public}s, lastErrMsg: %{public}s, "
125 "speedMode: %{public}d, looping: %{public}s, effectMode: %{public}d, leftVolume: %{public}f, "
126 "rightVolume: %{public}f", FAKE_POINTER(this), lastOpStatus_?"true":"false",
127 lastErrMsg_.c_str(), config_.speedMode, config_.looping?"true":"false", config_.effectMode,
128 config_.leftVolume, config_.rightVolume);
129 return MSERR_OK;
130 }
131
SetPlayerProducer(const PlayerProducer producer)132 int32_t PlayerServer::SetPlayerProducer(const PlayerProducer producer)
133 {
134 std::lock_guard<std::mutex> lock(mutex_);
135 MediaTrace trace("PlayerServer::SetPlayerProducer " + std::to_string(producer));
136 playerProducer_ = producer;
137 return MSERR_OK;
138 }
139
SetSource(const std::string & url)140 int32_t PlayerServer::SetSource(const std::string &url)
141 {
142 std::lock_guard<std::mutex> lock(mutex_);
143 MediaTrace trace("PlayerServer::SetSource url");
144 CHECK_AND_RETURN_RET_LOG(!url.empty(), MSERR_INVALID_VAL, "url is empty");
145 MEDIA_LOGW("0x%{public}06" PRIXPTR " KPI-TRACE: PlayerServer SetSource in(url)", FAKE_POINTER(this));
146 if (url.find("http") != std::string::npos) {
147 int32_t permissionResult = MediaPermission::CheckNetWorkPermission(appUid_, appPid_, appTokenId_);
148 if (permissionResult != Security::AccessToken::PERMISSION_GRANTED) {
149 MEDIA_LOGE("user do not have the right to access INTERNET");
150 OnErrorMessage(MSERR_USER_NO_PERMISSION, "user do not have the right to access INTERNET");
151 FaultSourceEventWrite(appName_, instanceId_, "player_framework",
152 static_cast<int8_t>(SourceType::SOURCE_TYPE_URI), url, "user do not have the right to access INTERNET");
153 return MSERR_INVALID_OPERATION;
154 }
155 }
156 config_.url = url;
157 int32_t ret = InitPlayEngine(url);
158 if (ret != MSERR_OK) {
159 FaultSourceEventWrite(appName_, instanceId_, "player_framework",
160 static_cast<int8_t>(SourceType::SOURCE_TYPE_URI), url, "SetSource Failed!");
161 }
162 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed!");
163 return ret;
164 }
165
SetSource(const std::shared_ptr<IMediaDataSource> & dataSrc)166 int32_t PlayerServer::SetSource(const std::shared_ptr<IMediaDataSource> &dataSrc)
167 {
168 std::lock_guard<std::mutex> lock(mutex_);
169 MediaTrace trace("PlayerServer::SetSource dataSrc");
170 CHECK_AND_RETURN_RET_LOG(dataSrc != nullptr, MSERR_INVALID_VAL, "data source is nullptr");
171 MEDIA_LOGW("KPI-TRACE: PlayerServer SetSource in(dataSrc)");
172 dataSrc_ = dataSrc;
173 std::string url = "media data source";
174 config_.url = url;
175 int32_t ret = InitPlayEngine(url);
176 if (ret != MSERR_OK) {
177 FaultSourceEventWrite(appName_, instanceId_, "player_framework",
178 static_cast<int8_t>(SourceType::SOURCE_TYPE_STREAM), url, "SetSource Failed!");
179 }
180 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "InitPlayEngine Failed!");
181 int64_t size = 0;
182 (void)dataSrc_->GetSize(size);
183 if (size == -1) {
184 config_.looping = false;
185 config_.speedMode = SPEED_FORWARD_1_00_X;
186 isLiveStream_ = true;
187 }
188 return ret;
189 }
190
SetSource(int32_t fd,int64_t offset,int64_t size)191 int32_t PlayerServer::SetSource(int32_t fd, int64_t offset, int64_t size)
192 {
193 std::lock_guard<std::mutex> lock(mutex_);
194 MediaTrace trace("PlayerServer::SetSource fd");
195 MEDIA_LOGW("KPI-TRACE: PlayerServer SetSource in(fd), fd: %{public}d, offset: %{public}" PRId64
196 ", size: %{public}" PRId64, fd, offset, size);
197 int32_t ret;
198 if (uriHelper_ != nullptr) {
199 std::string uri = uriHelper_->FormattedUri();
200 MEDIA_LOGI("UriHelper already existed, uri: %{private}s", uri.c_str());
201 ret = InitPlayEngine(uri);
202 if (ret != MSERR_OK) {
203 FaultSourceEventWrite(appName_, instanceId_, "player_framework",
204 static_cast<int8_t>(SourceType::SOURCE_TYPE_FD), uri, "SetSource Failed!");
205 }
206 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed!");
207 } else {
208 MEDIA_LOGI("UriHelper is nullptr, create a new instance.");
209 auto uriHelper = std::make_unique<UriHelper>(fd, offset, size);
210 CHECK_AND_RETURN_RET_LOG(uriHelper->AccessCheck(UriHelper::URI_READ),
211 MSERR_INVALID_VAL, "Failed to read the fd");
212 ret = InitPlayEngine(uriHelper->FormattedUri());
213 if (ret != MSERR_OK) {
214 FaultSourceEventWrite(appName_, instanceId_, "player_framework",
215 static_cast<int8_t>(SourceType::SOURCE_TYPE_FD), uriHelper->FormattedUri(), "SetSource Failed!");
216 }
217 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed!");
218 uriHelper_ = std::move(uriHelper);
219 playerEngine_->SetPerfRecEnabled(
220 uriHelper_ != nullptr && uriHelper_->GetFdLocation() == FdLocation::LOCAL);
221 }
222 config_.url = "file descriptor source";
223
224 return ret;
225 }
226
InitPlayEngine(const std::string & url)227 int32_t PlayerServer::InitPlayEngine(const std::string &url)
228 {
229 MEDIA_LOGI("PlayEngine Init");
230 CHECK_AND_RETURN_RET_LOG(lastOpStatus_ == PLAYER_IDLE, MSERR_INVALID_OPERATION,
231 "current state is: %{public}s, not support SetSource", GetStatusDescription(lastOpStatus_).c_str());
232 int32_t ret = taskMgr_.Init();
233 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "task mgr init failed");
234 MEDIA_LOGI("current url is : %{private}s", url.c_str());
235 auto engineFactory = EngineFactoryRepo::Instance().GetEngineFactory(
236 IEngineFactory::Scene::SCENE_PLAYBACK, appUid_, url);
237 CHECK_AND_RETURN_RET_LOG(engineFactory != nullptr, MSERR_CREATE_PLAYER_ENGINE_FAILED,
238 "failed to get engine factory");
239 playerEngine_ = engineFactory->CreatePlayerEngine(appUid_, appPid_, appTokenId_);
240 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_CREATE_PLAYER_ENGINE_FAILED,
241 "failed to create player engine");
242 playerEngine_->SetInstancdId(instanceId_);
243 playerEngine_->SetApiVersion(apiVersion_.load());
244 playerEngine_->SetIsCalledBySystemApp(isCalledBySystemApp_);
245 MEDIA_LOGI("Setted InstanceId %{public}" PRIu64, instanceId_);
246 if (dataSrc_ != nullptr) {
247 ret = playerEngine_->SetSource(dataSrc_);
248 } else if (mediaSource_ != nullptr) {
249 ret = playerEngine_->SetMediaSource(mediaSource_, strategy_);
250 } else {
251 ret = playerEngine_->SetSource(url);
252 }
253 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed! ret=%{public}d", ret);
254 MEDIA_LOGI("player engine SetSource success");
255 std::shared_ptr<IPlayerEngineObs> obs = shared_from_this();
256 ret = playerEngine_->SetObs(obs);
257 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetObs Failed!");
258 ret = playerEngine_->SetMaxAmplitudeCbStatus(
259 playerProducer_ == PlayerProducer::NAPI ? maxAmplitudeCbStatus_ : true);
260 ret = playerEngine_->SetSeiMessageCbStatus(seiMessageCbStatus_, payloadTypes_);
261 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetMaxAmplitudeCbStatus Failed!");
262 ret = playerEngine_->EnableReportMediaProgress(
263 playerProducer_ == PlayerProducer::NAPI ? enableReportMediaProgress_ : true);
264 TRUE_LOG(ret != MSERR_OK, MEDIA_LOGW, "PlayerEngine enable report media progress failed, ret %{public}d", ret);
265 if (playerCb_ != nullptr) {
266 playerCb_->SetInterruptListenerFlag(
267 playerProducer_ == PlayerProducer::NAPI ? enableReportAudioInterrupt_ : true);
268 }
269 playerEngine_->ForceLoadVideo(isForceLoadVideo_);
270 lastOpStatus_ = PLAYER_INITIALIZED;
271 ChangeState(initializedState_);
272 Format format;
273 OnInfo(INFO_TYPE_STATE_CHANGE, PLAYER_INITIALIZED, format);
274 return MSERR_OK;
275 }
276
AddSubSource(const std::string & url)277 int32_t PlayerServer::AddSubSource(const std::string &url)
278 {
279 std::lock_guard<std::mutex> lock(mutex_);
280 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr!");
281
282 if (subtitleTrackNum_ >= MAX_SUBTITLE_TRACK_NUN) {
283 MEDIA_LOGE("Can not add sub source, subtitle track num is %{public}u, exceed the max num.", subtitleTrackNum_);
284 return MSERR_INVALID_OPERATION;
285 }
286
287 MEDIA_LOGD("PlayerServer AddSubSource in(url).");
288 MediaTrace::TraceBegin("PlayerServer::AddSubSource", FAKE_POINTER(this));
289 (void)playerEngine_->AddSubSource(url);
290
291 return MSERR_OK;
292 }
293
AddSubSource(int32_t fd,int64_t offset,int64_t size)294 int32_t PlayerServer::AddSubSource(int32_t fd, int64_t offset, int64_t size)
295 {
296 std::lock_guard<std::mutex> lock(mutex_);
297 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
298
299 if (subtitleTrackNum_ >= MAX_SUBTITLE_TRACK_NUN) {
300 MEDIA_LOGE("Can not add sub source, subtitle track num is %{public}u, exceed the max num", subtitleTrackNum_);
301 return MSERR_INVALID_OPERATION;
302 }
303
304 auto uriHelper = std::make_shared<UriHelper>(fd, offset, size);
305 CHECK_AND_RETURN_RET_LOG(uriHelper->AccessCheck(UriHelper::URI_READ), MSERR_INVALID_VAL, "Failed to read the fd");
306
307 MEDIA_LOGD("PlayerServer AddSubSource in(fd)");
308 MediaTrace::TraceBegin("PlayerServer::AddSubSource", FAKE_POINTER(this));
309 (void)playerEngine_->AddSubSource(uriHelper->FormattedUri());
310 subUriHelpers_.emplace_back(uriHelper);
311
312 return MSERR_OK;
313 }
314
SetStartFrameRateOptEnabled(bool enabled)315 int32_t PlayerServer::SetStartFrameRateOptEnabled(bool enabled)
316 {
317 std::lock_guard<std::mutex> lock(mutex_);
318 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
319 auto startFrameRateOptTask = std::make_shared<TaskHandler<int32_t>>([this, enabled]() {
320 MediaTrace trace("PlayerServer::SetStartFrameRateOptEnabled");
321 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, taskMgr_.MarkTaskDone("SetStartFrameRateOptEnabled done"),
322 "SetStartFrameRateOptEnabled failed, playerEngine is nullptr");
323 auto res = playerEngine_->SetStartFrameRateOptEnabled(enabled);
324 taskMgr_.MarkTaskDone("SetStartFrameRateOptEnabled done");
325 return res;
326 });
327 taskMgr_.LaunchTask(startFrameRateOptTask, PlayerServerTaskType::LIGHT_TASK, "SetStartFrameRateOptEnabled");
328 return MSERR_OK;
329 }
330
Prepare()331 int32_t PlayerServer::Prepare()
332 {
333 if (inReleasing_.load()) {
334 MEDIA_LOGE("Can not Prepare, now in releasing");
335 return MSERR_INVALID_OPERATION;
336 }
337 std::lock_guard<std::mutex> lock(mutex_);
338 MEDIA_LOGD("KPI-TRACE: PlayerServer Prepare in");
339
340 if (lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STOPPED) {
341 return OnPrepare(false);
342 }
343 MEDIA_LOGE("Can not Prepare, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
344 return MSERR_INVALID_OPERATION;
345 }
346
SetRenderFirstFrame(bool display)347 int32_t PlayerServer::SetRenderFirstFrame(bool display)
348 {
349 std::lock_guard<std::mutex> lock(mutex_);
350 if (lastOpStatus_ != PLAYER_INITIALIZED) {
351 MEDIA_LOGE("Can not SetRenderFirstFrame, currentState is not PLAYER_INITIALIZED");
352 return MSERR_INVALID_OPERATION;
353 }
354 MEDIA_LOGD("PlayerServer SetRenderFirstFrame in, display %{public}d", display);
355
356 if (isLiveStream_) {
357 MEDIA_LOGE("Can not SetRenderFirstFrame, it is live-stream");
358 return MSERR_OK;
359 }
360
361 if (playerEngine_ != nullptr) {
362 int32_t ret = playerEngine_->SetRenderFirstFrame(display);
363 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetRenderFirstFrame Failed!");
364 }
365 return MSERR_OK;
366 }
367
SetPlayRange(int64_t start,int64_t end)368 int32_t PlayerServer::SetPlayRange(int64_t start, int64_t end)
369 {
370 std::lock_guard<std::mutex> lock(mutex_);
371 if (lastOpStatus_ != PLAYER_INITIALIZED
372 && lastOpStatus_ != PLAYER_PAUSED
373 && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
374 MEDIA_LOGE("Can not SetPlayRange, currentState is %{public}s",
375 GetStatusDescription(lastOpStatus_).c_str());
376 return MSERR_INVALID_OPERATION;
377 }
378
379 if (isLiveStream_) {
380 MEDIA_LOGE("Can not SetPlayRange, it is live-stream");
381 return MSERR_OK;
382 }
383
384 if (playerEngine_ != nullptr) {
385 int32_t ret = playerEngine_->SetPlayRange(start, end);
386 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetPlayRange Failed!");
387 }
388 return MSERR_OK;
389 }
390
SetPlayRangeWithMode(int64_t start,int64_t end,PlayerSeekMode mode)391 int32_t PlayerServer::SetPlayRangeWithMode(int64_t start, int64_t end, PlayerSeekMode mode)
392 {
393 std::lock_guard<std::mutex> lock(mutex_);
394 if (lastOpStatus_ != PLAYER_INITIALIZED
395 && lastOpStatus_ != PLAYER_PREPARED
396 && lastOpStatus_ != PLAYER_PAUSED
397 && lastOpStatus_ != PLAYER_STOPPED
398 && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
399 MEDIA_LOGE("Can not SetPlayRangeWithMode, currentState is %{public}s",
400 GetStatusDescription(lastOpStatus_).c_str());
401 return MSERR_INVALID_OPERATION;
402 }
403 if (isLiveStream_) {
404 MEDIA_LOGE("Can not SetPlayRangeWithMode, it is live-stream");
405 return MSERR_INVALID_OPERATION;
406 }
407 auto setPlayRangeTask = std::make_shared<TaskHandler<void>>([this, start, end, mode]() {
408 MediaTrace::TraceBegin("PlayerServer::SetPlayRange", FAKE_POINTER(this));
409 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
410 (void)currState->SetPlayRangeWithMode(start, end, mode);
411 });
412 int ret = taskMgr_.LaunchTask(setPlayRangeTask, PlayerServerTaskType::STATE_CHANGE, "set playRange");
413 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPlayRangeWithMode failed");
414 return MSERR_OK;
415 }
416
HandleSetPlayRange(int64_t start,int64_t end,PlayerSeekMode mode)417 int32_t PlayerServer::HandleSetPlayRange(int64_t start, int64_t end, PlayerSeekMode mode)
418 {
419 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSetPlayRange in");
420 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
421 int32_t ret = playerEngine_->SetPlayRangeWithMode(start, end, mode);
422 taskMgr_.MarkTaskDone("HandleSetPlayRange done");
423 MediaTrace::TraceEnd("PlayerServer::SetPlayRange", FAKE_POINTER(this));
424 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine SetPlayRangeWithMode Failed!");
425 return MSERR_OK;
426 }
427
PrepareAsync()428 int32_t PlayerServer::PrepareAsync()
429 {
430 if (inReleasing_.load()) {
431 MEDIA_LOGE("Can not Prepare, now in releasing");
432 return MSERR_INVALID_OPERATION;
433 }
434 std::lock_guard<std::mutex> lock(mutex_);
435 MEDIA_LOGD("KPI-TRACE: PlayerServer PrepareAsync in");
436
437 if (lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STOPPED) {
438 return OnPrepare(false);
439 }
440 MEDIA_LOGE("Can not Prepare, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
441 return MSERR_INVALID_OPERATION;
442 }
443
OnPrepare(bool sync)444 int32_t PlayerServer::OnPrepare(bool sync)
445 {
446 MEDIA_LOGD("KPI-TRACE: PlayerServer OnPrepare in");
447 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
448
449 int32_t ret = MSERR_OK;
450 lastOpStatus_ = PLAYER_PREPARED;
451 isInterruptNeeded_ = false;
452 playerEngine_->SetInterruptState(false);
453 auto preparedTask = std::make_shared<TaskHandler<int32_t>>([this]() {
454 MediaTrace::TraceBegin("PlayerServer::PrepareAsync", FAKE_POINTER(this));
455 #ifdef SUPPORT_VIDEO
456 {
457 std::lock_guard<std::mutex> lock(surfaceMutex_);
458 if (surface_ != nullptr) {
459 int32_t res = playerEngine_->SetVideoSurface(surface_);
460 CHECK_AND_RETURN_RET_LOG(res == MSERR_OK,
461 static_cast<int32_t>(MSERR_INVALID_OPERATION), "Engine SetVideoSurface Failed!");
462 }
463 }
464 #endif
465 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
466 return currState->Prepare();
467 });
468
469 ret = taskMgr_.LaunchTask(preparedTask, PlayerServerTaskType::STATE_CHANGE, "prepare");
470 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Prepare launch task failed");
471
472 if (sync) {
473 (void)preparedTask->GetResult(); // wait HandlePrpare
474 }
475 MEDIA_LOGD("KPI-TRACE: PlayerServer OnPrepare out");
476 return MSERR_OK;
477 }
478
HandlePrepare()479 int32_t PlayerServer::HandlePrepare()
480 {
481 MEDIA_LOGI("KPI-TRACE: PlayerServer HandlePrepare in");
482 int32_t ret = playerEngine_->PrepareAsync();
483 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Server Prepare Failed!");
484 CHECK_AND_RETURN_RET_LOG(!isInterruptNeeded_, MSERR_OK, "Cancel prepare");
485
486 if (config_.leftVolume < 1.0f) {
487 (void)playerEngine_->SetVolume(config_.leftVolume, config_.rightVolume);
488 }
489 if (config_.looping) {
490 (void)playerEngine_->SetLooping(config_.looping);
491 }
492 if (config_.speedMode != SPEED_FORWARD_1_00_X) {
493 MediaTrace::TraceBegin("PlayerServer::SetPlaybackSpeed", FAKE_POINTER(this));
494 auto rateTask = std::make_shared<TaskHandler<void>>([this]() {
495 int ret = playerEngine_->SetPlaybackSpeed(config_.speedMode);
496 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "Engine SetPlaybackSpeed Failed!");
497 });
498 auto cancelTask = std::make_shared<TaskHandler<void>>([this]() {
499 MEDIA_LOGI("Interrupted speed action");
500 taskMgr_.MarkTaskDone("interrupted speed done");
501 });
502
503 (void)taskMgr_.SpeedTask(rateTask, cancelTask, "prepare-speed", config_.speedMode);
504 }
505
506 if (config_.effectMode != OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT) {
507 MediaTrace::TraceBegin("PlayerServer::SetAudioEffectMode", FAKE_POINTER(this));
508 auto effectTask = std::make_shared<TaskHandler<void>>([this]() {
509 int ret = playerEngine_->SetAudioEffectMode(config_.effectMode);
510 taskMgr_.MarkTaskDone("SetAudioEffectMode done");
511 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "Engine SetAudioEffectMode Failed!");
512 });
513 (void)taskMgr_.LaunchTask(effectTask, PlayerServerTaskType::STATE_CHANGE, "SetAudioEffectMode", nullptr);
514 }
515
516 return MSERR_OK;
517 }
518
Play()519 int32_t PlayerServer::Play()
520 {
521 std::lock_guard<std::mutex> lock(mutex_);
522 MEDIA_LOGD("PlayerServer Play in");
523 if (lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE ||
524 lastOpStatus_ == PLAYER_PAUSED) {
525 return OnPlay();
526 }
527 if (lastOpStatus_ == PLAYER_STARTED && isInSeekContinous_.load()) {
528 return ExitSeekContinousAsync(true);
529 }
530 MEDIA_LOGE("Can not Play, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
531 return MSERR_INVALID_OPERATION;
532 }
533
OnPlay()534 int32_t PlayerServer::OnPlay()
535 {
536 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
537 if (lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE && dataSrc_ != nullptr) {
538 int64_t size = 0;
539 (void)dataSrc_->GetSize(size);
540 if (size == -1) {
541 MEDIA_LOGE("Can not play in complete status, it is live-stream");
542 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not play in complete status, it is live-stream");
543 return MSERR_INVALID_OPERATION;
544 }
545 }
546
547 auto playingTask = std::make_shared<TaskHandler<void>>([this]() {
548 MediaTrace::TraceBegin("PlayerServer::Play", FAKE_POINTER(this));
549 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
550 (void)currState->Play();
551 });
552 MEDIA_LOGD("PlayerServer OnPlay in");
553 int ret = taskMgr_.LaunchTask(playingTask, PlayerServerTaskType::STATE_CHANGE, "play");
554 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Play failed");
555
556 lastOpStatus_ = PLAYER_STARTED;
557 return MSERR_OK;
558 }
559
HandlePlay()560 int32_t PlayerServer::HandlePlay()
561 {
562 ExitSeekContinous(true);
563 TryFlvLiveRestartLink();
564 int32_t ret = playerEngine_->Play();
565 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Play Failed!");
566
567 return MSERR_OK;
568 }
569
BackGroundChangeState(PlayerStates state,bool isBackGroundCb)570 int32_t PlayerServer::BackGroundChangeState(PlayerStates state, bool isBackGroundCb)
571 {
572 backgroundState_ = state;
573 MEDIA_LOGI("PlayerServer::BackGroundChangeState is called");
574 isBackgroundCb_ = isBackGroundCb;
575 if (state == PLAYER_PAUSED) {
576 isBackgroundChanged_ = true;
577 return PlayerServer::Pause();
578 }
579 if (state == PLAYER_STARTED) {
580 isBackgroundChanged_ = true;
581 return PlayerServer::Play();
582 }
583 return MSERR_INVALID_OPERATION;
584 }
585
Pause()586 int32_t PlayerServer::Pause()
587 {
588 std::lock_guard<std::mutex> lock(mutex_);
589 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer Pause in", FAKE_POINTER(this));
590 if (lastOpStatus_ == PLAYER_PAUSED) {
591 MEDIA_LOGE("Can not Pause, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
592 return MSERR_OK;
593 }
594 if (lastOpStatus_ != PLAYER_STARTED) {
595 MEDIA_LOGE("Can not Pause, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
596 return MSERR_INVALID_OPERATION;
597 }
598 return OnPause(false);
599 }
600
OnPause(bool isSystemOperation)601 int32_t PlayerServer::OnPause(bool isSystemOperation)
602 {
603 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
604 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnPause in", FAKE_POINTER(this));
605
606 auto pauseTask = std::make_shared<TaskHandler<void>>([this, isSystemOperation]() {
607 MediaTrace::TraceBegin("PlayerServer::Pause", FAKE_POINTER(this));
608 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
609 (void)currState->Pause(isSystemOperation);
610 });
611
612 int ret = taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::STATE_CHANGE, "pause");
613 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Pause failed");
614
615 lastOpStatus_ = PLAYER_PAUSED;
616 return MSERR_OK;
617 }
618
HandlePause(bool isSystemOperation)619 int32_t PlayerServer::HandlePause(bool isSystemOperation)
620 {
621 MEDIA_LOGI("KPI-TRACE: PlayerServer HandlePause in");
622 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
623 ExitSeekContinous(true);
624 int32_t ret = playerEngine_->Pause(isSystemOperation);
625 UpdateFlvLivePauseTime();
626 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Pause Failed!");
627
628 return MSERR_OK;
629 }
630
Freeze()631 int32_t PlayerServer::Freeze()
632 {
633 std::lock_guard<std::mutex> lock(mutex_);
634 if (lastOpStatus_ != PLAYER_STARTED) {
635 MEDIA_LOGE("Can not Freeze, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
636 return MSERR_OK;
637 }
638 if (playerCb_ != nullptr) {
639 playerCb_->SetFreezeFlag(true);
640 }
641 auto ret = OnFreeze();
642 isFrozen_ = ret == MSERR_OK;
643 return ret;
644 }
645
OnFreeze()646 int32_t PlayerServer::OnFreeze()
647 {
648 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
649 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnFreeze in", FAKE_POINTER(this));
650 auto freezeTask = std::make_shared<TaskHandler<void>>([this]() {
651 MediaTrace Trace("PlayerServer::Freeze");
652 MEDIA_LOGI("PlayerServer::OnFreeze start");
653 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
654 (void)currState->Freeze();
655 MEDIA_LOGI("PlayerServer::OnFreeze end");
656 });
657
658 auto cancelTask = std::make_shared<TaskHandler<void>>([this]() {
659 MEDIA_LOGI("cancel OnFreeze");
660 taskMgr_.MarkTaskDone("interrupted OnFreeze done");
661 });
662
663 int ret = taskMgr_.FreezeTask(freezeTask, cancelTask, "Freeze");
664 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Freeze failed");
665
666 return MSERR_OK;
667 }
668
HandleFreeze()669 int32_t PlayerServer::HandleFreeze()
670 {
671 MEDIA_LOGI("PlayerServer HandleFreeze in");
672 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
673 ExitSeekContinous(true);
674 bool isNoNeedToFreeze = false;
675 int32_t ret = playerEngine_->Freeze(isNoNeedToFreeze);
676 UpdateFlvLivePauseTime();
677 if (ret != MSERR_OK) {
678 MEDIA_LOGI("Engine Freeze Failed!");
679 taskMgr_.MarkTaskDone("Freeze done");
680 return MSERR_INVALID_OPERATION;
681 }
682 if (isNoNeedToFreeze) {
683 CHECK_AND_RETURN_RET_NOLOG(playerCb_ != nullptr, MSERR_OK);
684 playerCb_->SetFreezeFlag(false);
685 taskMgr_.MarkTaskDone("Freeze done");
686 return MSERR_OK;
687 }
688 ret = HandleLiteFreeze();
689 MEDIA_LOGI("HandleLiteFreeze ret is %{public}d", ret);
690 taskMgr_.MarkTaskDone("Freeze done");
691 return ret;
692 }
693
HandleLiteFreeze()694 int32_t PlayerServer::HandleLiteFreeze()
695 {
696 CHECK_AND_RETURN_RET_NOLOG(!isMemoryExchanged_, MSERR_OK);
697 auto ret = playerEngine_->NotifyMemoryExchange(true);
698 isMemoryExchanged_ = true;
699 return ret;
700 }
701
UnFreeze()702 int32_t PlayerServer::UnFreeze()
703 {
704 std::lock_guard<std::mutex> lock(mutex_);
705 if (playerCb_ != nullptr) {
706 playerCb_->SetFreezeFlag(false);
707 }
708 if (!isFrozen_) {
709 MEDIA_LOGE("Can not UnFreeze, is not FrozenState");
710 return MSERR_OK;
711 }
712 auto ret = OnUnFreeze();
713 isFrozen_ = ret != MSERR_OK;
714 return ret;
715 }
716
OnUnFreeze()717 int32_t PlayerServer::OnUnFreeze()
718 {
719 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
720 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnUnFreeze in", FAKE_POINTER(this));
721 auto unFreezeTask = std::make_shared<TaskHandler<void>>([this]() {
722 MediaTrace Trace("PlayerServer::UnFreeze");
723 MEDIA_LOGI("PlayerServer::OnUnFreeze start");
724 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
725 (void)currState->UnFreeze();
726 MEDIA_LOGI("PlayerServer::OnUnFreeze end");
727 });
728
729 auto cancelTask = std::make_shared<TaskHandler<void>>([this]() {
730 MEDIA_LOGI("cancel OnUnFreeze");
731 taskMgr_.MarkTaskDone("cancel OnUnFreeze done");
732 });
733
734 int ret = taskMgr_.UnFreezeTask(unFreezeTask, cancelTask, "UnFreeze");
735 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "UnFreeze failed");
736
737 return MSERR_OK;
738 }
739
HandleUnFreeze()740 int32_t PlayerServer::HandleUnFreeze()
741 {
742 MEDIA_LOGI("PlayerServer HandleUnFreeze in");
743 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
744 (void)HandleLiteUnFreeze();
745 ExitSeekContinous(true);
746 playerEngine_->ResumeSourceDownload();
747 if (playerEngine_->IsFlvLive()) {
748 HandleFlvLiveRestartLink();
749 }
750 int32_t ret = playerEngine_->UnFreeze();
751 taskMgr_.MarkTaskDone("UnFreeze done");
752 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine UnFreeze Failed!");
753
754 return MSERR_OK;
755 }
756
HandleLiteUnFreeze()757 int32_t PlayerServer::HandleLiteUnFreeze()
758 {
759 CHECK_AND_RETURN_RET_NOLOG(isMemoryExchanged_, MSERR_OK);
760 auto ret = playerEngine_->NotifyMemoryExchange(false);
761 isMemoryExchanged_ = false;
762 return ret;
763 }
764
HandlePauseDemuxer()765 int32_t PlayerServer::HandlePauseDemuxer()
766 {
767 MEDIA_LOGI("KPI-TRACE: PlayerServer HandlePauseDemuxer in");
768 MediaTrace::TraceBegin("PlayerServer::HandlePauseDemuxer", FAKE_POINTER(this));
769 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
770 int32_t ret = playerEngine_->PauseDemuxer();
771 taskMgr_.MarkTaskDone("PauseDemuxer done");
772 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine PauseDemuxer Failed!");
773 return MSERR_OK;
774 }
775
HandleResumeDemuxer()776 int32_t PlayerServer::HandleResumeDemuxer()
777 {
778 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleResumeDemuxer in");
779 MediaTrace::TraceBegin("PlayerServer::HandleResumeDemuxer", FAKE_POINTER(this));
780 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
781 TryFlvLiveRestartLink();
782 int32_t ret = playerEngine_->ResumeDemuxer();
783 taskMgr_.MarkTaskDone("ResumeDemuxer done");
784 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine ResumeDemuxer Failed!");
785 return MSERR_OK;
786 }
787
Stop()788 int32_t PlayerServer::Stop()
789 {
790 std::lock_guard<std::mutex> lock(mutex_);
791
792 if (lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
793 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE || lastOpStatus_ == PLAYER_PAUSED) {
794 MediaTrace::TraceBegin("PlayerServer::Stop", FAKE_POINTER(this));
795 disableStoppedCb_ = false;
796 return OnStop(false);
797 }
798 MEDIA_LOGE("Can not Stop, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
799 return MSERR_INVALID_OPERATION;
800 }
801
OnStop(bool sync)802 int32_t PlayerServer::OnStop(bool sync)
803 {
804 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
805 isInterruptNeeded_ = true;
806 playerEngine_->SetInterruptState(true);
807 taskMgr_.ClearAllTask();
808 auto stopTask = std::make_shared<TaskHandler<void>>([this]() {
809 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
810 (void)currState->Stop();
811 });
812
813 (void)taskMgr_.LaunchTask(stopTask, PlayerServerTaskType::STATE_CHANGE, "stop");
814 if (sync) {
815 (void)stopTask->GetResult(); // wait HandleStop
816 }
817 lastOpStatus_ = PLAYER_STOPPED;
818 MEDIA_LOGD("PlayerServer OnStop out");
819 return MSERR_OK;
820 }
821
HandleStop()822 int32_t PlayerServer::HandleStop()
823 {
824 ExitSeekContinous(false);
825 int32_t ret = playerEngine_->Stop();
826 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Stop Failed!");
827
828 return MSERR_OK;
829 }
830
Reset()831 int32_t PlayerServer::Reset()
832 {
833 std::lock_guard<std::mutex> lock(mutex_);
834 MediaTrace trace("PlayerServer::Reset");
835 if (lastOpStatus_ == PLAYER_IDLE) {
836 MEDIA_LOGE("Can not Reset, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
837 return MSERR_INVALID_OPERATION;
838 }
839 return OnReset();
840 }
841
OnReset()842 int32_t PlayerServer::OnReset()
843 {
844 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
845 disableStoppedCb_ = true;
846 if (lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
847 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE || lastOpStatus_ == PLAYER_PAUSED) {
848 (void)OnStop(true);
849 } else if (lastOpStatus_ == PLAYER_STATE_ERROR && playerEngine_ != nullptr) {
850 isInterruptNeeded_ = true;
851 MEDIA_LOGW("error state interrupt");
852 playerEngine_->SetInterruptState(true);
853 }
854
855 MEDIA_LOGD("PlayerServer OnReset in");
856 taskMgr_.ClearAllTask();
857 auto idleTask = std::make_shared<TaskHandler<void>>([this]() {
858 ChangeState(idleState_);
859 });
860 (void)taskMgr_.LaunchTask(idleTask, PlayerServerTaskType::STATE_CHANGE, "reset");
861 (void)idleTask->GetResult();
862 (void)taskMgr_.Reset();
863 lastOpStatus_ = PLAYER_IDLE;
864 isLiveStream_ = false;
865 subtitleTrackNum_ = 0;
866 isStreamUsagePauseRequired_ = true;
867
868 return MSERR_OK;
869 }
870
HandleReset()871 int32_t PlayerServer::HandleReset()
872 {
873 (void)playerEngine_->Reset();
874 std::thread([playerEngine = std::move(playerEngine_), uriHelper = std::move(uriHelper_)]() mutable -> void {
875 MEDIA_LOGI("HandleReset: create new thread");
876 std::unique_ptr<UriHelper> helper = std::move(uriHelper);
877 std::unique_ptr<IPlayerEngine> engine = std::move(playerEngine);
878 MEDIA_LOGI("HandleReset: thread finished");
879 }).detach();
880 dataSrc_ = nullptr;
881 config_.looping = false;
882 uriHelper_ = nullptr;
883 mediaSource_ = nullptr;
884 {
885 decltype(subUriHelpers_) temp;
886 temp.swap(subUriHelpers_);
887 }
888 lastErrMsg_.clear();
889 errorCbOnce_ = false;
890 disableNextSeekDone_ = false;
891 totalMemoryUage_ = 0;
892 Format format;
893 OnInfo(INFO_TYPE_STATE_CHANGE, PLAYER_IDLE, format);
894 return MSERR_OK;
895 }
896
Release()897 int32_t PlayerServer::Release()
898 {
899 std::lock_guard<std::mutex> lock(mutex_);
900 MediaTrace trace("PlayerServer::Release");
901 inReleasing_ = true;
902 {
903 std::lock_guard<std::mutex> lockCb(mutexCb_);
904 playerCb_ = nullptr;
905 }
906 MEDIA_LOGD("PlayerServer Release in");
907 if (lastOpStatus_ != PLAYER_IDLE) {
908 (void)OnReset();
909 }
910 #ifdef SUPPORT_VIDEO
911 if (surface_ != nullptr) {
912 surface_ = nullptr;
913 }
914 #endif
915 return MSERR_OK;
916 }
917
SetVolumeMode(int32_t mode)918 int32_t PlayerServer::SetVolumeMode(int32_t mode)
919 {
920 std::lock_guard<std::mutex> lock(mutex_);
921 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
922 MEDIA_LOGE("Can not SetVolume, currentState is PLAYER_STATE_ERROR");
923 return MSERR_INVALID_OPERATION;
924 }
925 MEDIA_LOGD("PlayerServer SetVolumeMode in mode %{public}d", mode);
926 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
927 (void)playerEngine_->SetVolumeMode(mode);
928 return MSERR_OK;
929 }
930
SetVolume(float leftVolume,float rightVolume)931 int32_t PlayerServer::SetVolume(float leftVolume, float rightVolume)
932 {
933 {
934 std::lock_guard<std::mutex> lock(mutex_);
935 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
936 MEDIA_LOGE("Can not SetVolume, currentState is PLAYER_STATE_ERROR");
937 return MSERR_INVALID_OPERATION;
938 }
939 MEDIA_LOGD("PlayerServer SetVolume in leftVolume %{public}f %{public}f", leftVolume, rightVolume);
940 constexpr float maxVolume = 1.0f;
941 if ((leftVolume < 0) || (leftVolume > maxVolume) || (rightVolume < 0) || (rightVolume > maxVolume)) {
942 MEDIA_LOGE("SetVolume failed, the volume should be set to a value ranging from 0 to 5");
943 return MSERR_INVALID_OPERATION;
944 }
945
946 config_.leftVolume = leftVolume;
947 config_.rightVolume = rightVolume;
948 if (IsEngineStarted()) {
949 auto task = std::make_shared<TaskHandler<void>>([this]() {
950 (void)playerEngine_->SetVolume(config_.leftVolume, config_.rightVolume);
951 taskMgr_.MarkTaskDone("volume done");
952 });
953 (void)taskMgr_.LaunchTask(task, PlayerServerTaskType::STATE_CHANGE, "volume");
954 } else {
955 MEDIA_LOGI("Waiting for the engine state is <prepared> to take effect");
956 }
957 }
958
959 Format format;
960 (void)format.PutFloatValue(PlayerKeys::PLAYER_VOLUME_LEVEL, leftVolume);
961 MEDIA_LOGI("SetVolume callback");
962 OnInfoNoChangeStatus(INFO_TYPE_VOLUME_CHANGE, 0, format);
963 return MSERR_OK;
964 }
965
IsEngineStarted()966 bool PlayerServer::IsEngineStarted()
967 {
968 if (playerEngine_ != nullptr) {
969 if (GetCurrState() == preparedState_ || GetCurrState() == playingState_ ||
970 GetCurrState() == pausedState_ || GetCurrState() == playbackCompletedState_) {
971 return true;
972 }
973 }
974 return false;
975 }
976
IsValidSeekMode(PlayerSeekMode mode)977 bool PlayerServer::IsValidSeekMode(PlayerSeekMode mode)
978 {
979 switch (mode) {
980 case SEEK_PREVIOUS_SYNC:
981 case SEEK_NEXT_SYNC:
982 case SEEK_CLOSEST_SYNC:
983 case SEEK_CLOSEST:
984 case SEEK_CONTINOUS:
985 break;
986 default:
987 MEDIA_LOGE("Unknown seek mode %{public}d", mode);
988 return false;
989 }
990 return true;
991 }
992
Seek(int32_t mSeconds,PlayerSeekMode mode)993 int32_t PlayerServer::Seek(int32_t mSeconds, PlayerSeekMode mode)
994 {
995 std::lock_guard<std::mutex> lock(mutex_);
996 int32_t checkRet = CheckSeek(mSeconds, mode);
997 CHECK_AND_RETURN_RET_LOG(checkRet == MSERR_OK, checkRet, "check seek faild");
998
999 MEDIA_LOGD("seek position %{public}d, seek mode is %{public}d", mSeconds, mode);
1000 if (mode == SEEK_CONTINOUS) {
1001 return SeekContinous(mSeconds);
1002 }
1003 mSeconds = std::max(0, mSeconds);
1004 auto seekTask = std::make_shared<TaskHandler<void>>([this, mSeconds, mode]() {
1005 MediaTrace::TraceBegin("PlayerServer::Seek", FAKE_POINTER(this));
1006 MEDIA_LOGI("PlayerServer::Seek start");
1007 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1008 (void)currState->Seek(mSeconds, mode);
1009 MEDIA_LOGI("PlayerServer::Seek end");
1010 });
1011
1012 auto cancelTask = std::make_shared<TaskHandler<void>>([this, mSeconds]() {
1013 MEDIA_LOGI("Interrupted seek action");
1014 Format format;
1015 OnInfoNoChangeStatus(INFO_TYPE_SEEKDONE, mSeconds, format);
1016 taskMgr_.MarkTaskDone("interrupted seek done");
1017 });
1018
1019 int32_t ret = taskMgr_.SeekTask(seekTask, cancelTask, "seek", mode, mSeconds);
1020 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Seek failed");
1021
1022 MEDIA_LOGI("Queue seekTask end, position %{public}d, seek mode is %{public}d", mSeconds, mode);
1023 return MSERR_OK;
1024 }
1025
HandleSeek(int32_t mSeconds,PlayerSeekMode mode)1026 int32_t PlayerServer::HandleSeek(int32_t mSeconds, PlayerSeekMode mode)
1027 {
1028 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d, mSeconds: %{public}d, "
1029 "instanceId: %{public}" PRIu64 "", mSeconds, mode, instanceId_);
1030 ExitSeekContinous(false);
1031 int32_t ret = playerEngine_->Seek(mSeconds, mode);
1032 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Seek Failed!");
1033 MEDIA_LOGI("PlayerServer HandleSeek end");
1034 return MSERR_OK;
1035 }
1036
GetCurrentTime(int32_t & currentTime)1037 int32_t PlayerServer::GetCurrentTime(int32_t ¤tTime)
1038 {
1039 // delete lock, cannot be called concurrently with Reset or Release
1040 currentTime = -1;
1041 if (lastOpStatus_ == PLAYER_IDLE || lastOpStatus_ == PLAYER_STATE_ERROR) {
1042 MEDIA_LOGE("Can not GetCurrentTime, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1043 return MSERR_INVALID_OPERATION;
1044 }
1045 if (isLiveStream_ && dataSrc_ == nullptr) {
1046 MEDIA_LOGD("It is live-stream");
1047 return MSERR_OK;
1048 }
1049
1050 MEDIA_LOGD("PlayerServer GetCurrentTime in, currentState is %{public}s",
1051 GetStatusDescription(lastOpStatus_).c_str());
1052 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PAUSED &&
1053 lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1054 currentTime = 0;
1055 MEDIA_LOGD("get position at state: %{public}s, return 0", GetStatusDescription(lastOpStatus_).c_str());
1056 return MSERR_OK;
1057 }
1058
1059 if (playerEngine_ != nullptr) {
1060 int32_t ret = playerEngine_->GetCurrentTime(currentTime);
1061 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetCurrentTime Failed!");
1062 }
1063 return MSERR_OK;
1064 }
1065
GetPlaybackPosition(int32_t & playbackPosition)1066 int32_t PlayerServer::GetPlaybackPosition(int32_t &playbackPosition)
1067 {
1068 // delete lock, cannot be called concurrently with Reset or Release
1069 if (lastOpStatus_ == PLAYER_IDLE || lastOpStatus_ == PLAYER_STATE_ERROR) {
1070 MEDIA_LOGE("Can not GetPlaybackPosition, currentState is %{public}s",
1071 GetStatusDescription(lastOpStatus_).c_str());
1072 return MSERR_INVALID_OPERATION;
1073 }
1074
1075 MEDIA_LOGD("PlayerServer GetPlaybackPosition in, currentState is %{public}s",
1076 GetStatusDescription(lastOpStatus_).c_str());
1077 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PAUSED &&
1078 lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1079 playbackPosition = 0;
1080 MEDIA_LOGD("get position at state: %{public}s, return 0", GetStatusDescription(lastOpStatus_).c_str());
1081 return MSERR_OK;
1082 }
1083
1084 if (playerEngine_ != nullptr) {
1085 int32_t ret = playerEngine_->GetPlaybackPosition(playbackPosition);
1086 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetPlaybackPosition Failed!");
1087 }
1088 return MSERR_OK;
1089 }
1090
GetVideoTrackInfo(std::vector<Format> & videoTrack)1091 int32_t PlayerServer::GetVideoTrackInfo(std::vector<Format> &videoTrack)
1092 {
1093 std::lock_guard<std::mutex> lock(mutex_);
1094 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1095
1096 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
1097 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1098 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1099 return MSERR_INVALID_OPERATION;
1100 }
1101 MEDIA_LOGD("PlayerServer GetVideoTrackInfo in");
1102 int32_t ret = playerEngine_->GetVideoTrackInfo(videoTrack);
1103 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetVideoTrackInfo Failed!");
1104 return MSERR_OK;
1105 }
1106
GetPlaybackInfo(Format & playbackInfo)1107 int32_t PlayerServer::GetPlaybackInfo(Format &playbackInfo)
1108 {
1109 std::lock_guard<std::mutex> lock(mutex_);
1110 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1111
1112 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
1113 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1114 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1115 return MSERR_INVALID_OPERATION;
1116 }
1117 MEDIA_LOGD("PlayerServer GetPlaybackInfo in");
1118 int32_t ret = playerEngine_->GetPlaybackInfo(playbackInfo);
1119 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetPlaybackInfo Failed!");
1120 return MSERR_OK;
1121 }
1122
GetAudioTrackInfo(std::vector<Format> & audioTrack)1123 int32_t PlayerServer::GetAudioTrackInfo(std::vector<Format> &audioTrack)
1124 {
1125 std::lock_guard<std::mutex> lock(mutex_);
1126 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1127
1128 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
1129 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1130 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1131 return MSERR_INVALID_OPERATION;
1132 }
1133 MEDIA_LOGD("PlayerServer GetAudioTrackInfo in");
1134 int32_t ret = playerEngine_->GetAudioTrackInfo(audioTrack);
1135 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetAudioTrackInfo Failed!");
1136 return MSERR_OK;
1137 }
1138
GetSubtitleTrackInfo(std::vector<Format> & subtitleTrack)1139 int32_t PlayerServer::GetSubtitleTrackInfo(std::vector<Format> &subtitleTrack)
1140 {
1141 std::lock_guard<std::mutex> lock(mutex_);
1142 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1143
1144 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
1145 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1146 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1147 return MSERR_INVALID_OPERATION;
1148 }
1149 MEDIA_LOGD("PlayerServer GetSubtitleTrackInfo in");
1150 int32_t ret = playerEngine_->GetSubtitleTrackInfo(subtitleTrack);
1151 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetSubtitleTrackInfo Failed!");
1152 return MSERR_OK;
1153 }
1154
GetVideoWidth()1155 int32_t PlayerServer::GetVideoWidth()
1156 {
1157 std::lock_guard<std::mutex> lock(mutex_);
1158 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1159
1160 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
1161 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_STOPPED &&
1162 lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1163 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1164 return MSERR_INVALID_OPERATION;
1165 }
1166 MEDIA_LOGD("PlayerServer GetVideoWidth in");
1167 return playerEngine_->GetVideoWidth();
1168 }
1169
GetVideoHeight()1170 int32_t PlayerServer::GetVideoHeight()
1171 {
1172 std::lock_guard<std::mutex> lock(mutex_);
1173 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1174
1175 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
1176 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_STOPPED &&
1177 lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1178 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1179 return MSERR_INVALID_OPERATION;
1180 }
1181 MEDIA_LOGD("PlayerServer GetVideoHeight in");
1182 return playerEngine_->GetVideoHeight();
1183 }
1184
GetDuration(int32_t & duration)1185 int32_t PlayerServer::GetDuration(int32_t &duration)
1186 {
1187 // delete lock, cannot be called concurrently with Reset or Release
1188 if (lastOpStatus_ == PLAYER_IDLE || lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STATE_ERROR) {
1189 MEDIA_LOGE("Can not GetDuration, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1190 return MSERR_INVALID_OPERATION;
1191 }
1192
1193 MEDIA_LOGD("PlayerServer GetDuration in");
1194 duration = -1;
1195 if (playerEngine_ != nullptr) {
1196 int ret = playerEngine_->GetDuration(duration);
1197 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetDuration Failed!");
1198 }
1199 MEDIA_LOGD("PlayerServer GetDuration %{public}d", duration);
1200 return MSERR_OK;
1201 }
1202
GetApiVersion(int32_t & apiVersion)1203 int32_t PlayerServer::GetApiVersion(int32_t &apiVersion)
1204 {
1205 apiVersion = apiVersion_.load();
1206 MEDIA_LOGD("PlayerServer GetApiVersion %{public}d", apiVersion);
1207 return MSERR_OK;
1208 }
1209
ClearConfigInfo()1210 void PlayerServer::ClearConfigInfo()
1211 {
1212 std::lock_guard<std::mutex> lock(mutex_);
1213
1214 config_.looping = false;
1215 config_.leftVolume = INVALID_VALUE;
1216 config_.rightVolume = INVALID_VALUE;
1217 config_.speedMode = SPEED_FORWARD_1_00_X;
1218 config_.url = "";
1219 }
1220
SetPlaybackSpeed(PlaybackRateMode mode)1221 int32_t PlayerServer::SetPlaybackSpeed(PlaybackRateMode mode)
1222 {
1223 std::lock_guard<std::mutex> lock(mutex_);
1224
1225 if ((lastOpStatus_ != PLAYER_STARTED) && (lastOpStatus_ != PLAYER_PREPARED) &&
1226 (lastOpStatus_ != PLAYER_PAUSED) && (lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE)) {
1227 MEDIA_LOGE("Can not SetPlaybackSpeed, currentState is %{public}s",
1228 GetStatusDescription(lastOpStatus_).c_str());
1229 return MSERR_INVALID_OPERATION;
1230 }
1231 MEDIA_LOGD("PlayerServer SetPlaybackSpeed in, mode %{public}d", mode);
1232 if (isLiveStream_) {
1233 MEDIA_LOGE("Can not SetPlaybackSpeed, it is live-stream");
1234 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not SetPlaybackSpeed, it is live-stream");
1235 return MSERR_INVALID_OPERATION;
1236 }
1237
1238 auto rateTask = std::make_shared<TaskHandler<void>>([this, mode]() {
1239 MediaTrace::TraceBegin("PlayerServer::SetPlaybackSpeed", FAKE_POINTER(this));
1240 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1241 (void)currState->SetPlaybackSpeed(mode);
1242 });
1243
1244 auto cancelTask = std::make_shared<TaskHandler<void>>([this, mode]() {
1245 MEDIA_LOGI("Interrupted speed action");
1246 Format format;
1247 OnInfoNoChangeStatus(INFO_TYPE_SPEEDDONE, mode, format);
1248 taskMgr_.MarkTaskDone("interrupted speed done");
1249 });
1250
1251 int ret = taskMgr_.SpeedTask(rateTask, cancelTask, "speed", config_.speedMode);
1252 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPlaybackSpeed failed");
1253
1254 return MSERR_OK;
1255 }
1256
SetPlaybackRate(float rate)1257 int32_t PlayerServer::SetPlaybackRate(float rate)
1258 {
1259 std::lock_guard<std::mutex> lock(mutex_);
1260
1261 if ((lastOpStatus_ != PLAYER_STARTED) && (lastOpStatus_ != PLAYER_PREPARED) &&
1262 (lastOpStatus_ != PLAYER_PAUSED) && (lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE)) {
1263 MEDIA_LOGE("Can not SetPlaybackRate, currentState is %{public}s",
1264 GetStatusDescription(lastOpStatus_).c_str());
1265 return MSERR_INVALID_OPERATION;
1266 }
1267 MEDIA_LOGD("PlayerServer SetPlaybackRate in, rate %{public}f", rate);
1268 if (isLiveStream_) {
1269 MEDIA_LOGE("Can not SetPlaybackRate, it is live-stream");
1270 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not SetPlaybackRate, it is live-stream");
1271 return MSERR_INVALID_OPERATION;
1272 }
1273
1274 auto rateTask = std::make_shared<TaskHandler<void>>([this, rate]() {
1275 MediaTrace::TraceBegin("PlayerServer::SetPlaybackRate", FAKE_POINTER(this));
1276 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1277 (void)currState->SetPlaybackRate(rate);
1278 });
1279
1280 auto cancelTask = std::make_shared<TaskHandler<void>>([this, rate]() {
1281 MEDIA_LOGI("Interrupted rate action");
1282 Format format;
1283 OnInfoNoChangeStatus(INFO_TYPE_RATEDONE, rate, format);
1284 taskMgr_.MarkTaskDone("interrupted rate done");
1285 });
1286
1287 int32_t ret = taskMgr_.SpeedTask(rateTask, cancelTask, "rate", config_.speedRate);
1288 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPlaybackRate failed");
1289
1290 return MSERR_OK;
1291 }
1292
HandleSetPlaybackSpeed(PlaybackRateMode mode)1293 int32_t PlayerServer::HandleSetPlaybackSpeed(PlaybackRateMode mode)
1294 {
1295 if (config_.speedMode == mode) {
1296 MEDIA_LOGD("The speed mode is same, mode = %{public}d", mode);
1297 Format format;
1298 OnInfoNoChangeStatus(INFO_TYPE_SPEEDDONE, mode, format);
1299 taskMgr_.MarkTaskDone("set speed mode is same");
1300 MediaTrace::TraceEnd("PlayerServer::SetPlaybackSpeed", FAKE_POINTER(this));
1301 return MSERR_OK;
1302 }
1303
1304 if (playerEngine_ != nullptr) {
1305 int ret = playerEngine_->SetPlaybackSpeed(mode);
1306 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine SetPlaybackSpeed Failed!");
1307 }
1308 config_.speedMode = mode;
1309 return MSERR_OK;
1310 }
1311
HandleSetPlaybackRate(float rate)1312 int32_t PlayerServer::HandleSetPlaybackRate(float rate)
1313 {
1314 constexpr float EPSILON = 1e-6;
1315 if (std::fabs(config_.speedRate - rate) < EPSILON) {
1316 MEDIA_LOGD("The speed rate is same, rate = %{public}f", rate);
1317 Format format;
1318 (void)format.PutFloatValue(PlayerKeys::PLAYER_PLAYBACK_RATE, rate);
1319 OnInfoNoChangeStatus(INFO_TYPE_RATEDONE, rate, format);
1320 taskMgr_.MarkTaskDone("set speed rate is same");
1321 MediaTrace::TraceEnd("PlayerServer::SetPlaybackRate", FAKE_POINTER(this));
1322 return MSERR_OK;
1323 }
1324
1325 if (playerEngine_ != nullptr) {
1326 int32_t ret = playerEngine_->SetPlaybackRate(rate);
1327 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine SetPlaybackRate Failed!");
1328 }
1329 config_.speedRate = rate;
1330 return MSERR_OK;
1331 }
1332
SetMediaSource(const std::shared_ptr<AVMediaSource> & mediaSource,AVPlayStrategy strategy)1333 int32_t PlayerServer::SetMediaSource(const std::shared_ptr<AVMediaSource> &mediaSource, AVPlayStrategy strategy)
1334 {
1335 std::lock_guard<std::mutex> lock(mutex_);
1336 MediaTrace trace("PlayerServer::SetMediaSource");
1337 CHECK_AND_RETURN_RET_LOG(mediaSource != nullptr, MSERR_INVALID_VAL, "mediaSource is nullptr");
1338
1339 mediaSource_ = mediaSource;
1340 strategy_ = strategy;
1341
1342 std::string uri = mediaSource_->url;
1343 std::string mimeType = mediaSource_->GetMimeType();
1344 size_t pos1 = uri.find("?");
1345 size_t pos2 = uri.find("offset=");
1346 size_t pos3 = uri.find("&");
1347 if (mimeType == AVMimeType::APPLICATION_M3U8 && pos1 != std::string::npos && pos2 != std::string::npos &&
1348 pos3 != std::string::npos) {
1349 CHECK_AND_RETURN_RET_LOG(strlen("fd://") < pos1, MSERR_INVALID_VAL, "Failed to read fd.");
1350 CHECK_AND_RETURN_RET_LOG(pos2 + strlen("offset=") < pos3, MSERR_INVALID_VAL, "Failed to read fd.");
1351 std::string fdStr = uri.substr(strlen("fd://"), pos1 - strlen("fd://"));
1352 std::string offsetStr = uri.substr(pos2 + strlen("offset="), pos3 - pos2 - strlen("offset="));
1353 std::string sizeStr = uri.substr(pos3 + sizeof("&size"));
1354 int32_t fd = -1;
1355 int32_t offset = -1;
1356 int32_t size = -1;
1357 CHECK_AND_RETURN_RET_LOG(StrToInt(fdStr, fd), MSERR_INVALID_VAL, "Failed to read fd.");
1358 CHECK_AND_RETURN_RET_LOG(StrToInt(offsetStr, offset), MSERR_INVALID_VAL, "Failed to read offset.");
1359 CHECK_AND_RETURN_RET_LOG(StrToInt(sizeStr, size), MSERR_INVALID_VAL, "Failed to read size.");
1360
1361 auto uriHelper = std::make_unique<UriHelper>(fd, offset, size);
1362 CHECK_AND_RETURN_RET_LOG(uriHelper->AccessCheck(UriHelper::URI_READ), MSERR_INVALID_VAL, "Failed ro read fd.");
1363 uriHelper_ = std::move(uriHelper);
1364 mediaSource_->url = uriHelper_->FormattedUri();
1365 }
1366
1367 int32_t ret = InitPlayEngine(mediaSource->url);
1368 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetMediaSource Failed!");
1369
1370 config_.url = mediaSource_->url;
1371 config_.header = mediaSource_->header;
1372 config_.strategy_ = strategy;
1373
1374 return MSERR_OK;
1375 }
1376
HandleEos()1377 void PlayerServer::HandleEos()
1378 {
1379 if (config_.looping.load()) {
1380 auto seekTask = std::make_shared<TaskHandler<void>>([this]() {
1381 MediaTrace::TraceBegin("PlayerServer::Seek", FAKE_POINTER(this));
1382 disableNextSeekDone_ = true;
1383 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1384 if (playerEngine_ != nullptr) {
1385 int64_t startTime = playerEngine_->GetPlayRangeStartTime();
1386 int64_t endTime = playerEngine_->GetPlayRangeEndTime();
1387 PlayerSeekMode seekMode = static_cast<PlayerSeekMode>(playerEngine_->GetPlayRangeSeekMode());
1388 int32_t seekTime = (startTime != -1 && endTime != -1) ? startTime : 0;
1389 playerEngine_->SetEosInLoopForFrozen(false);
1390 (void)currState->Seek(seekTime, seekMode);
1391 }
1392 });
1393
1394 auto cancelTask = std::make_shared<TaskHandler<void>>([this]() {
1395 MEDIA_LOGI("Interrupted seek action");
1396 playerEngine_->SetEosInLoopForFrozen(false);
1397 taskMgr_.MarkTaskDone("interrupted seek done");
1398 disableNextSeekDone_ = false;
1399 });
1400
1401 int32_t ret = taskMgr_.SeekTask(seekTask, cancelTask, "eos seek", SEEK_PREVIOUS_SYNC, 0);
1402 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "Seek failed");
1403 }
1404 }
1405
PreparedHandleEos()1406 void PlayerServer::PreparedHandleEos()
1407 {
1408 MEDIA_LOGI("PlayerServer PreparedHandleEos in");
1409 if (!config_.looping.load()) {
1410 lastOpStatus_ = PLAYER_PLAYBACK_COMPLETE;
1411 ChangeState(playbackCompletedState_);
1412 (void)taskMgr_.MarkTaskDone("play->completed done");
1413 }
1414 }
1415
HandleInterruptEvent(const Format & infoBody)1416 void PlayerServer::HandleInterruptEvent(const Format &infoBody)
1417 {
1418 MEDIA_LOGI("0x%{public}06" PRIXPTR " HandleInterruptEvent in ", FAKE_POINTER(this));
1419 int32_t hintType = -1;
1420 int32_t forceType = -1;
1421 int32_t eventType = -1;
1422 (void)infoBody.GetIntValue(PlayerKeys::AUDIO_INTERRUPT_TYPE, eventType);
1423 (void)infoBody.GetIntValue(PlayerKeys::AUDIO_INTERRUPT_FORCE, forceType);
1424 (void)infoBody.GetIntValue(PlayerKeys::AUDIO_INTERRUPT_HINT, hintType);
1425 if (forceType == OHOS::AudioStandard::INTERRUPT_FORCE) {
1426 if (hintType == OHOS::AudioStandard::INTERRUPT_HINT_PAUSE ||
1427 hintType == OHOS::AudioStandard::INTERRUPT_HINT_STOP) {
1428 interruptEventState_ = PLAYER_IDLE;
1429 }
1430 }
1431 }
1432
HandleAudioDeviceChangeEvent(const Format & infoBody)1433 void PlayerServer::HandleAudioDeviceChangeEvent(const Format &infoBody)
1434 {
1435 MEDIA_LOGI("0x%{public}06" PRIXPTR " HandleAudioDeviceChangeEvent in ", FAKE_POINTER(this));
1436 int32_t reason = -1;
1437 (void)infoBody.GetIntValue(PlayerKeys::AUDIO_DEVICE_CHANGE_REASON, reason);
1438 if (!deviceChangeCallbackflag_ &&
1439 reason == static_cast<int32_t>(OHOS::AudioStandard::AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE) &&
1440 isStreamUsagePauseRequired_) {
1441 audioDeviceChangeState_ = PLAYER_PAUSED;
1442 (void)BackGroundChangeState(PLAYER_PAUSED, true);
1443 }
1444 }
1445
GetPlaybackSpeed(PlaybackRateMode & mode)1446 int32_t PlayerServer::GetPlaybackSpeed(PlaybackRateMode &mode)
1447 {
1448 std::lock_guard<std::mutex> lock(mutex_);
1449
1450 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1451 MEDIA_LOGE("Can not GetDuration, currentState is PLAYER_STATE_ERROR");
1452 return MSERR_INVALID_OPERATION;
1453 }
1454 MEDIA_LOGD("PlayerServer GetPlaybackSpeed in");
1455
1456 mode = config_.speedMode;
1457 return MSERR_OK;
1458 }
1459
SelectBitRate(uint32_t bitRate)1460 int32_t PlayerServer::SelectBitRate(uint32_t bitRate)
1461 {
1462 std::unique_lock<std::mutex> lock(mutex_);
1463 if (playerEngine_ != nullptr) {
1464 int ret = playerEngine_->SelectBitRate(bitRate, false);
1465 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine SelectBitRate Failed!");
1466 }
1467 return MSERR_OK;
1468 }
1469
1470 #ifdef SUPPORT_VIDEO
SetVideoSurface(sptr<Surface> surface)1471 int32_t PlayerServer::SetVideoSurface(sptr<Surface> surface)
1472 {
1473 std::lock_guard<std::mutex> lock(mutex_);
1474 CHECK_AND_RETURN_RET_LOG(surface != nullptr, MSERR_INVALID_VAL, "surface is nullptr");
1475
1476 bool setSurfaceFirst = lastOpStatus_ == PLAYER_INITIALIZED;
1477 bool switchSurface = lastOpStatus_ == PLAYER_PREPARED ||
1478 lastOpStatus_ == PLAYER_STARTED ||
1479 lastOpStatus_ == PLAYER_PAUSED ||
1480 lastOpStatus_ == PLAYER_STOPPED ||
1481 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE;
1482
1483 if (setSurfaceFirst) {
1484 MEDIA_LOGI("set surface first in %{public}s state", GetStatusDescription(lastOpStatus_).c_str());
1485 } else if (switchSurface) {
1486 MEDIA_LOGI("switch surface in %{public}s state", GetStatusDescription(lastOpStatus_).c_str());
1487 if (surface_ == nullptr && !isForceLoadVideo_ && mutedMediaType_ != OHOS::Media::MediaType::MEDIA_TYPE_VID) {
1488 MEDIA_LOGE("old surface is required before switching surface");
1489 return MSERR_INVALID_OPERATION;
1490 }
1491 } else {
1492 MEDIA_LOGE("current state: %{public}s, can not SetVideoSurface", GetStatusDescription(lastOpStatus_).c_str());
1493 return MSERR_INVALID_OPERATION;
1494 }
1495 MEDIA_LOGD("PlayerServer SetVideoSurface in");
1496 {
1497 std::lock_guard<std::mutex> surfaceLock(surfaceMutex_);
1498 surface_ = surface;
1499 }
1500 CHECK_AND_RETURN_RET_LOG(switchSurface && playerEngine_ != nullptr, MSERR_OK,
1501 "current state: %{public}s, playerEngine == nullptr: %{public}d, can not SetVideoSurface",
1502 GetStatusDescription(lastOpStatus_).c_str(), playerEngine_ == nullptr);
1503 auto task = std::make_shared<TaskHandler<void>>([this]() {
1504 std::lock_guard<std::mutex> surfaceLock(surfaceMutex_);
1505 (void)playerEngine_->SetVideoSurface(surface_);
1506 taskMgr_.MarkTaskDone("SetVideoSurface done");
1507 });
1508 int32_t ret = taskMgr_.SetVideoSurfaeTask(task, "SetVideoSurface");
1509 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetVideoSurface launch task failed");
1510 return MSERR_OK;
1511 }
1512 #endif
1513
SetDecryptConfig(const sptr<DrmStandard::IMediaKeySessionService> & keySessionProxy,bool svp)1514 int32_t PlayerServer::SetDecryptConfig(const sptr<DrmStandard::IMediaKeySessionService> &keySessionProxy,
1515 bool svp)
1516 {
1517 MEDIA_LOGI("PlayerServer SetDecryptConfig");
1518 #ifdef SUPPORT_AVPLAYER_DRM
1519 std::lock_guard<std::mutex> lock(mutex_);
1520 CHECK_AND_RETURN_RET_LOG(keySessionProxy != nullptr, MSERR_INVALID_VAL, "keySessionProxy is nullptr");
1521
1522 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_VAL, "playerEngine_ is nullptr");
1523 int32_t res = playerEngine_->SetDecryptConfig(keySessionProxy, svp);
1524 CHECK_AND_RETURN_RET_LOG(res == MSERR_OK,
1525 static_cast<int32_t>(MSERR_INVALID_OPERATION), "Engine SetDecryptConfig Failed!");
1526 MEDIA_LOGI("PlayerServer SetDecryptConfig out");
1527 return MSERR_OK;
1528 #else
1529 (void)keySessionProxy;
1530 (void)svp;
1531 return 0;
1532 #endif
1533 }
1534
IsPlaying()1535 bool PlayerServer::IsPlaying()
1536 {
1537 std::lock_guard<std::mutex> lock(mutex_);
1538 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1539 MEDIA_LOGE("0x%{public}06" PRIXPTR " Can not judge IsPlaying, currentState is PLAYER_STATE_ERROR",
1540 FAKE_POINTER(this));
1541 return false;
1542 }
1543
1544 return lastOpStatus_ == PLAYER_STARTED;
1545 }
1546
IsPrepared()1547 bool PlayerServer::IsPrepared()
1548 {
1549 std::lock_guard<std::mutex> lock(mutex_);
1550 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1551 MEDIA_LOGE("Can not judge IsPrepared, currentState is PLAYER_STATE_ERROR");
1552 return false;
1553 }
1554
1555 return lastOpStatus_ == PLAYER_PREPARED;
1556 }
1557
IsCompleted()1558 bool PlayerServer::IsCompleted()
1559 {
1560 std::lock_guard<std::mutex> lock(mutex_);
1561 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1562 MEDIA_LOGE("Can not judge IsCompleted, currentState is PLAYER_STATE_ERROR");
1563 return false;
1564 }
1565
1566 return lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE;
1567 }
1568
IsLooping()1569 bool PlayerServer::IsLooping()
1570 {
1571 std::lock_guard<std::mutex> lock(mutex_);
1572 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1573 MEDIA_LOGE("Can not judge IsLooping, currentState is PLAYER_STATE_ERROR");
1574 return false;
1575 }
1576
1577 return config_.looping;
1578 }
1579
SetLooping(bool loop)1580 int32_t PlayerServer::SetLooping(bool loop)
1581 {
1582 std::lock_guard<std::mutex> lock(mutex_);
1583 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1584 MEDIA_LOGE("Can not SetLooping, currentState is PLAYER_STATE_ERROR");
1585 return MSERR_INVALID_OPERATION;
1586 }
1587 MEDIA_LOGD("PlayerServer SetLooping in, loop %{public}d", loop);
1588
1589 if (isLiveStream_) {
1590 MEDIA_LOGE("Can not SetLooping, it is live-stream");
1591 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not SetLooping, it is live-stream");
1592 return MSERR_INVALID_OPERATION;
1593 }
1594
1595 if (lastOpStatus_ == PLAYER_IDLE || lastOpStatus_ == PLAYER_INITIALIZED || GetCurrState() == preparingState_) {
1596 MEDIA_LOGI("Waiting for the engine state is <prepared> to take effect");
1597 config_.looping = loop;
1598 return MSERR_OK;
1599 }
1600
1601 if (playerEngine_ != nullptr) {
1602 int32_t ret = playerEngine_->SetLooping(loop);
1603 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetLooping Failed!");
1604 }
1605 config_.looping = loop;
1606 return MSERR_OK;
1607 }
1608
SetParameter(const Format & param)1609 int32_t PlayerServer::SetParameter(const Format ¶m)
1610 {
1611 std::lock_guard<std::mutex> lock(mutex_);
1612 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1613 MEDIA_LOGE("Can not SetParameter, currentState is PLAYER_STATE_ERROR");
1614 return MSERR_INVALID_OPERATION;
1615 }
1616
1617 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1618
1619 if (param.ContainKey(PlayerKeys::STREAM_USAGE)) {
1620 int32_t streamUsage = OHOS::AudioStandard::STREAM_USAGE_UNKNOWN;
1621 CHECK_AND_RETURN_RET(param.GetIntValue(PlayerKeys::STREAM_USAGE, streamUsage), MSERR_INVALID_VAL);
1622 MEDIA_LOGI("streamUsage = %{public}d", streamUsage);
1623 if (streamUsage != OHOS::AudioStandard::STREAM_USAGE_MUSIC &&
1624 streamUsage != OHOS::AudioStandard::STREAM_USAGE_MOVIE &&
1625 streamUsage != OHOS::AudioStandard::STREAM_USAGE_AUDIOBOOK) {
1626 isStreamUsagePauseRequired_ = false;
1627 }
1628 MEDIA_LOGI("isStreamUsagePauseRequired_ = %{public}d", isStreamUsagePauseRequired_);
1629 }
1630
1631 if (param.ContainKey(PlayerKeys::AUDIO_EFFECT_MODE)) {
1632 int32_t effectMode = OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT;
1633 CHECK_AND_RETURN_RET(param.GetIntValue(PlayerKeys::AUDIO_EFFECT_MODE, effectMode), MSERR_INVALID_VAL);
1634 return SetAudioEffectMode(effectMode);
1635 }
1636
1637 int32_t ret = playerEngine_->SetParameter(param);
1638 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetParameter Failed!");
1639
1640 if (param.ContainKey(PlayerKeys::CONTENT_TYPE)) {
1641 config_.effectMode = OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT;
1642 }
1643
1644 return MSERR_OK;
1645 }
1646
SetAudioEffectMode(const int32_t effectMode)1647 int32_t PlayerServer::SetAudioEffectMode(const int32_t effectMode)
1648 {
1649 MEDIA_LOGD("SetAudioEffectMode in");
1650 CHECK_AND_RETURN_RET(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1651 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE || lastOpStatus_ == PLAYER_PAUSED, MSERR_INVALID_OPERATION);
1652 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1653 CHECK_AND_RETURN_RET_LOG(effectMode <= OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT &&
1654 effectMode >= OHOS::AudioStandard::AudioEffectMode::EFFECT_NONE, MSERR_INVALID_VAL,
1655 "Invalid effectMode parameter");
1656 int32_t ret = playerEngine_->SetAudioEffectMode(effectMode);
1657 if (ret == MSERR_OK) {
1658 config_.effectMode = effectMode;
1659 }
1660
1661 return ret;
1662 }
1663
SetPlayerCallback(const std::shared_ptr<PlayerCallback> & callback)1664 int32_t PlayerServer::SetPlayerCallback(const std::shared_ptr<PlayerCallback> &callback)
1665 {
1666 std::lock_guard<std::mutex> lock(mutex_);
1667 CHECK_AND_RETURN_RET_LOG(callback != nullptr, MSERR_INVALID_VAL, "callback is nullptr");
1668
1669 if (lastOpStatus_ != PLAYER_IDLE && lastOpStatus_ != PLAYER_INITIALIZED) {
1670 MEDIA_LOGE("Can not SetPlayerCallback, currentState is %{public}s",
1671 GetStatusDescription(lastOpStatus_).c_str());
1672 return MSERR_INVALID_OPERATION;
1673 }
1674
1675 {
1676 std::lock_guard<std::mutex> lockCb(mutexCb_);
1677 playerCb_ = callback;
1678 }
1679 return MSERR_OK;
1680 }
1681
SelectTrack(int32_t index,PlayerSwitchMode mode)1682 int32_t PlayerServer::SelectTrack(int32_t index, PlayerSwitchMode mode)
1683 {
1684 std::lock_guard<std::mutex> lock(mutex_);
1685
1686 CHECK_AND_RETURN_RET_LOG(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1687 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE, MSERR_INVALID_OPERATION,
1688 "invalid state %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1689 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1690
1691 auto task = std::make_shared<TaskHandler<void>>([this, index, mode]() {
1692 MediaTrace::TraceBegin("PlayerServer::track", FAKE_POINTER(this));
1693 CHECK_AND_RETURN(IsEngineStarted());
1694 int32_t ret = playerEngine_->SelectTrack(index, mode);
1695 taskMgr_.MarkTaskDone("SelectTrack done");
1696 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "failed to SelectTrack");
1697 });
1698 int32_t ret = taskMgr_.LaunchTask(task, PlayerServerTaskType::STATE_CHANGE, "SelectTrack");
1699 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SelectTrack launch task failed");
1700
1701 return MSERR_OK;
1702 }
1703
DeselectTrack(int32_t index)1704 int32_t PlayerServer::DeselectTrack(int32_t index)
1705 {
1706 std::lock_guard<std::mutex> lock(mutex_);
1707 CHECK_AND_RETURN_RET_LOG(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1708 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE, MSERR_INVALID_OPERATION,
1709 "invalid state %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1710 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1711
1712 auto task = std::make_shared<TaskHandler<void>>([this, index]() {
1713 MediaTrace::TraceBegin("PlayerServer::track", FAKE_POINTER(this));
1714 CHECK_AND_RETURN(IsEngineStarted());
1715 int32_t ret = playerEngine_->DeselectTrack(index);
1716 taskMgr_.MarkTaskDone("DeselectTrack done");
1717 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "failed to DeselectTrack");
1718 });
1719 int32_t ret = taskMgr_.LaunchTask(task, PlayerServerTaskType::STATE_CHANGE, "DeselectTrack");
1720 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "DeselectTrack launch task failed");
1721
1722 return MSERR_OK;
1723 }
1724
GetCurrentTrack(int32_t trackType,int32_t & index)1725 int32_t PlayerServer::GetCurrentTrack(int32_t trackType, int32_t &index)
1726 {
1727 CHECK_AND_RETURN_RET_LOG(trackType >= Media::MediaType::MEDIA_TYPE_AUD &&
1728 trackType <= Media::MediaType::MEDIA_TYPE_SUBTITLE, MSERR_INVALID_VAL,
1729 "Invalid trackType %{public}d", trackType);
1730
1731 std::lock_guard<std::mutex> lock(mutex_);
1732 CHECK_AND_RETURN_RET_LOG(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1733 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE, MSERR_INVALID_OPERATION,
1734 "invalid state %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1735 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1736
1737 return playerEngine_->GetCurrentTrack(trackType, index);
1738 }
1739
FormatToString(std::string & dumpString,std::vector<Format> & videoTrack)1740 void PlayerServer::FormatToString(std::string &dumpString, std::vector<Format> &videoTrack)
1741 {
1742 for (auto iter = videoTrack.begin(); iter != videoTrack.end(); iter++) {
1743 dumpString += iter->Stringify();
1744 dumpString += '\n';
1745 }
1746 }
1747
DumpInfo(int32_t fd)1748 int32_t PlayerServer::DumpInfo(int32_t fd)
1749 {
1750 std::string dumpString;
1751 if (playerEngine_ == nullptr) {
1752 dumpString +=
1753 "The engine is not created, note: engine can't be created until set source.\n";
1754 }
1755 dumpString += "PlayerServer current state is: " + GetStatusDescription(lastOpStatus_) + "\n";
1756 if (lastErrMsg_.size() != 0) {
1757 dumpString += "PlayerServer last error is: " + lastErrMsg_ + "\n";
1758 }
1759 dumpString += "PlayerServer url is: " + config_.url + "\n";
1760 dumpString += "PlayerServer play back speed is: " + std::to_string(config_.speedMode) + "\n";
1761 std::string loopflag = config_.looping ? "" : "not ";
1762 dumpString += "PlayerServer current " + loopflag + "in looping mode\n";
1763 dumpString += "PlayerServer left volume and right volume is: " +
1764 std::to_string(config_.leftVolume) + ", " + std::to_string(config_.rightVolume) + "\n";
1765 dumpString += "PlayerServer audio effect mode is: " + std::to_string(config_.effectMode) + "\n";
1766 if (playerEngine_ != nullptr) {
1767 dumpString += "PlayerServer enable HEBC: " + std::to_string(playerEngine_->GetHEBCMode()) + "\n";
1768 playerEngine_->OnDumpInfo(fd);
1769 }
1770 dumpString += "PlayerServer client bundle name is: " + appName_ + "\n";
1771 dumpString += "PlayerServer instance id is: " + std::to_string(instanceId_) + "\n";
1772 std::vector<Format> videoTrack;
1773 (void)GetVideoTrackInfo(videoTrack);
1774 dumpString += "PlayerServer video tracks info: \n";
1775 FormatToString(dumpString, videoTrack);
1776
1777 std::vector<Format> audioTrack;
1778 (void)GetAudioTrackInfo(audioTrack);
1779 dumpString += "PlayerServer audio tracks info: \n";
1780 FormatToString(dumpString, audioTrack);
1781
1782 int32_t currentTime = -1;
1783 (void)GetCurrentTime(currentTime);
1784 dumpString += "PlayerServer current time is: " + std::to_string(currentTime) + "\n";
1785 write(fd, dumpString.c_str(), dumpString.size());
1786
1787 return MSERR_OK;
1788 }
1789
OnError(PlayerErrorType errorType,int32_t errorCode)1790 void PlayerServer::OnError(PlayerErrorType errorType, int32_t errorCode)
1791 {
1792 (void)errorType;
1793 auto errorMsg = MSErrorToExtErrorString(static_cast<MediaServiceErrCode>(errorCode)) + ", ";
1794 errorMsg += MSErrorToString(static_cast<MediaServiceErrCode>(errorCode));
1795 return OnErrorMessage(errorCode, errorMsg);
1796 }
1797
OnErrorMessage(int32_t errorCode,const std::string & errorMsg)1798 void PlayerServer::OnErrorMessage(int32_t errorCode, const std::string &errorMsg)
1799 {
1800 if (static_cast<MediaServiceExtErrCodeAPI9>(errorCode) == MSERR_EXT_API9_IO) {
1801 MEDIA_LOGD("0x%{public}06" PRIXPTR " PlayerServer OnErrorMessage Error in", FAKE_POINTER(this));
1802 auto pauseTask = std::make_shared<TaskHandler<void>>([this, errorCode, errorMsg]() {
1803 MediaTrace::TraceBegin("PlayerServer::PauseIoError", FAKE_POINTER(this));
1804 MEDIA_LOGI("PlayerServer::PauseIoError start");
1805 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1806 (void)currState->Pause(true);
1807 OnErrorCb(errorCode, errorMsg);
1808 MEDIA_LOGI("PlayerServer::PauseIoError end");
1809 });
1810 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::STATE_CHANGE, "pause");
1811 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnErrorMessage IO Error out", FAKE_POINTER(this));
1812 return;
1813 } else if (errorCode == MSERR_DEMUXER_BUFFER_NO_MEMORY) {
1814 auto pauseTask = std::make_shared<TaskHandler<void>>([this, errorCode, errorMsg]() {
1815 MEDIA_LOGI("MSERR_DEMUXER_BUFFER_NO_MEMORY PauseDemuxer start");
1816 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1817 (void)currState->PauseDemuxer();
1818 OnErrorCb(errorCode, errorMsg);
1819 MEDIA_LOGI("MSERR_DEMUXER_BUFFER_NO_MEMORY PauseDemuxer end");
1820 });
1821 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::LIGHT_TASK, "PauseDemuxer");
1822 return;
1823 }
1824 OnErrorCb(errorCode, errorMsg);
1825 }
1826
OnErrorCb(int32_t errorCode,const std::string & errorMsg)1827 void PlayerServer::OnErrorCb(int32_t errorCode, const std::string &errorMsg)
1828 {
1829 std::lock_guard<std::mutex> lockCb(mutexCb_);
1830 lastErrMsg_ = errorMsg;
1831 if (playerCb_ != nullptr && !errorCbOnce_) {
1832 playerCb_->OnError(errorCode, errorMsg);
1833 errorCbOnce_ = true;
1834 }
1835 }
1836
OnInfo(PlayerOnInfoType type,int32_t extra,const Format & infoBody)1837 void PlayerServer::OnInfo(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
1838 {
1839 std::lock_guard<std::mutex> lockCb(mutexCb_);
1840 int32_t ret = HandleMessage(type, extra, infoBody);
1841 InnerOnInfo(type, extra, infoBody, ret);
1842 }
1843
DoCheckLiveDelayTime()1844 void PlayerServer::DoCheckLiveDelayTime()
1845 {
1846 CHECK_AND_RETURN(playerEngine_ != nullptr);
1847 MEDIA_LOGI("DoCheckLiveDelayTime");
1848 PlaybackRateMode mode = PlaybackRateMode::SPEED_FORWARD_1_00_X;
1849 bool isExceedMaxDelayTime = playerEngine_->IsNeedChangePlaySpeed(mode, isXSpeedPlay_);
1850 if (isExceedMaxDelayTime) {
1851 int32_t ret = playerEngine_->SetPlaybackSpeed(mode);
1852 sumPauseTime_ = (ret == MSERR_OK && mode == PlaybackRateMode::SPEED_FORWARD_1_20_X) ? 0 : sumPauseTime_;
1853 }
1854 return;
1855 }
1856
InnerOnInfo(PlayerOnInfoType type,int32_t extra,const Format & infoBody,const int32_t ret)1857 void PlayerServer::InnerOnInfo(PlayerOnInfoType type, int32_t extra, const Format &infoBody, const int32_t ret)
1858 {
1859 if (type == INFO_TYPE_IS_LIVE_STREAM) {
1860 isLiveStream_ = true;
1861 } else if (type == INFO_TYPE_TRACK_NUM_UPDATE) {
1862 subtitleTrackNum_ = static_cast<uint32_t>(extra);
1863 return;
1864 }
1865 CHECK_AND_RETURN_LOG(CheckState(type, extra), "OnInfo check state failed");
1866 if (type == INFO_TYPE_DEFAULTTRACK || type == INFO_TYPE_TRACK_DONE || type == INFO_TYPE_ADD_SUBTITLE_DONE) {
1867 return;
1868 }
1869 if (playerCb_ != nullptr && type == INFO_TYPE_ERROR_MSG) {
1870 int32_t errorCode = extra;
1871 Format newInfo = infoBody;
1872 auto errorMsg = MSErrorToString(static_cast<MediaServiceErrCode>(errorCode));
1873 newInfo.PutIntValue(std::string(PlayerKeys::PLAYER_ERROR_TYPE), errorCode);
1874 newInfo.PutStringValue(std::string(PlayerKeys::PLAYER_ERROR_MSG), errorMsg);
1875 playerCb_->OnInfo(type, extra, newInfo);
1876 return;
1877 }
1878 if (type == INFO_TYPE_BUFFERING_UPDATE) {
1879 OnBufferingUpdate(type, extra, infoBody);
1880 }
1881 if (type == INFO_TYPE_FLV_AUTO_SELECT_BITRATE) {
1882 OnFlvAutoSelectBitRate(extra);
1883 return;
1884 }
1885 if (playerCb_ != nullptr && ret == MSERR_OK) {
1886 bool isBackgroudPause = (extra == backgroundState_ || extra == interruptEventState_ ||
1887 extra == audioDeviceChangeState_);
1888 if (isBackgroundChanged_ && type == INFO_TYPE_STATE_CHANGE && isBackgroudPause) {
1889 MEDIA_LOGI("Background change state to %{public}d, Status reporting %{public}d", extra, isBackgroundCb_);
1890 if (isBackgroundCb_) {
1891 Format newInfo = infoBody;
1892 newInfo.PutIntValue(PlayerKeys::PLAYER_STATE_CHANGED_REASON, StateChangeReason::BACKGROUND);
1893 playerCb_->OnInfo(type, extra, newInfo);
1894 isBackgroundCb_ = false;
1895 }
1896 isBackgroundChanged_ = false;
1897 interruptEventState_ = PLAYER_IDLE;
1898 audioDeviceChangeState_ = PLAYER_IDLE;
1899 } else {
1900 playerCb_->OnInfo(type, extra, infoBody);
1901 }
1902 } else {
1903 MEDIA_LOGD("0x%{public}06" PRIXPTR " playerCb_ != nullptr %{public}d, ret %{public}d",
1904 FAKE_POINTER(this), playerCb_ != nullptr, ret);
1905 }
1906 }
1907
OnDfxInfo(const DfxEvent & event)1908 void PlayerServer::OnDfxInfo(const DfxEvent &event)
1909 {
1910 MEDIA_LOGD("OnDfxInfo, type: %{public}d", static_cast<int32_t>(event.type));
1911 if (event.type == DfxEventType::DFX_INFO_MEMORY_USAGE) {
1912 totalMemoryUage_ = AnyCast<uint32_t>(event.param);
1913 MEDIA_LOGD("OnDfxInfo %{public}d", static_cast<int32_t>(totalMemoryUage_.load()));
1914 }
1915 }
1916
OnSystemOperation(PlayerOnSystemOperationType type,PlayerOperationReason reason)1917 void PlayerServer::OnSystemOperation(PlayerOnSystemOperationType type, PlayerOperationReason reason)
1918 {
1919 std::lock_guard<std::mutex> lock(mutex_);
1920 MEDIA_LOGI("PlayerServer OnSystemOperation start, type: %{public}d, reason: %{public}d", static_cast<int32_t>(type),
1921 static_cast<int32_t>(reason));
1922 switch (type) {
1923 case OPERATION_TYPE_PAUSE:
1924 if (lastOpStatus_ == PLAYER_STARTED) {
1925 (void)OnPause(true);
1926 }
1927 break;
1928 case OPERATION_TYPE_CHECK_LIVE_DELAY:
1929 DoCheckLiveDelayTime();
1930 break;
1931 default:
1932 MEDIA_LOGI("Can not OnSystemOperation, currentState is %{public}s",
1933 GetStatusDescription(lastOpStatus_).c_str());
1934 break;
1935 }
1936 }
1937
OnBufferingUpdate(PlayerOnInfoType type,int32_t extra,const Format & infoBody)1938 void PlayerServer::OnBufferingUpdate(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
1939 {
1940 Format newInfo = infoBody;
1941 int info = -1;
1942 infoBody.GetIntValue(std::string(PlayerKeys::PLAYER_BUFFERING_START), info);
1943 if (info == 1) {
1944 OnNotifyBufferingStart();
1945 return;
1946 }
1947 infoBody.GetIntValue(std::string(PlayerKeys::PLAYER_BUFFERING_END), info);
1948 if (info == 1) {
1949 OnNotifyBufferingEnd();
1950 return;
1951 }
1952 }
1953
OnNotifyBufferingStart()1954 void PlayerServer::OnNotifyBufferingStart()
1955 {
1956 MEDIA_LOGD("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingStart in", FAKE_POINTER(this));
1957 auto pauseTask = std::make_shared<TaskHandler<void>>([this]() {
1958 MediaTrace::TraceBegin("PlayerServer::PauseDemuxer", FAKE_POINTER(this));
1959 MEDIA_LOGI("PauseDemuxer start");
1960 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1961 (void)currState->PauseDemuxer();
1962 MEDIA_LOGI("PauseDemuxer end");
1963 });
1964 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::LIGHT_TASK, "PauseDemuxer");
1965 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingStart out", FAKE_POINTER(this));
1966 UpdateFlvLivePauseTime();
1967 return;
1968 }
1969
OnNotifyBufferingEnd()1970 void PlayerServer::OnNotifyBufferingEnd()
1971 {
1972 MEDIA_LOGD("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingEnd in", FAKE_POINTER(this));
1973 auto playingTask = std::make_shared<TaskHandler<void>>([this]() {
1974 MediaTrace::TraceBegin("PlayerServer::ResumeDemuxer", FAKE_POINTER(this));
1975 MEDIA_LOGI("ResumeDemuxer start");
1976 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1977 (void)currState->ResumeDemuxer();
1978 MEDIA_LOGI("ResumeDemuxer end");
1979 });
1980 taskMgr_.LaunchTask(playingTask, PlayerServerTaskType::LIGHT_TASK, "ResumeDemuxer");
1981 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingEnd out", FAKE_POINTER(this));
1982 return;
1983 }
1984
OnFlvAutoSelectBitRate(uint32_t bitRate)1985 void PlayerServer::OnFlvAutoSelectBitRate(uint32_t bitRate)
1986 {
1987 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnFlvAutoSelectBitRate in", FAKE_POINTER(this));
1988 CHECK_AND_RETURN(playerEngine_ != nullptr);
1989 auto autoSelectBitRateTask = std::make_shared<TaskHandler<void>>([this, bitRate]() {
1990 MediaTrace::TraceBegin("PlayerServer::OnFlvAutoSelectBitRate", FAKE_POINTER(this));
1991 if (playerEngine_ == nullptr) {
1992 MEDIA_LOGI("OnFlvAutoSelectBitRate task end, playerEngine_ is null");
1993 taskMgr_.MarkTaskDone("flv auto select bitrate ignore");
1994 return;
1995 }
1996 int32_t ret = playerEngine_->SelectBitRate(bitRate, true);
1997 MEDIA_LOGI("OnFlvAutoSelectBitRate task end");
1998 taskMgr_.MarkTaskDone("flv auto select bitrate done");
1999 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "flv auto select bit rate failed");
2000 });
2001 taskMgr_.LaunchTask(autoSelectBitRateTask, PlayerServerTaskType::LIGHT_TASK, "AutoSelectBitRateTask");
2002 MEDIA_LOGD("0x%{public}06" PRIXPTR " PlayerServer OnFlvAutoSelectBitRate out", FAKE_POINTER(this));
2003 return;
2004 }
2005
UpdateFlvLivePauseTime()2006 void PlayerServer::UpdateFlvLivePauseTime()
2007 {
2008 CHECK_AND_RETURN_LOG(playerEngine_ != nullptr, "playerEngine_ is nullptr");
2009 CHECK_AND_RETURN_NOLOG(playerEngine_->IsFlvLive());
2010 if (pauseTimestamp_ == HST_TIME_NONE) {
2011 pauseTimestamp_ = SteadyClock::GetCurrentTimeMs();
2012 if (pauseTimestamp_ < 0) {
2013 MEDIA_LOGI("get current time failed");
2014 pauseTimestamp_ = HST_TIME_NONE;
2015 }
2016 }
2017 }
2018
TryFlvLiveRestartLink()2019 void PlayerServer::TryFlvLiveRestartLink()
2020 {
2021 CHECK_AND_RETURN_LOG(playerEngine_ != nullptr, "playerEngine_ is nullptr");
2022 CHECK_AND_RETURN_NOLOG(playerEngine_->IsFlvLive());
2023 if (pauseTimestamp_ != HST_TIME_NONE) {
2024 sumPauseTime_ += CalculatePauseTime();
2025 pauseTimestamp_ = HST_TIME_NONE;
2026 bool isNeededRestartLink = playerEngine_->IsPauseForTooLong(sumPauseTime_);
2027 if (isNeededRestartLink) {
2028 HandleFlvLiveRestartLink();
2029 }
2030 }
2031 }
2032
CalculatePauseTime()2033 int64_t PlayerServer::CalculatePauseTime()
2034 {
2035 int64_t curTime = SteadyClock::GetCurrentTimeMs();
2036 return (curTime > pauseTimestamp_) ? (curTime - pauseTimestamp_) : 0;
2037 }
2038
HandleFlvLiveRestartLink()2039 void PlayerServer::HandleFlvLiveRestartLink()
2040 {
2041 MEDIA_LOGI("HandleRestartLink");
2042 std::lock_guard<std::mutex> lock(mutex_);
2043 sumPauseTime_ = 0;
2044 pauseTimestamp_ = HST_TIME_NONE;
2045 playerEngine_->DoRestartLiveLink();
2046 playerEngine_->SetPlaybackSpeed(PlaybackRateMode::SPEED_FORWARD_1_00_X);
2047 isXSpeedPlay_ = false;
2048 }
2049
OnInfoNoChangeStatus(PlayerOnInfoType type,int32_t extra,const Format & infoBody)2050 void PlayerServer::OnInfoNoChangeStatus(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
2051 {
2052 std::lock_guard<std::mutex> lockCb(mutexCb_);
2053
2054 if (playerCb_ != nullptr) {
2055 playerCb_->OnInfo(type, extra, infoBody);
2056 }
2057 }
2058
GetStatusDescription(int32_t status)2059 const std::string &PlayerServer::GetStatusDescription(int32_t status)
2060 {
2061 static const std::string ILLEGAL_STATE = "PLAYER_STATUS_ILLEGAL";
2062 if (status < PLAYER_STATE_ERROR || status > PLAYER_PLAYBACK_COMPLETE) {
2063 return ILLEGAL_STATE;
2064 }
2065
2066 return STATUS_TO_STATUS_DESCRIPTION_TABLE.find(status)->second;
2067 }
2068
GetStateName() const2069 std::string PlayerServerState::GetStateName() const
2070 {
2071 return name_;
2072 }
2073
HandleMessage(PlayerOnInfoType type,int32_t extra,const Format & infoBody)2074 int32_t PlayerServerStateMachine::HandleMessage(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
2075 {
2076 if (currState_ != nullptr) {
2077 return currState_->OnMessageReceived(type, extra, infoBody);
2078 }
2079 return MSERR_OK;
2080 }
2081
Init(const std::shared_ptr<PlayerServerState> & state)2082 void PlayerServerStateMachine::Init(const std::shared_ptr<PlayerServerState> &state)
2083 {
2084 currState_ = state;
2085 }
2086
ChangeState(const std::shared_ptr<PlayerServerState> & state)2087 void PlayerServerStateMachine::ChangeState(const std::shared_ptr<PlayerServerState> &state)
2088 {
2089 {
2090 // Resolve the deadlock between reset and state callback
2091 std::unique_lock<std::recursive_mutex> lock(recMutex_);
2092
2093 if (state == nullptr || (state == currState_)) {
2094 return;
2095 }
2096
2097 if (currState_) {
2098 MEDIA_LOGD("exit state %{public}s", currState_->name_.c_str());
2099 currState_->StateExit();
2100 }
2101 MEDIA_LOGI("instance: 0x%{public}06" PRIXPTR " change state to %{public}s",
2102 FAKE_POINTER(this), state->name_.c_str());
2103 currState_ = state;
2104 }
2105 state->StateEnter();
2106 }
2107
GetCurrState()2108 std::shared_ptr<PlayerServerState> PlayerServerStateMachine::GetCurrState()
2109 {
2110 std::unique_lock<std::recursive_mutex> lock(recMutex_);
2111 return currState_;
2112 }
2113
OnCommonEventReceived(const std::string & event)2114 void PlayerServer::OnCommonEventReceived(const std::string &event)
2115 {
2116 MEDIA_LOGI("instance: 0x%{public}06" PRIXPTR " receive event %{public}s",
2117 FAKE_POINTER(this), event.c_str());
2118 if (event == EventFwk::CommonEventSupport::COMMON_EVENT_USER_BACKGROUND) {
2119 std::weak_ptr<PlayerServer> server = std::static_pointer_cast<PlayerServer>(shared_from_this());
2120 auto pauseTask = std::make_shared<TaskHandler<void>>([server]() {
2121 std::shared_ptr<PlayerServer> spServer = server.lock();
2122 if (spServer != nullptr) {
2123 spServer->taskMgr_.MarkTaskDone("receiveccommonevent done");
2124 (void)spServer->OnSystemOperation(OPERATION_TYPE_PAUSE, OPERATION_REASON_USER_BACKGROUND);
2125 }
2126 });
2127 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::STATE_CHANGE, "receiveccommonevent");
2128 }
2129 }
2130
GetUserId()2131 int32_t PlayerServer::GetUserId()
2132 {
2133 return userId_.load();
2134 }
2135
GetCommonEventReceiver()2136 std::shared_ptr<CommonEventReceiver> PlayerServer::GetCommonEventReceiver()
2137 {
2138 return commonEventReceiver_;
2139 }
2140
IsBootCompleted()2141 bool PlayerServer::IsBootCompleted()
2142 {
2143 return isBootCompleted_.load();
2144 }
2145
SetMediaMuted(OHOS::Media::MediaType mediaType,bool isMuted)2146 int32_t PlayerServer::SetMediaMuted(OHOS::Media::MediaType mediaType, bool isMuted)
2147 {
2148 CHECK_AND_RETURN_RET(mediaType == OHOS::Media::MediaType::MEDIA_TYPE_AUD ||
2149 mediaType == OHOS::Media::MediaType::MEDIA_TYPE_VID, MSERR_INVALID_VAL);
2150 std::lock_guard<std::mutex> lock(mutex_);
2151 CHECK_AND_RETURN_RET(lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_PREPARED ||
2152 lastOpStatus_ == PLAYER_STARTED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE ||
2153 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_STOPPED,
2154 MSERR_INVALID_STATE);
2155 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
2156 auto mediaMuteTask = std::make_shared<TaskHandler<int32_t>>([this, mediaType, isMuted]() {
2157 MediaTrace trace("PlayerServer::SetMediaMuted");
2158 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, taskMgr_.MarkTaskDone("SetMediaMuted done"),
2159 "SetMediaMuted failed, playerEngine is nullptr");
2160 auto res = playerEngine_->SetMediaMuted(mediaType, isMuted);
2161 MEDIA_LOGI("SetMediaMuted %{public}u %{public}u", mediaType, isMuted);
2162 taskMgr_.MarkTaskDone("SetMediaMuted done");
2163 return res;
2164 });
2165 taskMgr_.LaunchTask(mediaMuteTask, PlayerServerTaskType::LIGHT_TASK, "SetMediaMuted");
2166 return MSERR_OK;
2167 }
2168
SetPlaybackStrategy(AVPlayStrategy playbackStrategy)2169 int32_t PlayerServer::SetPlaybackStrategy(AVPlayStrategy playbackStrategy)
2170 {
2171 MediaTrace::TraceBegin("PlayerServer::SetPlaybackStrategy", FAKE_POINTER(this));
2172 std::lock_guard<std::mutex> lock(mutex_);
2173 bool isValidState = lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STOPPED;
2174 CHECK_AND_RETURN_RET_LOG(isValidState, MSERR_INVALID_STATE,
2175 "can not set playback strategy, current state is %{public}d", static_cast<int32_t>(lastOpStatus_.load()));
2176 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
2177 MEDIA_LOGD("PlayerServer::SetPlaybackStrategy mutedMediaType is: %{public}d", playbackStrategy.mutedMediaType);
2178 MEDIA_LOGD("SetPlaybackStrategy keepDecodingOnmute is: %{public}d ", playbackStrategy.keepDecodingOnMute);
2179 mutedMediaType_ = playbackStrategy.mutedMediaType;
2180 return playerEngine_->SetPlaybackStrategy(playbackStrategy);
2181 }
2182
SetSuperResolution(bool enabled)2183 int32_t PlayerServer::SetSuperResolution(bool enabled)
2184 {
2185 MediaTrace::TraceBegin("PlayerServer::SetSuperResolution", FAKE_POINTER(this));
2186 std::lock_guard<std::mutex> lock(mutex_);
2187 bool isValidState = lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_PREPARED ||
2188 lastOpStatus_ == PLAYER_STARTED || lastOpStatus_ == PLAYER_PAUSED ||
2189 lastOpStatus_ == PLAYER_STOPPED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE;
2190 CHECK_AND_RETURN_RET_LOG(isValidState, MSERR_INVALID_STATE,
2191 "can not set super resolution, current state is %{public}d", static_cast<int32_t>(lastOpStatus_.load()));
2192 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
2193 return playerEngine_->SetSuperResolution(enabled);
2194 }
2195
SetVideoWindowSize(int32_t width,int32_t height)2196 int32_t PlayerServer::SetVideoWindowSize(int32_t width, int32_t height)
2197 {
2198 MediaTrace::TraceBegin("PlayerServer::SetVideoWindowSize", FAKE_POINTER(this));
2199 std::lock_guard<std::mutex> lock(mutex_);
2200 bool isValidState = lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_PREPARED ||
2201 lastOpStatus_ == PLAYER_STARTED || lastOpStatus_ == PLAYER_PAUSED ||
2202 lastOpStatus_ == PLAYER_STOPPED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE;
2203 CHECK_AND_RETURN_RET_LOG(isValidState, MSERR_INVALID_STATE,
2204 "can not set video window size, current state is %{public}d", static_cast<int32_t>(lastOpStatus_.load()));
2205 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
2206 return playerEngine_->SetVideoWindowSize(width, height);
2207 }
2208
CheckSeek(int32_t mSeconds,PlayerSeekMode mode)2209 int32_t PlayerServer::CheckSeek(int32_t mSeconds, PlayerSeekMode mode)
2210 {
2211 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
2212
2213 MEDIA_LOGI("KPI-TRACE: PlayerServer Seek in");
2214 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
2215 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
2216 MEDIA_LOGE("Can not Seek, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
2217 return MSERR_INVALID_OPERATION;
2218 }
2219
2220 if (IsValidSeekMode(mode) != true) {
2221 MEDIA_LOGE("Seek failed, inValid mode");
2222 return MSERR_INVALID_VAL;
2223 }
2224
2225 if (isLiveStream_) {
2226 MEDIA_LOGE("Can not Seek, it is live-stream");
2227 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not Seek, it is live-stream");
2228 return MSERR_INVALID_OPERATION;
2229 }
2230 return MSERR_OK;
2231 }
2232
SeekContinous(int32_t mSeconds)2233 int32_t PlayerServer::SeekContinous(int32_t mSeconds)
2234 {
2235 if (mSeconds == -1) {
2236 ExitSeekContinousAsync(true);
2237 return MSERR_OK;
2238 }
2239 {
2240 std::lock_guard<std::mutex> lock(seekContinousMutex_);
2241 if (!isInSeekContinous_.load()) {
2242 UpdateContinousBatchNo();
2243 isInSeekContinous_.store(true);
2244 }
2245 }
2246 int64_t seekContinousBatchNo = seekContinousBatchNo_.load();
2247 mSeconds = std::max(0, mSeconds);
2248 auto seekContinousTask = std::make_shared<TaskHandler<void>>([this, mSeconds, seekContinousBatchNo]() {
2249 MediaTrace trace("PlayerServer::SeekContinous");
2250 MEDIA_LOGI("PlayerServer::Seek start");
2251 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
2252 (void)currState->SeekContinous(mSeconds, seekContinousBatchNo);
2253 MEDIA_LOGI("PlayerServer::SeekContinous end");
2254 taskMgr_.MarkTaskDone("seek continous done");
2255 });
2256
2257 int32_t ret = taskMgr_.SeekContinousTask(seekContinousTask, "seek continous");
2258 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SeekContinous failed");
2259
2260 MEDIA_LOGI("Queue seekTask end, position %{public}d", mSeconds);
2261 return MSERR_OK;
2262 }
2263
HandleSeekContinous(int32_t mSeconds,int64_t batchNo)2264 int32_t PlayerServer::HandleSeekContinous(int32_t mSeconds, int64_t batchNo)
2265 {
2266 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d, "
2267 "instanceId: %{public}" PRIu64 "", mSeconds, instanceId_);
2268 int32_t ret = playerEngine_->SeekContinous(mSeconds, batchNo);
2269 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Seek Failed!");
2270 MEDIA_LOGI("PlayerServer HandleSeek end");
2271 return MSERR_OK;
2272 }
2273
ExitSeekContinous(bool align)2274 int32_t PlayerServer::ExitSeekContinous(bool align)
2275 {
2276 {
2277 std::lock_guard<std::mutex> lock(seekContinousMutex_);
2278 if (!isInSeekContinous_.load()) {
2279 return MSERR_OK;
2280 }
2281 UpdateContinousBatchNo();
2282 isInSeekContinous_.store(false);
2283 }
2284 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
2285 return playerEngine_->ExitSeekContinous(align, seekContinousBatchNo_.load());
2286 }
2287
ExitSeekContinousAsync(bool align)2288 int32_t PlayerServer::ExitSeekContinousAsync(bool align)
2289 {
2290 {
2291 std::lock_guard<std::mutex> lock(seekContinousMutex_);
2292 if (!isInSeekContinous_.load()) {
2293 return MSERR_OK;
2294 }
2295 UpdateContinousBatchNo();
2296 isInSeekContinous_.store(false);
2297 }
2298 int64_t seekContinousBatchNo = seekContinousBatchNo_.load();
2299 auto exitSeekContinousTask = std::make_shared<TaskHandler<void>>([this, align, seekContinousBatchNo]() {
2300 MediaTrace trace("PlayerServer::ExitSeekContinousAsync");
2301 MEDIA_LOGI("PlayerServer::ExitSeekContinous start");
2302 if (playerEngine_ == nullptr) {
2303 MEDIA_LOGE("playerEngine_ is nullptr!");
2304 taskMgr_.MarkTaskDone("exit seek continous done");
2305 return;
2306 }
2307 playerEngine_->ExitSeekContinous(align, seekContinousBatchNo);
2308 MEDIA_LOGI("PlayerServer::ExitSeekContinous end");
2309 taskMgr_.MarkTaskDone("exit seek continous done");
2310 });
2311 int32_t ret = taskMgr_.SeekContinousTask(exitSeekContinousTask, "exit seek continous");
2312 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SeekContinous failed");
2313 return MSERR_OK;
2314 }
2315
SetDeviceChangeCbStatus(bool status)2316 int32_t PlayerServer::SetDeviceChangeCbStatus(bool status)
2317 {
2318 deviceChangeCallbackflag_ = status;
2319 MEDIA_LOGI("Set DeviceChangeFlag success, status = %{public}d", deviceChangeCallbackflag_);
2320 return MSERR_OK;
2321 }
2322
UpdateContinousBatchNo()2323 void PlayerServer::UpdateContinousBatchNo()
2324 {
2325 seekContinousBatchNo_++;
2326 }
2327
CheckState(PlayerOnInfoType type,int32_t extra)2328 bool PlayerServer::CheckState(PlayerOnInfoType type, int32_t extra)
2329 {
2330 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
2331 bool isCompletedInfo = type == INFO_TYPE_STATE_CHANGE && extra == PlayerStates::PLAYER_PLAYBACK_COMPLETE;
2332 bool isEosInfo = type == INFO_TYPE_EOS;
2333 CHECK_AND_RETURN_RET_LOG(currState != stoppedState_ || !(isCompletedInfo || isEosInfo), false,
2334 "do not report completed or eos in stopped state");
2335
2336 bool isErrorInfo = type == INFO_TYPE_STATE_CHANGE && extra == PlayerStates::PLAYER_STATE_ERROR;
2337 CHECK_AND_RETURN_RET_LOG(currState != idleState_ || !isErrorInfo, false, "do not report error in idle state");
2338
2339 bool isPreparedInfo = type == INFO_TYPE_STATE_CHANGE && extra == PlayerStates::PLAYER_PREPARED;
2340 CHECK_AND_RETURN_RET_LOG(currState != idleState_ || !isPreparedInfo, false,
2341 "do not report prepared in idle state");
2342 return true;
2343 }
2344
SetMaxAmplitudeCbStatus(bool status)2345 int32_t PlayerServer::SetMaxAmplitudeCbStatus(bool status)
2346 {
2347 maxAmplitudeCbStatus_ = status;
2348 std::lock_guard<std::mutex> lock(mutex_);
2349 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
2350 return playerEngine_->SetMaxAmplitudeCbStatus(maxAmplitudeCbStatus_);
2351 }
2352
IsSeekContinuousSupported()2353 bool PlayerServer::IsSeekContinuousSupported()
2354 {
2355 MediaTrace trace("PlayerServer::IsSeekContinuousSupported");
2356 std::lock_guard<std::mutex> lock(mutex_);
2357 CHECK_AND_RETURN_RET(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
2358 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE || lastOpStatus_ == PLAYER_PAUSED, false);
2359 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, false, "engine is nullptr");
2360 bool isSeekContinuousSupported = false;
2361 int32_t ret = playerEngine_->IsSeekContinuousSupported(isSeekContinuousSupported);
2362 return ret == MSERR_OK && isSeekContinuousSupported;
2363 }
2364
SetSeiMessageCbStatus(bool status,const std::vector<int32_t> & payloadTypes)2365 int32_t PlayerServer::SetSeiMessageCbStatus(bool status, const std::vector<int32_t> &payloadTypes)
2366 {
2367 seiMessageCbStatus_ = status;
2368 payloadTypes_.assign(payloadTypes.begin(), payloadTypes.end());
2369 CHECK_AND_RETURN_RET_NOLOG(
2370 playerEngine_ == nullptr, playerEngine_->SetSeiMessageCbStatus(status, payloadTypes));
2371 return MSERR_OK;
2372 }
2373
GetMemoryUsage()2374 uint32_t PlayerServer::GetMemoryUsage()
2375 {
2376 int32_t version = apiVersion_.load();
2377 CHECK_AND_RETURN_RET_LOG(version >= MEMORY_USAGE_VERSION_ISOLATION, 0, "api version is low %{public}d", version);
2378 return totalMemoryUage_.load();
2379 }
2380
SetReopenFd(int32_t fd)2381 int32_t PlayerServer::SetReopenFd(int32_t fd)
2382 {
2383 MEDIA_LOGD("Set reopenFd success, fd = %{public}d", fd);
2384 CHECK_AND_RETURN_RET_NOLOG(playerEngine_ == nullptr, playerEngine_->SetReopenFd(fd));
2385 return MSERR_OK;
2386 }
2387
EnableCameraPostprocessing()2388 int32_t PlayerServer::EnableCameraPostprocessing()
2389 {
2390 MediaTrace::TraceBegin("PlayerServer::EnableCameraPostprocessing", FAKE_POINTER(this));
2391 std::lock_guard<std::mutex> lock(mutex_);
2392 bool isValidState = lastOpStatus_ == PLAYER_INITIALIZED;
2393 CHECK_AND_RETURN_RET_LOG(isValidState, MSERR_INVALID_STATE,
2394 "can not enable camera postProcessor, current state is %{public}d", static_cast<int32_t>(lastOpStatus_.load()));
2395 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
2396 return playerEngine_->EnableCameraPostprocessing();
2397 }
2398
SetCameraPostprocessing(bool isOpen)2399 int32_t PlayerServer::SetCameraPostprocessing(bool isOpen)
2400 {
2401 MediaTrace::TraceBegin("PlayerServer::SetCameraPostprocessing", FAKE_POINTER(this));
2402 std::lock_guard<std::mutex> lock(mutex_);
2403 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
2404 return playerEngine_->SetCameraPostprocessing(isOpen);
2405 }
2406
EnableReportMediaProgress(bool enable)2407 int32_t PlayerServer::EnableReportMediaProgress(bool enable)
2408 {
2409 std::lock_guard<std::mutex> lock(mutex_);
2410 enableReportMediaProgress_ = enable;
2411 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
2412 return playerEngine_->EnableReportMediaProgress(enableReportMediaProgress_);
2413 }
2414
EnableReportAudioInterrupt(bool enable)2415 int32_t PlayerServer::EnableReportAudioInterrupt(bool enable)
2416 {
2417 std::lock_guard<std::mutex> lock(mutex_);
2418 enableReportAudioInterrupt_ = enable;
2419 if (playerCb_ != nullptr) {
2420 playerCb_->SetInterruptListenerFlag(enableReportAudioInterrupt_);
2421 }
2422 return MSERR_OK;
2423 }
2424
ForceLoadVideo(bool status)2425 int32_t PlayerServer::ForceLoadVideo(bool status)
2426 {
2427 std::lock_guard<std::mutex> lock(mutex_);
2428 isForceLoadVideo_ = status;
2429 auto forceLoadVideoTask = std::make_shared<TaskHandler<int32_t>>([this, status]() {
2430 MediaTrace trace("PlayerServer::ForceLoadVideo");
2431 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, taskMgr_.MarkTaskDone("ForceLoadVideo done"),
2432 "ForceLoadVideo failed, playerEngine is nullptr");
2433 auto res = playerEngine_->ForceLoadVideo(status);
2434 MEDIA_LOGI("ForceLoadVideo %{public}d", status);
2435 taskMgr_.MarkTaskDone("ForceLoadVideo done");
2436 return res;
2437 });
2438 taskMgr_.LaunchTask(forceLoadVideoTask, PlayerServerTaskType::LIGHT_TASK, "ForceLoadVideo");
2439 return MSERR_OK;
2440 }
2441 } // namespace Media
2442 } // namespace OHOS
2443