Mix to an intermediate buffer.

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 57 matching lines @@
   DCHECK(!alsa_device_);
   Cleanup();
 }
 
 AudioOutputPtr AlsaOutput::New(AudioOutputManager* manager) {
   return AudioOutputPtr(new AlsaOutput(manager));
 }
 
 MediaResult AlsaOutput::Configure(LpcmMediaTypeDetailsPtr config) {
   if (!config) { return MediaResult::INVALID_ARGUMENT; }
-  if (output_format_) { return MediaResult::BAD_STATE; }
+  if (output_formatter_) { return MediaResult::BAD_STATE; }
 
-  uint32_t bytes_per_sample;
+  output_formatter_ = OutputFormatter::Select(config);
+  if (!output_formatter_) { return MediaResult::UNSUPPORTED_CONFIG; }
+
   switch (config->sample_format) {
   case LpcmSampleFormat::UNSIGNED_8:
     alsa_format_ = SND_PCM_FORMAT_U8;
-    silence_byte_ = 0x80;
-    bytes_per_sample = 1;
     break;
 
   case LpcmSampleFormat::SIGNED_16:
     alsa_format_ = SND_PCM_FORMAT_S16;
-    silence_byte_ = 0x00;
-    bytes_per_sample = 2;
     break;
 
   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->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->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 (!output_formatter_) { 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_->channels,
-                           output_format_->frames_per_second,
+                           output_formatter_->format()->channels,
+                           output_formatter_->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 channels         : "
-               << output_format_->channels;
+               << output_formatter_->format()->channels;
     LOG(ERROR) << "Requested frames per second: "
-               << output_format_->frames_per_second;
+               << output_formatter_->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) {
     LOG(ERROR) << "[" << this << "] : "
                << "Fatal error (" << res
                << ") attempting to determine ALSA buffer size.";
     Cleanup();
     return MediaResult::INTERNAL_ERROR;
   }
 
+  size_t buffer_size;
   mix_buf_frames_ = res;
-  mix_buf_.reset(new uint8_t[mix_buf_frames_ * output_bytes_per_frame_]);
+  buffer_size = mix_buf_frames_ * output_formatter_->bytes_per_frame();
+  mix_buf_.reset(new uint8_t[buffer_size]);
+
+  // Set up the intermediate buffer at the StandardOutputBase level
+  SetupMixBuffer(mix_buf_frames_);
 
   return MediaResult::OK;
 }
 
 void AlsaOutput::Cleanup() {
   if (alsa_device_) {
     snd_pcm_close(alsa_device_);
     alsa_device_ = nullptr;
   }
 
@@ skipping 89 matching lines @@
     job->buf_frames = (avail < fill_amt) ? avail : fill_amt;
     if (job->buf_frames > mix_buf_frames_) {
       job->buf_frames = mix_buf_frames_;
     }
 
     job->buf = mix_buf_.get();
     job->start_pts_of = frames_sent_;
     job->local_to_output = &local_to_output_;
     job->local_to_output_gen = local_to_output_gen_;
 
-    // TODO(johngro): optimize this if we can.  The first buffer we mix can just
-    // put its samples directly into the output buffer, and does not need to
-    // accumulate and clip.  In theory, we only need to put silence in the
-    // places where our outputs are not going to already overwrite.
-    FillMixBufWithSilence(job->buf_frames);
     return true;
   }
 
   // Wait until its time to mix some more data.
   SetNextSchedTime(low_buf_time);
   return false;
 }
 
 bool AlsaOutput::FinishMixJob(const MixJob& job) {
   DCHECK(job.buf == mix_buf_.get());
   DCHECK(job.buf_frames);
 
   // We should always be able to write all of the data that we mixed.
   snd_pcm_sframes_t res;
   res = snd_pcm_writei(alsa_device_, job.buf, job.buf_frames);
   if (res != job.buf_frames) {
     HandleAlsaError(res);
     return false;
   }
 
   frames_sent_ += res;
   return true;
 }
 
-void AlsaOutput::FillMixBufWithSilence(uint32_t frames) {
-  DCHECK(mix_buf_);
-  DCHECK(frames <= mix_buf_frames_);
-
-  // TODO(johngro): someday, this may not be this simple.  Filling unsigned
-  // multibyte sample formats, or floating point formats, will require something
-  // more sophisticated than filling with a single byte pattern.
-  ::memset(mix_buf_.get(), silence_byte_, frames * output_bytes_per_frame_);
-}
-
 void AlsaOutput::HandleAsUnderflow() {
   snd_pcm_sframes_t res;
 
   // If we were already primed, then this is a legitimate underflow, not the
   // startup case or recovery from some other error.
   if (primed_) {
     // TODO(johngro): come up with a way to properly throttle this.  Also, add a
     // friendly name to the output so the log helps to identify which output
     // underflowed.
     LOG(WARNING) << "[" << this << "] : underflow";
     res = snd_pcm_recover(alsa_device_, -EPIPE, true);
     if (res < 0) {
       HandleAsError(res);
       return;
     }
   }
 
   // TODO(johngro): We don't actually have to fill up the entire lead time with
   // silence.  When we have better control of our thread priorities, prime this
   // with the minimimum amt we can get away with and still be able to start
   // mixing without underflowing.
-  FillMixBufWithSilence(mix_buf_frames_);
+  output_formatter_->FillWithSilence(mix_buf_.get(), mix_buf_frames_);
   res = snd_pcm_writei(alsa_device_, mix_buf_.get(), mix_buf_frames_);
 
   if (res < 0) {
     HandleAsError(res);
     return;
   }
 
   primed_ = true;
   local_to_output_known_ = false;
   SetNextSchedDelay(local_time::from_msec(1));
@@ skipping 37 matching lines @@
   if (code == -EPIPE) {
     HandleAsUnderflow();
   } else {
     HandleAsError(code);
   }
 }
 
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo