media/base/clock.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/base/clock.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "base/time/tick_clock.h"
  11 #include "media/base/buffers.h"
  12
  13 namespace media {
  14
  15 Clock::Clock(base::TickClock* clock)
  16     : clock_(clock),
  17       playing_(false),
  18       underflow_(false),
  19       playback_rate_(1.0f),
  20       max_time_(kNoTimestamp()),
  21       duration_(kNoTimestamp()) {
  22   DCHECK(clock_);
  23 }
  24
  25 Clock::~Clock() {}
  26
  27 bool Clock::IsPlaying() const {
  28   return playing_;
  29 }
  30
  31 base::TimeDelta Clock::Play() {
  32   DCHECK(!playing_);
  33   UpdateReferencePoints();
  34   playing_ = true;
  35   return media_time_;
  36 }
  37
  38 base::TimeDelta Clock::Pause() {
  39   DCHECK(playing_);
  40   UpdateReferencePoints();
  41   playing_ = false;
  42   return media_time_;
  43 }
  44
  45 void Clock::SetPlaybackRate(float playback_rate) {
  46   UpdateReferencePoints();
  47   playback_rate_ = playback_rate;
  48 }
  49
  50 void Clock::SetTime(base::TimeDelta current_time, base::TimeDelta max_time) {
  51   DCHECK(current_time <= max_time);
  52   DCHECK(current_time != kNoTimestamp());
  53
  54   UpdateReferencePoints(current_time);
  55   max_time_ = ClampToValidTimeRange(max_time);
  56   underflow_ = false;
  57 }
  58
  59 base::TimeDelta Clock::Elapsed() {
  60   if (duration_ == kNoTimestamp())
  61     return base::TimeDelta();
  62
  63   // The clock is not advancing, so return the last recorded time.
  64   if (!playing_ || underflow_)
  65     return media_time_;
  66
  67   base::TimeDelta elapsed = EstimatedElapsedTime();
  68   if (max_time_ != kNoTimestamp() && elapsed > max_time_) {
  69     UpdateReferencePoints(max_time_);
  70     underflow_ = true;
  71     elapsed = max_time_;
  72   }
  73
  74   return elapsed;
  75 }
  76
  77 void Clock::SetMaxTime(base::TimeDelta max_time) {
  78   DCHECK(max_time != kNoTimestamp());
  79
  80   UpdateReferencePoints();
  81   max_time_ = ClampToValidTimeRange(max_time);
  82
  83   underflow_ = media_time_ > max_time_;
  84   if (underflow_)
  85     media_time_ = max_time_;
  86 }
  87
  88 void Clock::SetDuration(base::TimeDelta duration) {
  89   DCHECK(duration > base::TimeDelta());
  90   duration_ = duration;
  91
  92   media_time_ = ClampToValidTimeRange(media_time_);
  93   if (max_time_ != kNoTimestamp())
  94     max_time_ = ClampToValidTimeRange(max_time_);
  95 }
  96
  97 base::TimeDelta Clock::ElapsedViaProvidedTime(
  98     const base::TimeTicks& time) const {
  99   // TODO(scherkus): floating point badness scaling time by playback rate.
 100   int64 now_us = (time - reference_).InMicroseconds();
 101   now_us = static_cast<int64>(now_us * playback_rate_);
 102   return media_time_ + base::TimeDelta::FromMicroseconds(now_us);
 103 }
 104
 105 base::TimeDelta Clock::ClampToValidTimeRange(base::TimeDelta time) const {
 106   if (duration_ == kNoTimestamp())
 107     return base::TimeDelta();
 108   return std::max(std::min(time, duration_), base::TimeDelta());
 109 }
 110
 111 base::TimeDelta Clock::Duration() const {
 112   if (duration_ == kNoTimestamp())
 113     return base::TimeDelta();
 114   return duration_;
 115 }
 116
 117 void Clock::UpdateReferencePoints() {
 118   UpdateReferencePoints(Elapsed());
 119 }
 120
 121 void Clock::UpdateReferencePoints(base::TimeDelta current_time) {
 122   media_time_ = ClampToValidTimeRange(current_time);
 123   reference_ = clock_->NowTicks();
 124 }
 125
 126 base::TimeDelta Clock::EstimatedElapsedTime() {
 127   return ClampToValidTimeRange(ElapsedViaProvidedTime(clock_->NowTicks()));
 128 }
 129
 130 }  // namespace media