Provide fine grained media playback time thru interpolation

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 #include "content/renderer/media/crypto/key_systems.h"
 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
 #include "content/renderer/media/webcontentdecryptionmodule_impl.h"
 #include "content/renderer/media/webmediaplayer_delegate.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
+#include "media/base/android/media_common_android.h"
 #include "media/base/android/media_player_android.h"
 #include "media/base/bind_to_current_loop.h"
 // TODO(xhwang): Remove when we remove prefixed EME implementation.
 #include "media/base/media_keys.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
@@ skipping 89 matching lines @@
       stream_id_(0),
       is_playing_(false),
       needs_establish_peer_(true),
       stream_texture_proxy_initialized_(false),
       has_size_info_(false),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
       pending_playback_(false),
       player_type_(MEDIA_PLAYER_TYPE_URL),
-      current_time_(0),
       is_remote_(false),
       media_log_(media_log),
       web_cdm_(NULL),
       allow_stored_credentials_(false),
       is_local_resource_(false),
+      interpolator_(&default_tick_clock_),
       weak_factory_(this) {
   DCHECK(player_manager_);
   DCHECK(cdm_manager_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   player_id_ = player_manager_->RegisterMediaPlayer(this);
 
 #if defined(VIDEO_HOLE)
   force_use_overlay_embedded_video_ = CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kForceUseOverlayEmbeddedVideo);
   if (force_use_overlay_embedded_video_ ||
     player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo()) {
     // Defer stream texture creation until we are sure it's necessary.
     needs_establish_peer_ = false;
     current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
   }
 #endif  // defined(VIDEO_HOLE)
   TryCreateStreamTextureProxyIfNeeded();
+  interpolator_.SetUpperBound(base::TimeDelta());

[scherkus (not reviewing), 2014/09/05 20:12:57]

is this needed? the docs and code make it look like we'll return 0 after being
created:

https://code.google.com/p/chromium/codesearch#chromium/src/media/base/time_de...

[qinmin, 2014/09/05 21:32:19]

It will return 0 only if interpolator_.StartInterpolating() is not called.
if we don't do this here, the interpolator_ will starts to return non-zero
values when user hit the play button. However, the browser side mediaplayer may
take several seconds to start rendering data. And when the first OnTimeUpdate
msg came, we may already run too far ahead.


On 2014/09/05 20:12:57, scherkus wrote:

 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   SetVideoFrameProviderClient(NULL);
   client_->setWebLayer(NULL);
 
   if (player_manager_) {
     player_manager_->DestroyPlayer(player_id_);
     player_manager_->UnregisterMediaPlayer(player_id_);
@@ skipping 276 matching lines @@
 
 double WebMediaPlayerAndroid::currentTime() const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // If the player is processing a seek, return the seek time.
   // Blink may still query us if updatePlaybackState() occurs while seeking.
   if (seeking()) {
     return pending_seek_ ?
         pending_seek_time_.InSecondsF() : seek_time_.InSecondsF();
   }
 
-  return current_time_;
+  return std::min(
+      (const_cast<media::TimeDeltaInterpolator*>(
+          &interpolator_))->GetInterpolatedTime(), duration_).InSecondsF();
 }
 
 WebSize WebMediaPlayerAndroid::naturalSize() const {
   return natural_size_;
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerAndroid::networkState() const {
   return network_state_;
 }
 
@@ skipping 262 matching lines @@
 
   if (need_to_signal_duration_changed)
     client_->durationChanged();
 }
 
 void WebMediaPlayerAndroid::OnPlaybackComplete() {
   // When playback is about to finish, android media player often stops
   // at a time which is smaller than the duration. This makes webkit never
   // know that the playback has finished. To solve this, we set the
   // current time to media duration when OnPlaybackComplete() get called.
-  OnTimeUpdate(duration_);
+  interpolator_.SetBounds(duration_, duration_);
+  interpolator_.StopInterpolating();
   client_->timeChanged();
 
   // if the loop attribute is set, timeChanged() will update the current time
   // to 0. It will perform a seek to 0. As the requests to the renderer
   // process are sequential, the OnSeekComplete() will only occur
   // once OnPlaybackComplete() is done. As the playback can only be executed
   // upon completion of OnSeekComplete(), the request needs to be saved.
   is_playing_ = false;
   if (seeking_ && seek_time_ == base::TimeDelta())
     pending_playback_ = true;
@@ skipping 11 matching lines @@
 
 void WebMediaPlayerAndroid::OnSeekComplete(
     const base::TimeDelta& current_time) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_time_.InSecondsF());
     return;
   }
