Mix to an intermediate buffer.

services/media/audio/platform/generic/standard_output_base.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 "base/logging.h"
 #include "services/media/audio/audio_track_impl.h"
 #include "services/media/audio/audio_track_to_output_link.h"
 #include "services/media/audio/platform/generic/mixer.h"
@@ skipping 60 matching lines @@
 
     // As long as our implementation wants to mix more and has not run into a
     // problem trying to finish the mix job, mix some more.
     do {
       ::memset(&cur_mix_job_, 0, sizeof(cur_mix_job_));
 
       if (!StartMixJob(&cur_mix_job_, now)) {
         break;
       }
 
+      // If we have a mix job, then we must have an output formatter, and an
+      // intermediate buffer allocated, and it must be large enough for the mix
+      // job we were given.
+      DCHECK(mix_buf_);
+      DCHECK(output_formatter_);
+      DCHECK_LE(cur_mix_job_.buf_frames, mix_buf_frames_);
+
+      // Fill the intermediate buffer with silence.
+      size_t bytes_to_zero = sizeof(*mix_buf_)
+                           * cur_mix_job_.buf_frames
+                           * output_formatter_->channels();
+      ::memset(mix_buf_.get(), 0, bytes_to_zero);
+
+      // Mix each track into the intermediate buffer, then clip/format into the
+      // final buffer.
       ForeachTrack(setup_mix_, process_mix_);
+      output_formatter_->ProduceOutput(mix_buf_.get(),
+                                       cur_mix_job_.buf,
+                                       cur_mix_job_.buf_frames);
+
       mixed = true;
     } while (FinishMixJob(cur_mix_job_));
   }
 
   if (!next_sched_time_known_) {
     // TODO(johngro): log this as an error.
     ShutdownSelf();
     return;
   }
 
@@ skipping 20 matching lines @@
 
   // We should never fail to allocate our bookkeeping.  The only way this can
   // happen is if we have a badly behaved implementation.
   if (!bk) { return MediaResult::INTERNAL_ERROR; }
 
   // We cannot proceed if our track has somehow managed to go away already.
   AudioTrackImplPtr track = link->GetTrack();
   if (!track) { return MediaResult::INVALID_ARGUMENT; }
 
   // Pick a mixer based on the input and output formats.
-  bk->mixer = Mixer::Select(track->Format(), output_format_);
+  bk->mixer = Mixer::Select(track->Format(), output_formatter_
+                                           ? &output_formatter_->format()
+                                           : nullptr);
   if (bk->mixer == nullptr) { return MediaResult::UNSUPPORTED_CONFIG; }
 
   // Looks like things went well.  Stash a reference to our bookkeeping and get
   // out.
   link->output_bookkeeping() = std::move(ref);
   return MediaResult::OK;
 }
 
 StandardOutputBase::TrackBookkeeping* StandardOutputBase::AllocBookkeeping() {
   return new TrackBookkeeping();
 }
 
+void StandardOutputBase::SetupMixBuffer(uint32_t max_mix_frames) {
+  DCHECK_GT(output_formatter_->channels(), 0u);
+  DCHECK_GT(max_mix_frames, 0u);
+  DCHECK_LE(max_mix_frames, std::numeric_limits<uint32_t>::max() /
+                            output_formatter_->channels());
+
+  mix_buf_frames_ = max_mix_frames;
+  mix_buf_.reset(new int32_t[mix_buf_frames_ * output_formatter_->channels()]);
+}
+
 void StandardOutputBase::ForeachTrack(const TrackSetupTask& setup,
                                       const TrackProcessTask& process) {
   for (auto iter = links_.begin(); iter != links_.end(); ) {
     if (shutting_down()) { return; }
 
     // Is the track still around?  If so, process it.  Otherwise, remove the
     // track entry and move on.
     const AudioTrackToOutputLinkPtr& link = *iter;
     AudioTrackImplPtr track(link->GetTrack());
 
@@ skipping 66 matching lines @@
 
 bool StandardOutputBase::ProcessMix(
     const AudioTrackImplPtr& track,
     TrackBookkeeping* info,
     const AudioPipe::AudioPacketRefPtr& packet) {
   // Sanity check our parameters.
   DCHECK(info);
   DCHECK(packet);
 
   // We had better have a valid job, or why are we here?
-  DCHECK(cur_mix_job_.buf);
   DCHECK(cur_mix_job_.buf_frames);
   DCHECK(cur_mix_job_.frames_produced <= cur_mix_job_.buf_frames);
 
   // We also must have selected a mixer, or we are in trouble.
   DCHECK(info->mixer);
   Mixer& mixer = *(info->mixer);
 
   // If this track is currently paused (or being sampled extremely slowly), our
   // step size will be zero.  We know that this packet will be relevant at some
   // point in the future, but right now it contributes nothing.  Tell the
   // ForeachTrack loop that we are done and to hold onto this packet for now.
   if (!info->step_size) {
     return false;
   }
 
   // Have we produced all that we are supposed to?  If so, hold the current
   // packet and move on to the next track.
   if (cur_mix_job_.frames_produced >= cur_mix_job_.buf_frames) {
     return false;
   }
 
   uint32_t frames_left = cur_mix_job_.buf_frames - cur_mix_job_.frames_produced;
-  void* buf = static_cast<uint8_t*>(cur_mix_job_.buf)
-            + (cur_mix_job_.frames_produced * output_bytes_per_frame_);
+  int32_t* buf = mix_buf_.get()
+               + (cur_mix_job_.frames_produced * output_formatter_->channels());
 
   // Figure out where the first and last sampling points of this job are,
   // expressed in fractional track frames.
   int64_t first_sample_ftf;
   bool good = info->out_frames_to_track_frames.DoForwardTransform(
       cur_mix_job_.start_pts_of + cur_mix_job_.frames_produced,
       &first_sample_ftf);
   DCHECK(good);
 
   DCHECK(frames_left);
@@ skipping 242 matching lines @@
     step_size = static_cast<uint32_t>(tmp_step_size);
   }
 
   // Done, update our generation.
   out_frames_to_track_frames_gen = job.local_to_output_gen;
 }
 
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo