Motown: Use new TimelineTransform and related definitions

examples/audio_play_test/play_tone.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 <math.h>
 #include <memory>
 
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_runner.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/services/media/audio/interfaces/audio_server.mojom.h"
 #include "mojo/services/media/audio/interfaces/audio_track.mojom.h"
 #include "mojo/services/media/common/cpp/circular_buffer_media_pipe_adapter.h"
 #include "mojo/services/media/common/cpp/linear_transform.h"
 #include "mojo/services/media/common/cpp/local_time.h"
-#include "mojo/services/media/common/interfaces/rate_control.mojom.h"
+#include "mojo/services/media/common/interfaces/timelines.mojom.h"
 
 namespace mojo {
 namespace media {
 namespace audio {
 namespace examples {
 
 static constexpr uint32_t SAMP_FREQ = 48000;
 static constexpr uint32_t CHUNK_USEC = 10000;
 static constexpr uint32_t BUF_LO_WATER_USEC = 500000;
 static constexpr uint32_t BUF_HI_WATER_USEC = BUF_LO_WATER_USEC
@@ skipping 15 matching lines @@
   void Quit() override;
 
  private:
   void GenerateToneCbk(MediaResult res);
   void PlayTone(double freq_hz, double amplitude, double duration_sec);
   void PostShutdown();
   void Shutdown();
   void OnConnectionError(const std::string& connection_name);
 
   AudioServerPtr audio_server_;
-  AudioTrackPtr  audio_track_;
-  RateControlPtr rate_control_;
+  AudioTrackPtr audio_track_;
+  TimelineConsumerPtr timeline_consumer_;
   std::unique_ptr<CircularBufferMediaPipeAdapter> audio_pipe_;
 
   bool     clock_started_ = false;
   uint64_t media_time_    = 0;
   double   freq_hz_       = 440.0;
   double   amplitude_     = 1.0;
   bool     shutting_down_ = false;
 };
 
 void PlayToneApp::Quit() {
-  rate_control_.reset();
+  timeline_consumer_.reset();
   audio_pipe_.reset();
   audio_track_.reset();
   audio_server_.reset();
 }
 
 void PlayToneApp::Initialize(ApplicationImpl* app) {
   mojo::ConnectToService(app->shell(), "mojo:audio_server",
                          GetProxy(&audio_server_));
   audio_server_.set_connection_error_handler([this]() {
     OnConnectionError("audio_server");
@@ skipping 30 matching lines @@
   if (!audio_track_.WaitForIncomingResponse()) {
     MOJO_LOG(ERROR)
       << "Failed to fetch sync capabilities; no response received.";
     Shutdown();
     return;
   }
 
   // TODO(johngro): do something useful with our capabilities description.
   sink_desc.reset();
 
-  // Grab the rate control interface for our audio renderer.
-  audio_track_->GetRateControl(GetProxy(&rate_control_));
-  rate_control_.set_connection_error_handler([this]() {
-    OnConnectionError("rate_control");
-  });
+  // Grab the timeline consumer interface for our audio renderer.
+  MediaTimelineControlSitePtr timeline_control_site;
+  audio_track_->GetTimelineControlSite(GetProxy(&timeline_control_site));
+  timeline_control_site->GetTimelineConsumer(GetProxy(&timeline_consumer_));
+  timeline_consumer_.set_connection_error_handler(
+      [this]() { OnConnectionError("timeline_consumer"); });
 
   // Configure our sink for 16-bit 48KHz mono.
   AudioTrackConfigurationPtr cfg = AudioTrackConfiguration::New();
 
   AudioMediaTypeDetailsPtr pcm_cfg = AudioMediaTypeDetails::New();
   pcm_cfg->sample_format     = AudioSampleFormat::SIGNED_16;
   pcm_cfg->channels          = 1;
   pcm_cfg->frames_per_second = SAMP_FREQ;
 
   cfg->media_type = MediaType::New();
@@ skipping 64 matching lines @@
     if (res != MediaResult::OK) {
       MOJO_LOG(ERROR) << "Unexpected error when sending media packet ("
                  << res << ").";
       audio_pipe_->CancelMediaPacket(&mapped_pkt);
       PostShutdown();
       return;
     }
   }
 
   if (!clock_started_) {
-    // In theory, this could be done at compile time using std::ratio, but
-    // std::ratio is prohibited.
-    LinearTransform::Ratio audio_rate(SAMP_FREQ, 1);
-    LinearTransform::Ratio local_time_rate(LocalDuration::period::num,
-                                           LocalDuration::period::den);
-    LinearTransform::Ratio rate;
-    bool success = LinearTransform::Ratio::Compose(local_time_rate,
-                                                   audio_rate,
-                                                   &rate);
-    MOJO_DCHECK(success);  // assert that there was no loss of precision.
+    MOJO_LOG(INFO) << "Setting rate 1/1";
 
-    MOJO_LOG(INFO) << "Setting rate " << rate;
-
-    rate_control_->SetRate(rate.numerator, rate.denominator);
+    timeline_consumer_->SetTimelineTransform(
+        kUnspecifiedTime, 1, 1, kUnspecifiedTime, kUnspecifiedTime,
+        [](bool completed) {});
     clock_started_ = true;
   }
 }
 
 void PlayToneApp::OnConnectionError(const std::string& connection_name) {
   if (!shutting_down_) {
     MOJO_LOG(ERROR) << connection_name << " connection closed unexpectedly!";
     Shutdown();
   }
 }
@@ skipping 18 matching lines @@
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle app_request) {
   mojo::ApplicationRunner runner(
       std::unique_ptr<mojo::media::audio::examples::PlayToneApp>(
           new mojo::media::audio::examples::PlayToneApp()));
   return runner.Run(app_request);
 }