Support live streams (ie big timestamps), replace float with double

cobalt/dom/html_media_element.cc

@@ -138,7 +138,7 @@
       ready_state_(WebMediaPlayer::kReadyStateHaveNothing),
       ready_state_maximum_(WebMediaPlayer::kReadyStateHaveNothing),
       volume_(1.0f),
-      last_seek_time_(0),
+      last_seek_time_(0.0),
       previous_progress_time_(std::numeric_limits<double>::max()),
       duration_(std::numeric_limits<double>::quiet_NaN()),
       playing_(false),
@@ -149,7 +149,7 @@
       resume_frozen_flag_(false),
       seeking_(false),
       controls_(false),
-      last_time_update_event_movie_time_(std::numeric_limits<float>::max()),
+      last_time_update_event_movie_time_(std::numeric_limits<double>::max()),
       processing_media_player_callback_(0),
       media_source_url_(std::string(kMediaSourceUrlProtocol) + ':' +
                         base::GenerateGUID()),
@@ -222,7 +222,7 @@
   }
 
   player_->UpdateBufferedTimeRanges(
-      [&](float start, float end) { buffered->Add(start, end); });
+      [&](double start, double end) { buffered->Add(start, end); });
   return buffered;
 }
 
@@ -344,27 +344,26 @@
   return seeking_;
 }
 
-float HTMLMediaElement::current_time(
+double HTMLMediaElement::current_time(
     script::ExceptionState* exception_state) const {
   if (!player_) {
     LOG(INFO) << 0 << " (because player is NULL)";
-    return 0;
+    return 0.0;
   }
 
   if (seeking_) {
     MLOG() << last_seek_time_ << " (seeking)";
     return last_seek_time_;
   }
 
-  float time = player_->GetCurrentTime();
+  const double time = player_->GetCurrentTime();
   MLOG() << time << " (from player)";
   return time;
 }
 
 void HTMLMediaElement::set_current_time(
-    float time, script::ExceptionState* exception_state) {
+    double time, script::ExceptionState* exception_state) {
   // 4.8.9.9 Seeking
-
   // 1 - If the media element's readyState is
   // WebMediaPlayer::kReadyStateHaveNothing, then raise an INVALID_STATE_ERR
   // exception.
@@ -377,10 +376,9 @@
   Seek(time);
 }
 
-float HTMLMediaElement::duration() const {
+double HTMLMediaElement::duration() const {
   MLOG() << duration_;
-  // TODO: Turn duration into double.
-  return static_cast<float>(duration_);
+  return duration_;
 }
 
 base::Time HTMLMediaElement::GetStartDate() const {
@@ -433,7 +431,7 @@
 const scoped_refptr<TimeRanges>& HTMLMediaElement::played() {
   MLOG();
   if (playing_) {
-    float time = current_time(NULL);
+    const double time = current_time(NULL);
     if (time > last_seek_time_) {
       AddPlayedRange(last_seek_time_, time);
     }
@@ -447,8 +445,8 @@
 }
 
 scoped_refptr<TimeRanges> HTMLMediaElement::seekable() const {
-  if (player_ && player_->GetMaxTimeSeekable() != 0) {
-    double max_time_seekable = player_->GetMaxTimeSeekable();
+  if (player_ && player_->GetMaxTimeSeekable() != 0.0) {
+    const double max_time_seekable = player_->GetMaxTimeSeekable();
     MLOG() << "(0, " << max_time_seekable << ")";
     return new TimeRanges(0, max_time_seekable);
   }
@@ -632,7 +630,7 @@
   ScheduleOwnEvent(base::Tokens::durationchange());
 
   if (request_seek) {
-    Seek(static_cast<float>(duration));
+    Seek(duration);
   }
 }
 
@@ -775,7 +773,7 @@
 
   // 2 - Asynchronously await a stable state.
   played_time_ranges_ = new TimeRanges;
-  last_seek_time_ = 0;
+  last_seek_time_ = 0.0;
 
   ConfigureMediaControls();
 }
@@ -1019,8 +1017,8 @@
     return;
   }
 
-  double time = base::Time::Now().ToDoubleT();
-  double time_delta = time - previous_progress_time_;
+  const double time = base::Time::Now().ToDoubleT();
+  const double time_delta = time - previous_progress_time_;
 
   if (player_->DidLoadingProgress()) {
     ScheduleOwnEvent(base::Tokens::progress());
@@ -1082,7 +1080,7 @@
 void HTMLMediaElement::ScheduleTimeupdateEvent(bool periodic_event) {
   // Some media engines make multiple "time changed" callbacks at the same time,
   // but we only want one event at a given time so filter here
-  float movie_time = current_time(NULL);
+  const double movie_time = current_time(NULL);
   if (movie_time != last_time_update_event_movie_time_) {
     if (!periodic_event && playback_progress_timer_.IsRunning()) {
       playback_progress_timer_.Reset();
@@ -1268,7 +1266,7 @@
   network_state_ = kNetworkIdle;
 }
 
-void HTMLMediaElement::Seek(float time) {
+void HTMLMediaElement::Seek(double time) {
   LOG(INFO) << "Seek to " << time << ".";
   // 4.8.9.9 Seeking - continued from set_current_time().
 
@@ -1279,7 +1277,7 @@
 
   // Get the current time before setting seeking_, last_seek_time_ is returned
   // once it is set.
-  float now = current_time(NULL);
+  const double now = current_time(NULL);
 
   // 2 - If the element's seeking IDL attribute is true, then another instance
   // of this algorithm is already running. Abort that other instance of the
@@ -1297,7 +1295,7 @@
 
   // 6 - If the new playback position is less than the earliest possible
   // position, let it be that position instead.
-  time = std::max(time, 0.f);
+  time = std::max(time, 0.0);
 
   // 7 - If the (possibly now changed) new playback position is not in one of
   // the ranges given in the seekable attribute, then let it be the position in
@@ -1329,7 +1327,7 @@
     seeking_ = false;
     return;
   }
-  time = static_cast<float>(seekable_ranges->Nearest(time));
+  time = seekable_ranges->Nearest(time);
 
   if (playing_) {
     if (last_seek_time_ < now) {
@@ -1361,7 +1359,7 @@
   ScheduleOwnEvent(base::Tokens::seeked());
 }
 
-void HTMLMediaElement::AddPlayedRange(float start, float end) {
+void HTMLMediaElement::AddPlayedRange(double start, double end) {
   if (!played_time_ranges_) {
     played_time_ranges_ = new TimeRanges;
   }
@@ -1411,7 +1409,7 @@
 
     playback_progress_timer_.Stop();
     playing_ = false;
-    float time = current_time(NULL);
+    const double time = current_time(NULL);
     if (time > last_seek_time_) {
       AddPlayedRange(last_seek_time_, time);
     }
@@ -1431,7 +1429,7 @@
 }
 
 bool HTMLMediaElement::EndedPlayback() const {
-  float dur = duration();
+  const double dur = duration();
   if (!player_ || std::isnan(dur)) {
     return false;
   }
@@ -1448,15 +1446,15 @@
   // direction of playback is forwards, Either the media element does not have a
   // loop attribute specified, or the media element has a current media
   // controller.
-  float now = current_time(NULL);
-  if (playback_rate_ > 0) {
-    return dur > 0 && now >= dur && !loop();
+  const double now = current_time(NULL);
+  if (playback_rate_ > 0.f) {
+    return dur > 0.0 && now >= dur && !loop();
   }
 
   // or the current playback position is the earliest possible position and the
   // direction of playback is backwards
-  if (playback_rate_ < 0) {
-    return now <= 0;
+  if (playback_rate_ < 0.f) {
+    return now <= 0.0;
   }
 
   return false;
@@ -1557,14 +1555,14 @@
   // already posted one at the current movie time.
   ScheduleTimeupdateEvent(false);
 
-  float now = current_time(NULL);
-  float dur = duration();
+  const double now = current_time(NULL);
+  const double dur = duration();
 
   // When the current playback position reaches the end of the media resource
   // when the direction of playback is forwards, then the user agent must follow
   // these steps:
   eos_played |=
-      !std::isnan(dur) && (0.0f != dur) && now >= dur && playback_rate_ > 0;
+      !std::isnan(dur) && (0.0 != dur) && now >= dur && playback_rate_ > 0.f;
   if (eos_played) {
     LOG(INFO) << "End of stream is played.";
     // If the media element has a loop attribute specified and does not have a
@@ -1573,7 +1571,7 @@
       sent_end_event_ = false;
       // then seek to the earliest possible position of the media resource and
       // abort these steps.
-      Seek(0);
+      Seek(0.0);
     } else {
       // If the media element does not have a current media controller, and the
       // media element has still ended playback, and the direction of playback
@@ -1603,15 +1601,15 @@
 
   ScheduleOwnEvent(base::Tokens::durationchange());
 
-  double now = current_time(NULL);
+  const double now = current_time(NULL);
   // Reset and update |duration_|.
   duration_ = std::numeric_limits<double>::quiet_NaN();
   if (player_ && ready_state_ >= WebMediaPlayer::kReadyStateHaveMetadata) {
     duration_ = player_->GetDuration();
   }
 
   if (now > duration_) {
-    Seek(static_cast<float>(duration_));
+    Seek(duration_);
   }
 
   EndProcessingMediaPlayerCallback();

cobalt/dom/html_media_element.h

@@ -105,9 +105,9 @@ class HTMLMediaElement : public HTMLElement,
   bool seeking() const;
 
   // Playback state
-  float current_time(script::ExceptionState* exception_state) const;
-  void set_current_time(float time, script::ExceptionState* exception_state);
-  float duration() const;
+  double current_time(script::ExceptionState* exception_state) const;
+  void set_current_time(double time, script::ExceptionState* exception_state);
+  double duration() const;
   base::Time GetStartDate() const;
   bool paused() const;
   bool resume_frozen_flag() const;
@@ -210,10 +210,10 @@ class HTMLMediaElement : public HTMLElement,
   void ChangeNetworkStateFromLoadingToIdle();
 
   // Playback
-  void Seek(float time);
+  void Seek(double time);
   void FinishSeek();
 
-  void AddPlayedRange(float start, float end);
+  void AddPlayedRange(double start, double end);
 
   void UpdateVolume();
   void UpdatePlayState();
@@ -269,7 +269,7 @@ class HTMLMediaElement : public HTMLElement,
   WebMediaPlayer::ReadyState ready_state_maximum_;
 
   float volume_;
-  float last_seek_time_;
+  double last_seek_time_;
   double previous_progress_time_;
 
   double duration_;

cobalt/media/player/web_media_player.h

@@ -41,7 +41,7 @@ class WebMediaPlayer {
   // Return true if the punch through box should be rendered.  Return false if
   // no punch through box should be rendered.
   typedef base::Callback<bool(int x, int y, int width, int height)> SetBoundsCB;
-  typedef std::function<void(float start, float end)> AddRangeCB;
+  typedef std::function<void(double start, double end)> AddRangeCB;
 
   enum NetworkState {
     kNetworkStateEmpty,
@@ -109,12 +109,12 @@ class WebMediaPlayer {
   // Playback controls.
   virtual void Play() = 0;
   virtual void Pause() = 0;
-  virtual void Seek(float seconds) = 0;
+  virtual void Seek(double seconds) = 0;
   virtual void SetRate(float rate) = 0;
   virtual void SetVolume(float volume) = 0;
   virtual void SetVisible(bool visible) = 0;
   virtual void UpdateBufferedTimeRanges(const AddRangeCB& add_range_cb) = 0;
-  virtual float GetMaxTimeSeekable() const = 0;
+  virtual double GetMaxTimeSeekable() const = 0;
 
   // Suspend/Resume
   virtual void Suspend() = 0;
@@ -136,11 +136,11 @@ class WebMediaPlayer {
   // Getters of playback state.
   virtual bool IsPaused() const = 0;
   virtual bool IsSeeking() const = 0;
-  virtual float GetDuration() const = 0;
+  virtual double GetDuration() const = 0;
 #if SB_HAS(PLAYER_WITH_URL)
   virtual base::Time GetStartDate() const = 0;
 #endif  // SB_HAS(PLAYER_WITH_URL)
-  virtual float GetCurrentTime() const = 0;
+  virtual double GetCurrentTime() const = 0;
   virtual float GetPlaybackRate() const = 0;
 
   // Get rate of loading the resource.
@@ -152,7 +152,7 @@ class WebMediaPlayer {
 
   virtual bool DidLoadingProgress() const = 0;
 
-  virtual float MediaTimeForTimeValue(float timeValue) const = 0;
+  virtual double MediaTimeForTimeValue(double timeValue) const = 0;
 
   virtual PlayerStatistics GetStatistics() const = 0;