Motown: Use new TimelineTransform and related definitions

services/media/audio/audio_track_impl.cc

 // Copyright 2015 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 <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "mojo/services/media/common/cpp/linear_transform.h"
+#include "mojo/services/media/common/cpp/timeline.h"
 #include "services/media/audio/audio_output_manager.h"
 #include "services/media/audio/audio_server_impl.h"
 #include "services/media/audio/audio_track_impl.h"
 #include "services/media/audio/audio_track_to_output_link.h"
 
 namespace mojo {
 namespace media {
 namespace audio {
 
 constexpr size_t AudioTrackImpl::PTS_FRACTIONAL_BITS;
@@ skipping 45 matching lines @@
   AudioTrackImplPtr ret(new AudioTrackImpl(iface.Pass(), owner));
   ret->weak_this_ = ret;
   return ret;
 }
 
 void AudioTrackImpl::Shutdown() {
   // If we are unbound, then we have already been shut down and are just waiting
   // for the service to destroy us.  Run some DCHECK sanity checks and get out.
   if (!binding_.is_bound()) {
     DCHECK(!pipe_.IsInitialized());
-    DCHECK(!rate_control_.is_bound());
+    DCHECK(!timeline_control_site_.is_bound());
     DCHECK(!outputs_.size());
     return;
   }
 
   // Close the connection to our client
   binding_.set_connection_error_handler(mojo::Closure());
   binding_.Close();
 
   // reset all of our internal state and close any other client connections in
   // the process.
   pipe_.Reset();
-  rate_control_.Reset();
+  timeline_control_site_.Reset();
   outputs_.clear();
 
   DCHECK(owner_);
   AudioTrackImplPtr thiz = weak_this_.lock();
   owner_->RemoveTrack(thiz);
 }
 
 void AudioTrackImpl::Describe(const DescribeCallback& cbk) {
   // Build a minimal descriptor
   //
@@ skipping 88 matching lines @@
       static_cast<uint32_t>(configuration->audio_frame_ratio);
   uint32_t denominator =
       static_cast<uint32_t>(configuration->media_time_ratio);
   if ((numerator < 1) || (denominator < 1)) {
     LOG(ERROR) << "Invalid (audio frames:media time ticks) ratio ("
                << numerator << "/" << denominator << ")";
     Shutdown();
     return;
   }
 
+  frames_per_ns_ =
+      TimelineRate(cfg->frames_per_second, Timeline::ns_from_seconds(1));
 
   // Figure out the rate we need to scale by in order to produce our fixed
   // point timestamps.
   LinearTransform::Ratio frac_scale(1 << PTS_FRACTIONAL_BITS, 1);
   LinearTransform::Ratio frame_scale(LinearTransform::Ratio(numerator,
                                                             denominator));
   bool no_loss = LinearTransform::Ratio::Compose(frac_scale,
                                                  frame_scale,
                                                  &frame_to_media_ratio_);
   if (!no_loss) {
@@ skipping 49 matching lines @@
   // implementations, and scheduling a job to recalculate the properties for the
   // dirty tracks and notify the users as appropriate.
 
   // If we cannot promote our own weak pointer, something is seriously wrong.
   AudioTrackImplPtr strong_this(weak_this_.lock());
   DCHECK(strong_this);
   DCHECK(owner_);
   owner_->GetOutputManager().SelectOutputsForTrack(strong_this);
 }
 
-void AudioTrackImpl::GetRateControl(InterfaceRequest<RateControl> req) {
-  if (!rate_control_.Bind(req.Pass())) {
-    Shutdown();
-  }
+void AudioTrackImpl::GetTimelineControlSite(
+    InterfaceRequest<MediaTimelineControlSite> req) {
+  timeline_control_site_.Bind(req.Pass());
 }
 
 void AudioTrackImpl::SetGain(float db_gain) {
   if (db_gain >= AudioTrack::kMaxGain) {
     LOG(ERROR) << "Gain value too large (" << db_gain << ") for audio track.";
     Shutdown();
     return;
   }
 
   db_gain_ = db_gain;
@@ skipping 20 matching lines @@
   if (iter != outputs_.end()) {
     outputs_.erase(iter);
   } else {
     // TODO(johngro): that's odd.  I can't think of a reason why we we should
     // not be able to find this link in our set of outputs... should we log
     // something about this?
     DCHECK(false);
   }
 }
 
+void AudioTrackImpl::SnapshotRateTrans(LinearTransform* out,
+                                       uint32_t* generation) {
+  TimelineFunction timeline_function;
+  timeline_control_site_.SnapshotCurrentFunction(
+      Timeline::local_now(), &timeline_function, generation);
+
+  // The control site works in ns units. We want the rate in frames per
+  // nanosecond, so we convert here.
+  TimelineRate rate_in_frames_per_ns =
+      timeline_function.rate() * frames_per_ns_;
+
+  *out = LinearTransform(timeline_function.reference_time(),
+                         rate_in_frames_per_ns.subject_delta(),
+                         rate_in_frames_per_ns.reference_delta(),
+                         timeline_function.subject_time() * frames_per_ns_);
+}
+
 void AudioTrackImpl::OnPacketReceived(AudioPipe::AudioPacketRefPtr packet) {
   DCHECK(packet);
   for (const auto& output : outputs_) {
     DCHECK(output);
     output->PushToPendingQueue(packet);
   }
 }
 
 bool AudioTrackImpl::OnFlushRequested(const MediaConsumer::FlushCallback& cbk) {
   for (const auto& output : outputs_) {
     DCHECK(output);
     output->FlushPendingQueue();
   }
   cbk.Run();
   return true;
 }
 
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo