Mojom updates for Motown.

services/media/audio/platform/linux/alsa_output.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 <limits>
 #include <set>
 
 #include "mojo/services/media/common/cpp/local_time.h"
 #include "services/media/audio/platform/linux/alsa_output.h"
 
@@ skipping 31 matching lines @@
   // If we could own the output entirely and bypass the mixer to achieve lower
   // latency, that would be even better.
   AudioOutputPtr audio_out(audio::AlsaOutput::New(manager));
   if (!audio_out) { return nullptr; }
 
   AlsaOutput* alsa_out = static_cast<AlsaOutput*>(audio_out.get());
   DCHECK(alsa_out);
 
   LpcmMediaTypeDetailsPtr config(LpcmMediaTypeDetails::New());
   config->frames_per_second = 48000;
-  config->samples_per_frame = 2;
+  config->channels = 2;
   config->sample_format = LpcmSampleFormat::SIGNED_16;
 
   if (alsa_out->Configure(config.Pass()) != MediaResult::OK) {
     return nullptr;
   }
 
   return audio_out;
 }
 
 AlsaOutput::AlsaOutput(AudioOutputManager* manager)
@@ skipping 31 matching lines @@
   case LpcmSampleFormat::SIGNED_24_IN_32:
   default:
     return MediaResult::UNSUPPORTED_CONFIG;
   }
 
   if (SUPPORTED_SAMPLE_RATES.find(config->frames_per_second) ==
       SUPPORTED_SAMPLE_RATES.end()) {
     return MediaResult::UNSUPPORTED_CONFIG;
   }
 
-  if (SUPPORTED_CHANNEL_COUNTS.find(config->samples_per_frame) ==
+  if (SUPPORTED_CHANNEL_COUNTS.find(config->channels) ==
       SUPPORTED_CHANNEL_COUNTS.end()) {
     return MediaResult::UNSUPPORTED_CONFIG;
   }
 
   // Compute the ratio between frames and local time ticks.
   LinearTransform::Ratio sec_per_tick(LocalDuration::period::num,
                                       LocalDuration::period::den);
   LinearTransform::Ratio frames_per_sec(config->frames_per_second, 1);
   bool is_precise = LinearTransform::Ratio::Compose(frames_per_sec,
                                                     sec_per_tick,
                                                     &frames_per_tick_);
   DCHECK(is_precise);
 
   // Figure out how many bytes there are per frame.
-  output_bytes_per_frame_ = bytes_per_sample * config->samples_per_frame;
+  output_bytes_per_frame_ = bytes_per_sample * config->channels;
 
   // Success
   output_format_ = config.Pass();
   return MediaResult::OK;
 }
 
 MediaResult AlsaOutput::Init() {
   static const char* kAlsaDevice = "default";
 
   if (!output_format_) { return MediaResult::BAD_STATE; }
   if (alsa_device_) { return MediaResult::BAD_STATE; }
 
   snd_pcm_sframes_t res;
   res = snd_pcm_open(&alsa_device_,
                      kAlsaDevice,
                      SND_PCM_STREAM_PLAYBACK,
                      SND_PCM_NONBLOCK);
   if (res != 0) {
     LOG(ERROR) << "Failed to open ALSA device \"" << kAlsaDevice << "\".";
     return MediaResult::INTERNAL_ERROR;
   }
 
   res = snd_pcm_set_params(alsa_device_,
                            alsa_format_,
                            SND_PCM_ACCESS_RW_INTERLEAVED,
-                           output_format_->samples_per_frame,
+                           output_format_->channels,
                            output_format_->frames_per_second,
                            0,   // do not allow ALSA resample
                            local_time::to_usec<unsigned int>(TARGET_LATENCY));
   if (res) {
     LOG(ERROR) << "Failed to configure ALSA device \"" << kAlsaDevice << "\" "
                << "(res = " << res << ")";
     LOG(ERROR) << "Requested samples per frame: "
-               << output_format_->samples_per_frame;
+               << output_format_->channels;
     LOG(ERROR) << "Requested frames per second: "
                << output_format_->frames_per_second;
     LOG(ERROR) << "Requested ALSA format      : " << alsa_format_;
     Cleanup();
     return MediaResult::INTERNAL_ERROR;
   }
 
   // Figure out how big our mixing buffer needs to be, then allocate it.
   res = snd_pcm_avail_update(alsa_device_);
   if (res <= 0) {
@@ skipping 226 matching lines @@
   if (code == -EPIPE) {
     HandleAsUnderflow();
   } else {
     HandleAsError(code);
   }
 }
 
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo
-