Motown: Define MediaRenderer and make it the way we identify renderers.

examples/audio_play_test/play_wav.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 <memory>
 
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_impl_base.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/run_application.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "mojo/public/cpp/system/wait.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/core/interfaces/media_renderer.mojom.h"
 #include "mojo/services/network/interfaces/network_service.mojom.h"
 #include "mojo/services/network/interfaces/url_loader.mojom.h"
 
 #define PACKED __attribute__((packed))
 
 static inline constexpr uint32_t make_fourcc(uint8_t a, uint8_t b,
                                              uint8_t c, uint8_t d) {
   return (static_cast<uint32_t>(a) << 24) |
          (static_cast<uint32_t>(b) << 16) |
          (static_cast<uint32_t>(c) << 8)  |
@@ skipping 90 matching lines @@
 
     MOJO_DCHECK(wav_info_.frame_size);
     MOJO_DCHECK(frames <
                 std::numeric_limits<uint32_t>::max() / wav_info_.frame_size);
 
     return frames * wav_info_.frame_size;
   }
 
   AudioServerPtr               audio_server_;
   AudioTrackPtr                audio_track_;
+  MediaRendererPtr             media_renderer_;
   AudioPipePtr                 audio_pipe_;
   TimelineConsumerPtr          timeline_consumer_;
   AudioPacket                  audio_packet_;
   PacketCbk                    playout_complete_cbk_;
   NetworkServicePtr            network_service_;
   URLLoaderPtr                 url_loader_;
   ScopedDataPipeConsumerHandle payload_;
   uint32_t                     payload_len_;
   RIFFChunkHeader              riff_hdr_;
   WAVHeader                    wav_info_;
@@ skipping 51 matching lines @@
     MOJO_DCHECK(audio_pipe_);
     audio_pipe_->CancelMediaPacket(&audio_packet_);
   }
 
   payload_.reset();
   url_loader_.reset();
   network_service_.reset();
   audio_pipe_.reset();
   timeline_consumer_.reset();
   audio_track_.reset();
+  media_renderer_.reset();
   audio_server_.reset();
 }
 
 bool PlayWAVApp::BlockingRead(void* buf, uint32_t op_len) {
   MojoResult res;
   uint32_t amt;
 
   while (true) {
     amt = op_len;
     res = ReadDataRaw(payload_.get(), buf, &amt,
@@ skipping 34 matching lines @@
   }
 
   MOJO_LOG(INFO) << "Preparing to play...";
   MOJO_LOG(INFO) << "File : " << TEST_FILE;
   MOJO_LOG(INFO) << "Rate : " << wav_info_.frame_rate;
   MOJO_LOG(INFO) << "Chan : " << wav_info_.channel_count;
   MOJO_LOG(INFO) << "BPS  : " << wav_info_.bits_per_sample;
 
   // Create the audio sink we will use to play this WAV file and start to
   // configure it.
-  audio_server_->CreateTrack(GetProxy(&audio_track_));
+  audio_server_->CreateTrack(
+      GetProxy(&audio_track_), GetProxy(&media_renderer_));
 
   // TODO(johngro): when there is some better diagnostic information made
   // available to us, make sure that we log it so we have some way to proceed
   // with debugging.
   audio_track_.set_connection_error_handler([this]() {
     OnConnectionError("audio_track");
   });
-
-  LinearTransform::Ratio audio_rate(wav_info_.frame_rate, 1);
-  LinearTransform::Ratio local_rate(LocalDuration::period::num,
-                                    LocalDuration::period::den);
-  LinearTransform::Ratio tmp;
-  bool success = LinearTransform::Ratio::Compose(audio_rate, local_rate, &tmp);
-  MOJO_DCHECK(success);
-
-  AudioTrackConfigurationPtr cfg;
-  cfg = AudioTrackConfiguration::New();
-  cfg->audio_frame_ratio = tmp.numerator;
-  cfg->media_time_ratio  = tmp.denominator;
+  media_renderer_.set_connection_error_handler([this]() {
+    OnConnectionError("media_renderer");
+  });
 
   AudioMediaTypeDetailsPtr pcm_cfg = AudioMediaTypeDetails::New();
   pcm_cfg->sample_format = (wav_info_.bits_per_sample == 8)
                          ? AudioSampleFormat::UNSIGNED_8
                          : AudioSampleFormat::SIGNED_16;
   pcm_cfg->channels = wav_info_.channel_count;
   pcm_cfg->frames_per_second = wav_info_.frame_rate;
 
-  cfg->media_type = MediaType::New();
-  cfg->media_type->medium = MediaTypeMedium::AUDIO;
-  cfg->media_type->details = MediaTypeDetails::New();
-  cfg->media_type->details->set_audio(pcm_cfg.Pass());
-  cfg->media_type->encoding = MediaType::kAudioEncodingLpcm;
+  MediaTypePtr media_type = MediaType::New();
+  media_type->medium = MediaTypeMedium::AUDIO;
+  media_type->details = MediaTypeDetails::New();
+  media_type->details->set_audio(pcm_cfg.Pass());
+  media_type->encoding = MediaType::kAudioEncodingLpcm;
 
   // Configure the track based on the WAV header information.
+  media_renderer_->SetMediaType(media_type.Pass());
   MediaConsumerPtr media_pipe;
-  audio_track_->Configure(cfg.Pass(), GetProxy(&media_pipe));
+  media_renderer_->GetConsumer(GetProxy(&media_pipe));
 
   // Grab the timeline consumer interface for our audio renderer.
   MediaTimelineControlSitePtr timeline_control_site;
-  audio_track_->GetTimelineControlSite(GetProxy(&timeline_control_site));
+  media_renderer_->GetTimelineControlSite(GetProxy(&timeline_control_site));
   timeline_control_site->GetTimelineConsumer(GetProxy(&timeline_consumer_));
   timeline_consumer_.set_connection_error_handler(
       [this]() { OnConnectionError("timeline_consumer"); });
 
   // Set up our media pipe helper, configure its callback and water marks to
   // kick off the playback process.
   audio_pipe_.reset(new CircularBufferMediaPipeAdapter(media_pipe.Pass()));
   audio_pipe_->Init(USecToBytes(BUF_DEPTH_USEC));
   audio_pipe_->SetWatermarks(USecToBytes(BUF_HI_WATER_USEC),
                              USecToBytes(BUF_LO_WATER_USEC));
@@ skipping 247 matching lines @@
 
 }  // namespace examples
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle app_request) {
   mojo::media::audio::examples::PlayWAVApp play_wav_app;
   return mojo::RunApplication(app_request, &play_wav_app);
 }