wall_clock_time_source.cc 3.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101
  1. // Copyright 2014 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. #include "media/base/wall_clock_time_source.h"
  5. #include "base/logging.h"
  6. namespace media {
  7. WallClockTimeSource::WallClockTimeSource()
  8. : tick_clock_(base::DefaultTickClock::GetInstance()),
  9. ticking_(false),
  10. playback_rate_(1.0) {}
  11. WallClockTimeSource::~WallClockTimeSource() = default;
  12. void WallClockTimeSource::StartTicking() {
  13. DVLOG(1) << __func__;
  14. base::AutoLock auto_lock(lock_);
  15. DCHECK(!ticking_);
  16. ticking_ = true;
  17. reference_time_ = tick_clock_->NowTicks();
  18. }
  19. void WallClockTimeSource::StopTicking() {
  20. DVLOG(1) << __func__;
  21. base::AutoLock auto_lock(lock_);
  22. DCHECK(ticking_);
  23. base_timestamp_ = CurrentMediaTime_Locked();
  24. ticking_ = false;
  25. reference_time_ = tick_clock_->NowTicks();
  26. }
  27. void WallClockTimeSource::SetPlaybackRate(double playback_rate) {
  28. DVLOG(1) << __func__ << "(" << playback_rate << ")";
  29. base::AutoLock auto_lock(lock_);
  30. // Estimate current media time using old rate to use as a new base time for
  31. // the new rate.
  32. if (ticking_) {
  33. base_timestamp_ = CurrentMediaTime_Locked();
  34. reference_time_ = tick_clock_->NowTicks();
  35. }
  36. playback_rate_ = playback_rate;
  37. }
  38. void WallClockTimeSource::SetMediaTime(base::TimeDelta time) {
  39. DVLOG(1) << __func__ << "(" << time.InMicroseconds() << ")";
  40. base::AutoLock auto_lock(lock_);
  41. CHECK(!ticking_);
  42. base_timestamp_ = time;
  43. reference_time_ = base::TimeTicks();
  44. }
  45. base::TimeDelta WallClockTimeSource::CurrentMediaTime() {
  46. base::AutoLock auto_lock(lock_);
  47. return CurrentMediaTime_Locked();
  48. }
  49. bool WallClockTimeSource::GetWallClockTimes(
  50. const std::vector<base::TimeDelta>& media_timestamps,
  51. std::vector<base::TimeTicks>* wall_clock_times) {
  52. base::AutoLock auto_lock(lock_);
  53. DCHECK(wall_clock_times->empty());
  54. if (media_timestamps.empty()) {
  55. wall_clock_times->push_back(reference_time_);
  56. } else {
  57. // When playback is paused (rate is zero), assume a rate of 1.0.
  58. const double playback_rate = playback_rate_ ? playback_rate_ : 1.0;
  59. wall_clock_times->reserve(media_timestamps.size());
  60. for (const auto& media_timestamp : media_timestamps) {
  61. wall_clock_times->push_back(reference_time_ +
  62. (media_timestamp - base_timestamp_) /
  63. playback_rate);
  64. }
  65. }
  66. return playback_rate_ && ticking_;
  67. }
  68. void WallClockTimeSource::SetTickClockForTesting(
  69. const base::TickClock* tick_clock) {
  70. base::AutoLock auto_lock(lock_);
  71. tick_clock_ = tick_clock;
  72. }
  73. base::TimeDelta WallClockTimeSource::CurrentMediaTime_Locked() {
  74. lock_.AssertAcquired();
  75. if (!ticking_ || !playback_rate_)
  76. return base_timestamp_;
  77. base::TimeTicks now = tick_clock_->NowTicks();
  78. return base_timestamp_ +
  79. base::Microseconds((now - reference_time_).InMicroseconds() *
  80. playback_rate_);
  81. }
  82. } // namespace media