-
-  OnTimeUpdate(current_time);
+  interpolator_.SetBounds(current_time, current_time);
 
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
   client_->timeChanged();
 
   if (pending_playback_) {
     play();
     pending_playback_ = false;
   }
 }
@@ skipping 63 matching lines @@
         cc::VideoLayer::Create(this, media::VIDEO_ROTATION_0)));
     client_->setWebLayer(video_weblayer_.get());
   }
 
   // TODO(qinmin): This is a hack. We need the media element to stop showing the
   // poster image by forcing it to call setDisplayMode(video). Should move the
   // logic into HTMLMediaElement.cpp.
   client_->timeChanged();
 }
 
-void WebMediaPlayerAndroid::OnTimeUpdate(const base::TimeDelta& current_time) {
+void WebMediaPlayerAndroid::OnTimeUpdate(base::TimeDelta current_timestamp,
+                                         base::TimeTicks current_time_ticks) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  current_time_ = current_time.InSecondsF();
-  if (is_local_resource_ && current_time_ <= duration())
-    buffered_[0].end = current_time_;
+  // Compensate the current_timestamp with the IPC latency.
+  base::TimeDelta lower_bound =
+      base::TimeTicks::Now() - current_time_ticks + current_timestamp;
+  base::TimeDelta upper_bound = lower_bound;
+  // We should get another time update in about |kTimeUpdateInterval|
+  // milliseconds.
+  if (is_playing_) {
+    upper_bound += base::TimeDelta::FromMilliseconds(
+        media::kTimeUpdateInterval);
+  }
+  // if the lower_bound is smaller than the current time, just use the current
+  // time so that the timer is always progressing.
+  lower_bound =
+      std::min(lower_bound, base::TimeDelta::FromSecondsD(currentTime()));
+  interpolator_.SetBounds(lower_bound, upper_bound);
+  if (is_local_resource_ && current_timestamp <= duration_)
+    buffered_[0].end = current_timestamp.InSecondsF();

[scherkus (not reviewing), 2014/09/05 20:12:57]

it looks like this code was added in https://codereview.chromium.org/496683002
but I'm confused as to what it's supposed to be doing

if it's a local resource, buffered_[0].end should be equal to duration_ because
we should have the entire resource buffered...

[qinmin, 2014/09/05 21:32:19]

Moved this to OnMediaMetadataChanged(), feels wierd that the buffered content is
already the played content for local resources.

 }
 
 void WebMediaPlayerAndroid::OnConnectedToRemoteDevice(
     const std::string& remote_playback_message) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!media_source_delegate_);
   DrawRemotePlaybackText(remote_playback_message);
   is_remote_ = true;
   SetNeedsEstablishPeer(false);
 }
@@ skipping 397 matching lines @@
 void WebMediaPlayerAndroid::SetNeedsEstablishPeer(bool needs_establish_peer) {
   needs_establish_peer_ = needs_establish_peer;
 }
 
 void WebMediaPlayerAndroid::setPoster(const blink::WebURL& poster) {
   player_manager_->SetPoster(player_id_, poster);
 }
 
 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
   is_playing_ = is_playing;
   if (!delegate_)

[scherkus (not reviewing), 2014/09/05 20:12:57]

when do we not have a delegate?

if we don't have one, won't |interpolator_| go out of sync with |is_playing_|?

[qinmin, 2014/09/05 21:32:19]

If there is no delegate, then the WMPA instance is going away soon since the
delegate is the renderFrameImpl.
But logically we should start/stop the interpolator regardless of the
|delegate_|. Fixed.

On 2014/09/05 20:12:57, scherkus wrote:

     return;
-  if (is_playing)
+  if (is_playing) {
     delegate_->DidPlay(this);
-  else
+    interpolator_.StartInterpolating();
+  } else {
     delegate_->DidPause(this);
+    interpolator_.StopInterpolating();
+  }
 }
 
 #if defined(VIDEO_HOLE)
 bool WebMediaPlayerAndroid::UpdateBoundaryRectangle() {
   if (!video_weblayer_)
     return false;
 
   // Compute the geometry of video frame layer.
   cc::Layer* layer = video_weblayer_->layer();
   gfx::RectF rect(layer->bounds());
@@ skipping 460 matching lines @@
 
 bool WebMediaPlayerAndroid::IsHLSStream() const {
   std::string mime;
   GURL url = redirected_url_.is_empty() ? url_ : redirected_url_;
   if (!net::GetMimeTypeFromFile(base::FilePath(url.path()), &mime))
     return false;
   return !mime.compare("application/x-mpegurl");
 }
 
 }  // namespace content