const int kSeekableTimeUpdateInterval = 500;
}
+static void PlayerPreLoadingCb(void* data) {
+ if (!data) {
+ LOG(ERROR) << "input data is null";
+ return;
+ }
+ media::MediaPlayerBridgeCapiTV* player =
+ static_cast<media::MediaPlayerBridgeCapiTV*>(data);
+ player->OnPlayerPreloading();
+}
+
static void DrmErrorCb(int err_code, char* err_str, void* data) {
DCHECK(data);
media::MediaPlayerBridgeCapiTV* player =
if (blink::IsHbbTV() && CheckHighBitRate() && stream_type_ == DASH_STREAM)
AppendUrlHighBitRate(url_.spec());
+ player_prepared_ = false;
MediaPlayerBridgeCapi::Prepare();
if (GetMediaPlayerClient())
GetMediaPlayerClient()->NotifyPlaybackState(kPlaybackReady, player_id_);
}
void MediaPlayerBridgeCapiTV::Release() {
+ is_preloaded_ = false;
+ player_prepared_ = false;
StopSeekableTimeUpdateTimer();
MediaPlayerBridgeCapi::Release();
if (GetMediaPlayerClient())
}
bool MediaPlayerBridgeCapiTV::Play() {
+ LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__
+ << ",current_time:" << GetCurrentTime().InSecondsF();
+
+ // HBBTV run in preloading and preplay mode. If no prepread do prepare
+ // in PlayerPrePlay(), otherwise do normal Play.
+ if (blink::IsHbbTV() && !player_prepared_) {
+ if (!PlayerPrePlay())
+ LOG(ERROR) << "HBBTV prePlay fail.";
+ return false;
+ }
if (!MediaPlayerBridgeCapi::Play())
return false;
if (GetMediaPlayerClient())
return true;
}
+void MediaPlayerBridgeCapiTV::Pause(bool is_media_related_action) {
+ if (!player_prepared_) {
+ LOG(INFO) << "(" << static_cast<void*>(this)
+ << "), pause while player is not prepared, pause delay";
+ delayed_player_state_ = PLAYER_STATE_DELAYED_PAUSE;
+ return;
+ }
+ MediaPlayerBridgeCapi::Pause(is_media_related_action);
+}
+
void MediaPlayerBridgeCapiTV::PlaybackCompleteUpdate() {
MediaPlayerBridgeCapi::PlaybackCompleteUpdate();
if (GetMediaPlayerClient())
} // namespace media
void MediaPlayerBridgeCapiTV::PlayerPrepared() {
+ player_prepared_ = true;
MediaPlayerBridgeCapi::PlayerPrepared();
+ int canSeek = 0;
+ int retVal = player_seek_available(player_, &canSeek);
+ if (retVal == PLAYER_ERROR_NONE && !canSeek)
+ is_player_seek_available_ = false;
+
GetAdaptiveStreamingInfo();
- if (/*!blink::IsHbbTV() && */is_live_stream_) {
+ if (!blink::IsHbbTV() && is_live_stream_) {
UpdateSeekableTime();
StartSeekableTimeUpdateTimer();
}
type);
}
+bool MediaPlayerBridgeCapiTV::PreloadIfNeeded(int& ret) {
+ LOG(INFO) << "PreloadIfNeeded, is_preloaded_ " << is_preloaded_;
+ if (blink::IsHbbTV() && !is_preloaded_) {
+ ret = player_preloading_async(player_, -1, PlayerPreLoadingCb, this);
+ return true;
+ }
+
+ // fixup : kPlaybackReady status need checked by HBBTVResourceAcquired() patch
+ if (GetMediaPlayerClient())
+ GetMediaPlayerClient()->NotifyPlaybackState(kPlaybackReady, player_id_);
+ else
+ LOG(ERROR) << "(" << static_cast<void*>(this)
+ << "), GetMediaPlayerClient return null";
+ SetDisplayAtPausedState();
+ return false;
+}
+
+void MediaPlayerBridgeCapiTV::SetDisplayAtPausedState() {
+ int ret = PLAYER_ERROR_NONE;
+ if (!pending_seek_duration_.is_zero())
+ ret = player_display_video_at_paused_state(player_, false);
+ else
+ ret = player_display_video_at_paused_state(player_, true);
+
+ if (ret != PLAYER_ERROR_NONE)
+ LOG(ERROR) << "player_display_video_at_paused_state() failed";
+}
+
+void MediaPlayerBridgeCapiTV::UpdateDuration() {
+ LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
+ if (blink::IsHbbTV() && !is_preloaded_) {
+ LOG(INFO) << "HBBTV preload not finished, no need update duration. ";
+ return;
+ }
+ MediaPlayerBridgeCapi::UpdateDuration();
+}
+
+void MediaPlayerBridgeCapiTV::UpdateMediaType() {
+ LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
+
+ if (blink::IsHbbTV() && !is_preloaded_) {
+ LOG(INFO) << "HBBTV preload not finished, no need update media type. ";
+ return;
+ }
+ MediaPlayerBridgeCapi::UpdateMediaType();
+}
+
+bool MediaPlayerBridgeCapiTV::CheckLiveStreaming() const {
+ int isLive = 0;
+ int retVal = player_get_adaptive_streaming_info(player_, &isLive,
+ PLAYER_ADAPTIVE_INFO_IS_LIVE);
+ if (retVal != PLAYER_ERROR_NONE) {
+ LOG(ERROR) << "player_get_adaptive_streaming_info failed, error: "
+ << retVal;
+ return false;
+ }
+
+ if (!isLive)
+ return false;
+
+ LOG(INFO) << "This is a live streaming.";
+ return true;
+}
+
+void MediaPlayerBridgeCapiTV::OnPlayerPreloading() {
+ task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&MediaPlayerBridgeCapiTV::PlayerPreloaded,
+ weak_factory_.GetWeakPtr()));
+}
+
+bool MediaPlayerBridgeCapiTV::HBBTVResourceAcquired() {
+ bool media_resource_acquired = false;
+ if (!GetMediaPlayerClient()) {
+ LOG(ERROR) << "MediaPlayerTizenClient is nullptr";
+ return false;
+ }
+
+ GetMediaPlayerClient()->NotifyPlaybackState(
+ kPlaybackReady, player_id_, url_.spec(), mime_type_,
+ &media_resource_acquired, NULL, NULL);
+ if (!media_resource_acquired) {
+ GetMediaPlayerClient()->NotifyPlaybackState(kPlaybackStop, player_id_);
+ LOG(ERROR) << "HBBTV media resource acquired failed";
+ }
+ return media_resource_acquired;
+}
+
+void MediaPlayerBridgeCapiTV::PlayerPreloaded() {
+ LOG(INFO) << "PlayerPreloaded,this: " << this
+ << ",player_prepared_:" << player_prepared_;
+
+ is_preloaded_ = true;
+ is_live_stream_ = CheckLiveStreaming();
+ // if (stream_type_ == DASH_STREAM)
+ // ParseDashInfo();
+ if (is_live_stream_ && stream_type_ != OTHER_STREAM) {
+ // UpdateSeekableTime();
+ // StartSeekableTimeUpdateTimer();
+ }
+ // UpdateAudioTrackInfo();
+ // UpdateVideoTrackInfo();
+ // UpdateTextTrackInfo();
+ UpdateDuration();
+ UpdateMediaType();
+ if (GetMediaType() == MediaType::Invalid) {
+ LOG(ERROR) << "Media type is not valid!";
+ return;
+ }
+
+ OnReadyStateChange(player_id_,
+ blink::WebMediaPlayer::kReadyStateHaveFutureData);
+ OnNetworkStateChange(player_id_, blink::WebMediaPlayer::kNetworkStateLoading);
+
+ if (!player_prepared_ && HBBTVResourceAcquired()) {
+ int ret = SetPlayerPrepareAsync();
+ if (ret != PLAYER_ERROR_NONE) {
+ OnHandlePlayerError(ret, FROM_HERE);
+ }
+ }
+}
+
+bool MediaPlayerBridgeCapiTV::PlayerPrePlay() {
+ LOG(INFO) << "PlayerPrePlay, this: " << this
+ << ",is_player_prepared : " << player_prepared_;
+ if (IsPlayerSuspended()) {
+ LOG(INFO) << "PlayerPrePlay while player is suspended";
+ return false;
+ }
+
+ if (!HBBTVResourceAcquired()) {
+ LOG(INFO)
+ << "PlayerPrePlay while it's not in case of HBBTV Resource Acquired";
+ return false;
+ }
+
+ delayed_player_state_ = PLAYER_STATE_DELAYED_PLAY;
+ LOG(INFO) << "begin to |player_prepare_async|";
+
+ SetDisplayAtPausedState();
+ int ret = SetPlayerPrepareAsync();
+ if (ret != PLAYER_ERROR_NONE) {
+ OnHandlePlayerError(ret, FROM_HERE);
+ return false;
+ }
+
+ return true;
+}
void MediaPlayerBridgeCapiTV::Initialize(VideoRendererSink* sink) {
player_set_drm_error_cb(player_, DrmErrorCb, this);
MediaPlayerBridgeCapi::Initialize(sink);