services/media/audio/platform/generic/standard_output_base.cc - mojo-tools - Git at Google

 // 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"
 #include "services/media/audio/platform/generic/standard_output_base.h"

 namespace mojo {
 namespace media {
 namespace audio {

 static constexpr LocalDuration MAX_TRIM_PERIOD = local_time::from_msec(10);
 constexpr uint32_t StandardOutputBase::MixJob::INVALID_GENERATION;

 StandardOutputBase::TrackBookkeeping::TrackBookkeeping() {}
 StandardOutputBase::TrackBookkeeping::~TrackBookkeeping() {}

 StandardOutputBase::StandardOutputBase(AudioOutputManager* manager)
   : AudioOutput(manager) {
   setup_mix_ =
     [this] (const AudioTrackImplPtr& track, TrackBookkeeping* info) -> bool {
       return SetupMix(track, info);
     };

   process_mix_ =
     [this] (const AudioTrackImplPtr& track,
             TrackBookkeeping* info,
             const AudioPipe::AudioPacketRefPtr& pkt_ref) -> bool {
       return ProcessMix(track, info, pkt_ref);
     };

   setup_trim_ =
     [this] (const AudioTrackImplPtr& track, TrackBookkeeping* info) -> bool {
       return SetupTrim(track, info);
     };

   process_trim_ =
     [this] (const AudioTrackImplPtr& track,
             TrackBookkeeping* info,
             const AudioPipe::AudioPacketRefPtr& pkt_ref) -> bool {
       return ProcessTrim(track, info, pkt_ref);
     };

   next_sched_time_ = LocalClock::now();
   next_sched_time_known_ = true;
 }

 StandardOutputBase::~StandardOutputBase() {}

 void StandardOutputBase::Process() {
   bool mixed = false;
   LocalTime now = LocalClock::now();

   // At this point, we should always know when our implementation would like to
   // be called to do some mixing work next.  If we do not know, then we should
   // have already shut down.
   //
   // If the next sched time has not arrived yet, don't attempt to mix anything.
   // Just trim the queues and move on.
   DCHECK(next_sched_time_known_);
   if (now >= next_sched_time_) {
     // Clear the flag, if the implementation does not set this flag by calling
     // SetNextSchedTime during the cycle, we consider it to be an error and shut
     // down.
     next_sched_time_known_ = false;

     // 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;
       }

       ForeachTrack(setup_mix_, process_mix_);
       mixed = true;
     } while (FinishMixJob(cur_mix_job_));
   }

   if (!next_sched_time_known_) {
     // TODO(johngro): log this as an error.
     ShutdownSelf();
     return;
   }

   // If we mixed nothing this time, make sure that we trim all of our track
   // queues.  No matter what is going on with the output hardware, we are not
   // allowed to hold onto the queued data past its presentation time.
   if (!mixed) {
     ForeachTrack(setup_trim_, process_trim_);
   }

   // Figure out when we should wake up to do more work again.  No matter how
   // long our implementation wants to wait, we need to make sure to wake up and
   // periodically trim our input queues.
   LocalTime max_sched_time = now + MAX_TRIM_PERIOD;
   ScheduleCallback((next_sched_time_ > max_sched_time)
                    ? max_sched_time
                    : next_sched_time_);
 }

 MediaResult StandardOutputBase::InitializeLink(
     const AudioTrackToOutputLinkPtr& link) {
   TrackBookkeeping* bk = AllocBookkeeping();
   AudioTrackToOutputLink::BookkeepingPtr ref(bk);

   // 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_);
   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::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());

     auto tmp_iter = iter++;
     if (!track) {
       links_.erase(tmp_iter);
       continue;
     }

     // It would be nice to be able to use a dynamic cast for this, but currently
     // we are building with no-rtti
     TrackBookkeeping* info =
       static_cast<TrackBookkeeping*>(link->output_bookkeeping().get());
     DCHECK(info);

     // Make sure that the mapping between the track's frame time domain and
     // local time is up to date.
     info->UpdateTrackTrans(track);

     bool setup_done = false;
     AudioPipe::AudioPacketRefPtr pkt_ref;
     while (true) {
       // Try to grab the front of the packet queue.  If it has been flushed
       // since the last time we grabbed it, be sure to reset our mixer's
       // internal filter state.
       bool was_flushed;
       pkt_ref = link->LockPendingQueueFront(&was_flushed);
       if (was_flushed) {
         info->mixer->Reset();
       }

       // If the queue is empty, then we are done.
       if (!pkt_ref) { break; }

       // If we have not set up for this track yet, do so.  If the setup fails
       // for any reason, stop processing packets for this track.
       if (!setup_done) {
         setup_done = setup(track, info);
         if (!setup_done) { break; }
       }

       // Now process the packet which is at the front of the track's queue.  If
       // the packet has been entirely consumed, pop it off the front and proceed
       // to the next one.  Otherwise, we are finished.
       if (!process(track, info, pkt_ref)) { break; }
       link->UnlockPendingQueueFront(&pkt_ref, true);
     }

     // Unlock the queue and proceed to the next track.
     link->UnlockPendingQueueFront(&pkt_ref, false);

     // Note: there is no point in doing this for the trim task, but it dosn't
     // hurt anything, and its easier then introducing another function to the
     // ForeachTrack arguments to run after each track is processed just for the
     // purpose of setting this flag.
     cur_mix_job_.accumulate = true;
   }
 }

 bool StandardOutputBase::SetupMix(const AudioTrackImplPtr& track,
                                   TrackBookkeeping* info) {
   // If we need to recompose our transformation from output frame space to input
   // fractional frames, do so now.
   DCHECK(info);
   info->UpdateOutputTrans(cur_mix_job_);
   cur_mix_job_.frames_produced = 0;

   return true;
 }

 bool StandardOutputBase::ProcessMix(
     const AudioTrackImplPtr& track,
     TrackBookkeeping* info,
     const AudioPipe::AudioPacketRefPtr& pkt_ref) {
   // Sanity check our parameters.
   DCHECK(info);
   DCHECK(pkt_ref);

   // 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);

   // 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_);

   // Figure out where this job starts, expressed in fractional input frames.
   int64_t start_pts_ftf;
   bool good = info->out_frames_to_track_frames.DoForwardTransform(
       cur_mix_job_.start_pts_of + cur_mix_job_.frames_produced,
       &start_pts_ftf);
   DCHECK(good);

   // If the start of this mix job is past the end of this packet presentation,
   // do no mixing.  Let the ForeachTrack loop know that we are done with the
   // packet and it can be released.
   if (start_pts_ftf >= pkt_ref->end_pts()) {
     return true;
   }

   // 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;
   }

   // Figure out how many output samples into the current job this packet starts.
   int64_t delta;
   int64_t output_offset_64;
   if (pkt_ref->start_pts() > start_pts_ftf) {
     delta             = pkt_ref->start_pts() - start_pts_ftf;
     output_offset_64  = delta + info->step_size - 1;
     output_offset_64 /= info->step_size;
   } else {
     output_offset_64 = 0;
   }
   DCHECK_GE(output_offset_64, 0);

   // If this packet starts after the end of this job (entirely in the future),
   // then we are done for now.
   if (output_offset_64 >= frames_left) {
     return false;
   }

   // Figure out the offset (in fractional frames) into this packet where we want
   // to start sampling.
   int64_t  input_offset_64;
   if (output_offset_64) {
     input_offset_64  = output_offset_64 * info->step_size;
     input_offset_64 -= delta;
     DCHECK_LT(input_offset_64, info->step_size);
   } else {
     input_offset_64 = start_pts_ftf - pkt_ref->start_pts();
   }
   DCHECK_GE(input_offset_64, 0);
   DCHECK_LE(input_offset_64, std::numeric_limits<int32_t>::max());
   DCHECK_LT(input_offset_64, pkt_ref->end_pts() - pkt_ref->start_pts());

   uint32_t input_offset  = static_cast<uint32_t>(input_offset_64);
   uint32_t output_offset = static_cast<uint32_t>(output_offset_64);
   const auto& regions = pkt_ref->regions();
   DCHECK(info->mixer != nullptr);

   for (size_t i = 0;
       (i < regions.size()) && (output_offset < frames_left);
       ++i) {
     const auto& region = regions[i];

     if (input_offset >= region.frac_frame_len) {
       input_offset -= region.frac_frame_len;
       continue;
     }

     bool consumed_source = info->mixer->Mix(buf,
                                             frames_left,
                                             &output_offset,
                                             region.base,
                                             region.frac_frame_len,
                                             &input_offset,
                                             info->step_size,
                                             cur_mix_job_.accumulate);
     DCHECK_LE(output_offset, frames_left);

     if (!consumed_source) {
       // Looks like we didn't consume all of this region.  Assert that we have
       // produced all of our frames and we are done.
       DCHECK(output_offset == frames_left);
       return false;
     }

     input_offset -= region.frac_frame_len;
   }

   cur_mix_job_.frames_produced += output_offset;
   DCHECK(cur_mix_job_.frames_produced <= cur_mix_job_.buf_frames);
   return true;
 }

 bool StandardOutputBase::SetupTrim(const AudioTrackImplPtr& track,
                                    TrackBookkeeping* info) {
   // Compute the cutoff time we will use to decide wether or not to trim
   // packets.  ForeachTracks has already updated our transformation, no need
   // for us to do so here.
   DCHECK(info);

   int64_t local_now_ticks = LocalClock::now().time_since_epoch().count();

   // The behavior of the RateControlBase implementation guarantees that the
   // transformation into the media timeline is never singular.  If the
   // forward transformation fails it can only be because of an overflow,
   // which should be impossible unless the user has defined a playback rate
   // where the ratio between media time ticks and local time ticks is
   // greater than one.
   //
   // IOW - this should never happen.  If it does, we just stop processing
   // payloads.
   //
   // TODO(johngro): Log an error?  Communicate this to the user somehow?
   if (!info->lt_to_track_frames.DoForwardTransform(local_now_ticks,
                                                   &trim_threshold_)) {
     return false;
   }

   return true;
 }

 bool StandardOutputBase::ProcessTrim(
     const AudioTrackImplPtr& track,
     TrackBookkeeping* info,
     const AudioPipe::AudioPacketRefPtr& pkt_ref) {
   DCHECK(pkt_ref);

   // If the presentation end of this packet is in the future, stop trimming.
   if (pkt_ref->end_pts() > trim_threshold_) {
     return false;
   }

   return true;
 }

 void StandardOutputBase::TrackBookkeeping::UpdateTrackTrans(
     const AudioTrackImplPtr& track) {
   LinearTransform tmp;
   uint32_t gen;

   DCHECK(track);
   track->SnapshotRateTrans(&tmp, &gen);

   // If the local time -> media time transformation has not changed since the
   // last time we examines it, just get out now.
   if (lt_to_track_frames_gen == gen) { return; }

   // The transformation has changed, re-compute the local time -> track frame
   // transformation.
   LinearTransform scale(0, track->FractionalFrameToMediaTimeRatio(), 0);
   bool good;

   lt_to_track_frames.a_zero = tmp.a_zero;
   good = scale.DoForwardTransform(tmp.b_zero, &lt_to_track_frames.b_zero);
   DCHECK(good);
   good = LinearTransform::Ratio::Compose(scale.scale,
                                          tmp.scale,
                                          &lt_to_track_frames.scale);
   DCHECK(good);

   // Update the generation, and invalidate the output to track generation.
   lt_to_track_frames_gen = gen;
   out_frames_to_track_frames_gen = MixJob::INVALID_GENERATION;
 }

 void StandardOutputBase::TrackBookkeeping::UpdateOutputTrans(
     const MixJob& job) {
   // We should not be here unless we have a valid mix job.  From our point of
   // view, this means that we have a job which supplies a valid transformation
   // from local time to output frames.
   DCHECK(job.local_to_output);
   DCHECK(job.local_to_output_gen != MixJob::INVALID_GENERATION);

   // If our generations match, we don't need to re-compute anything.  Just use
   // what we have already.
   if (out_frames_to_track_frames_gen == job.local_to_output_gen) { return; }

   // Assert that we have a good mapping from local time to fractional track
   // frames.
   //
   // TODO(johngro): Don't assume that 0 means invalid.  Make it a proper
   // constant defined somewhere.
   DCHECK(lt_to_track_frames_gen);

   // Compose the job supplied transformation from local to output with the
   // track supplied mapping from local to fraction input frames to produce a
   // transformation which maps from output frames to fractional input frames.
   //
   // TODO(johngro): Make this composition operation part of the LinearTransform
   // class instead of doing it by hand here.  Its a more complicated task that
   // one might initially think, because of the need to deal with the
   // intermediate offset term, and distributing it to either side of the end of
   // the transformation with a minimum amt of loss, while avoiding overflow.
   //
   // For now, we punt, do it by hand and just assume that everything went well.
   LinearTransform& dst = out_frames_to_track_frames;

   // Distribute the intermediate offset entirely to the fractional frame domain
   // for now.  We can do better by extracting portions of the intermedate
   // offset that can be scaled by the ratios on either side of with without
   // loss, but for now this should be close enough.
   int64_t intermediate = job.local_to_output->a_zero
                        - lt_to_track_frames.a_zero;
   int64_t track_frame_offset;

   // TODO(johngro): add routines to LinearTransform::Ratio which allow us to
   // scale using just a ratio without needing to create a linear transform with
   // empty offsets.
   LinearTransform tmp(0, lt_to_track_frames.scale, 0);
   bool good = tmp.DoForwardTransform(intermediate, &track_frame_offset);
   DCHECK(good);

   dst.a_zero = job.local_to_output->b_zero;
   dst.b_zero = lt_to_track_frames.b_zero + track_frame_offset;

   // TODO(johngro): Add options to allow us to invert one or both of the ratios
   // during composition instead of needing to make a temporary ratio to
   // acomplish the task.
   LinearTransform::Ratio tmp_ratio(job.local_to_output->scale.denominator,
                                    job.local_to_output->scale.numerator);
   good = LinearTransform::Ratio::Compose(tmp_ratio,
                                          lt_to_track_frames.scale,
                                          &dst.scale);;
   DCHECK(good);

   // Finally, compute the step size in fractional frames.  IOW, every time we
   // move forward one output frame, how many fractional frames of input do we
   // consume.  Don't bother doing the multiplication if we already know that the
   // numerator is zero.
   //
   // TODO(johngro): same complaint as before... Do this without a temp.  The
   // special casing should be handled in the routine added to
   // LinearTransform::Ratio.
   DCHECK(dst.scale.denominator);
   if (!dst.scale.numerator) {
     step_size = 0;
   } else {
     LinearTransform tmp(0, dst.scale, 0);
     int64_t tmp_step_size;

     good = tmp.DoForwardTransform(1, &tmp_step_size);

     DCHECK(good);
     DCHECK_GE(tmp_step_size, 0);
     DCHECK_LE(tmp_step_size, std::numeric_limits<uint32_t>::max());

     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
	// 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"
	#include "services/media/audio/platform/generic/standard_output_base.h"

	namespace mojo {
	namespace media {
	namespace audio {

	static constexpr LocalDuration MAX_TRIM_PERIOD = local_time::from_msec(10);
	constexpr uint32_t StandardOutputBase::MixJob::INVALID_GENERATION;

	StandardOutputBase::TrackBookkeeping::TrackBookkeeping() {}
	StandardOutputBase::TrackBookkeeping::~TrackBookkeeping() {}

	StandardOutputBase::StandardOutputBase(AudioOutputManager* manager)
	: AudioOutput(manager) {
	setup_mix_ =
	[this] (const AudioTrackImplPtr& track, TrackBookkeeping* info) -> bool {
	return SetupMix(track, info);
	};

	process_mix_ =
	[this] (const AudioTrackImplPtr& track,
	TrackBookkeeping* info,
	const AudioPipe::AudioPacketRefPtr& pkt_ref) -> bool {
	return ProcessMix(track, info, pkt_ref);
	};

	setup_trim_ =
	[this] (const AudioTrackImplPtr& track, TrackBookkeeping* info) -> bool {
	return SetupTrim(track, info);
	};

	process_trim_ =
	[this] (const AudioTrackImplPtr& track,
	TrackBookkeeping* info,
	const AudioPipe::AudioPacketRefPtr& pkt_ref) -> bool {
	return ProcessTrim(track, info, pkt_ref);
	};

	next_sched_time_ = LocalClock::now();
	next_sched_time_known_ = true;
	}

	StandardOutputBase::~StandardOutputBase() {}

	void StandardOutputBase::Process() {
	bool mixed = false;
	LocalTime now = LocalClock::now();

	// At this point, we should always know when our implementation would like to
	// be called to do some mixing work next. If we do not know, then we should
	// have already shut down.
	//
	// If the next sched time has not arrived yet, don't attempt to mix anything.
	// Just trim the queues and move on.
	DCHECK(next_sched_time_known_);
	if (now >= next_sched_time_) {
	// Clear the flag, if the implementation does not set this flag by calling
	// SetNextSchedTime during the cycle, we consider it to be an error and shut
	// down.
	next_sched_time_known_ = false;

	// 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;
	}

	ForeachTrack(setup_mix_, process_mix_);
	mixed = true;
	} while (FinishMixJob(cur_mix_job_));
	}

	if (!next_sched_time_known_) {
	// TODO(johngro): log this as an error.
	ShutdownSelf();
	return;
	}

	// If we mixed nothing this time, make sure that we trim all of our track
	// queues. No matter what is going on with the output hardware, we are not
	// allowed to hold onto the queued data past its presentation time.
	if (!mixed) {
	ForeachTrack(setup_trim_, process_trim_);
	}

	// Figure out when we should wake up to do more work again. No matter how
	// long our implementation wants to wait, we need to make sure to wake up and
	// periodically trim our input queues.
	LocalTime max_sched_time = now + MAX_TRIM_PERIOD;
	ScheduleCallback((next_sched_time_ > max_sched_time)
	? max_sched_time
	: next_sched_time_);
	}

	MediaResult StandardOutputBase::InitializeLink(
	const AudioTrackToOutputLinkPtr& link) {
	TrackBookkeeping* bk = AllocBookkeeping();
	AudioTrackToOutputLink::BookkeepingPtr ref(bk);

	// 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_);
	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::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());

	auto tmp_iter = iter++;
	if (!track) {
	links_.erase(tmp_iter);
	continue;
	}

	// It would be nice to be able to use a dynamic cast for this, but currently
	// we are building with no-rtti
	TrackBookkeeping* info =
	static_cast<TrackBookkeeping*>(link->output_bookkeeping().get());
	DCHECK(info);

	// Make sure that the mapping between the track's frame time domain and
	// local time is up to date.
	info->UpdateTrackTrans(track);

	bool setup_done = false;
	AudioPipe::AudioPacketRefPtr pkt_ref;
	while (true) {
	// Try to grab the front of the packet queue. If it has been flushed
	// since the last time we grabbed it, be sure to reset our mixer's
	// internal filter state.
	bool was_flushed;
	pkt_ref = link->LockPendingQueueFront(&was_flushed);
	if (was_flushed) {
	info->mixer->Reset();
	}

	// If the queue is empty, then we are done.
	if (!pkt_ref) { break; }

	// If we have not set up for this track yet, do so. If the setup fails
	// for any reason, stop processing packets for this track.
	if (!setup_done) {
	setup_done = setup(track, info);
	if (!setup_done) { break; }
	}

	// Now process the packet which is at the front of the track's queue. If
	// the packet has been entirely consumed, pop it off the front and proceed
	// to the next one. Otherwise, we are finished.
	if (!process(track, info, pkt_ref)) { break; }
	link->UnlockPendingQueueFront(&pkt_ref, true);
	}

	// Unlock the queue and proceed to the next track.
	link->UnlockPendingQueueFront(&pkt_ref, false);

	// Note: there is no point in doing this for the trim task, but it dosn't
	// hurt anything, and its easier then introducing another function to the
	// ForeachTrack arguments to run after each track is processed just for the
	// purpose of setting this flag.
	cur_mix_job_.accumulate = true;
	}
	}

	bool StandardOutputBase::SetupMix(const AudioTrackImplPtr& track,
	TrackBookkeeping* info) {
	// If we need to recompose our transformation from output frame space to input
	// fractional frames, do so now.
	DCHECK(info);
	info->UpdateOutputTrans(cur_mix_job_);
	cur_mix_job_.frames_produced = 0;

	return true;
	}

	bool StandardOutputBase::ProcessMix(
	const AudioTrackImplPtr& track,
	TrackBookkeeping* info,
	const AudioPipe::AudioPacketRefPtr& pkt_ref) {
	// Sanity check our parameters.
	DCHECK(info);
	DCHECK(pkt_ref);

	// 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);

	// 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_);

	// Figure out where this job starts, expressed in fractional input frames.
	int64_t start_pts_ftf;
	bool good = info->out_frames_to_track_frames.DoForwardTransform(
	cur_mix_job_.start_pts_of + cur_mix_job_.frames_produced,
	&start_pts_ftf);
	DCHECK(good);

	// If the start of this mix job is past the end of this packet presentation,
	// do no mixing. Let the ForeachTrack loop know that we are done with the
	// packet and it can be released.
	if (start_pts_ftf >= pkt_ref->end_pts()) {
	return true;
	}

	// 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;
	}

	// Figure out how many output samples into the current job this packet starts.
	int64_t delta;
	int64_t output_offset_64;
	if (pkt_ref->start_pts() > start_pts_ftf) {
	delta = pkt_ref->start_pts() - start_pts_ftf;
	output_offset_64 = delta + info->step_size - 1;
	output_offset_64 /= info->step_size;
	} else {
	output_offset_64 = 0;
	}
	DCHECK_GE(output_offset_64, 0);

	// If this packet starts after the end of this job (entirely in the future),
	// then we are done for now.
	if (output_offset_64 >= frames_left) {
	return false;
	}

	// Figure out the offset (in fractional frames) into this packet where we want
	// to start sampling.
	int64_t input_offset_64;
	if (output_offset_64) {
	input_offset_64 = output_offset_64 * info->step_size;
	input_offset_64 -= delta;
	DCHECK_LT(input_offset_64, info->step_size);
	} else {
	input_offset_64 = start_pts_ftf - pkt_ref->start_pts();
	}
	DCHECK_GE(input_offset_64, 0);
	DCHECK_LE(input_offset_64, std::numeric_limits<int32_t>::max());
	DCHECK_LT(input_offset_64, pkt_ref->end_pts() - pkt_ref->start_pts());

	uint32_t input_offset = static_cast<uint32_t>(input_offset_64);
	uint32_t output_offset = static_cast<uint32_t>(output_offset_64);
	const auto& regions = pkt_ref->regions();
	DCHECK(info->mixer != nullptr);

	for (size_t i = 0;
	(i < regions.size()) && (output_offset < frames_left);
	++i) {
	const auto& region = regions[i];

	if (input_offset >= region.frac_frame_len) {
	input_offset -= region.frac_frame_len;
	continue;
	}

	bool consumed_source = info->mixer->Mix(buf,
	frames_left,
	&output_offset,
	region.base,
	region.frac_frame_len,
	&input_offset,
	info->step_size,
	cur_mix_job_.accumulate);
	DCHECK_LE(output_offset, frames_left);

	if (!consumed_source) {
	// Looks like we didn't consume all of this region. Assert that we have
	// produced all of our frames and we are done.
	DCHECK(output_offset == frames_left);
	return false;
	}

	input_offset -= region.frac_frame_len;
	}

	cur_mix_job_.frames_produced += output_offset;
	DCHECK(cur_mix_job_.frames_produced <= cur_mix_job_.buf_frames);
	return true;
	}

	bool StandardOutputBase::SetupTrim(const AudioTrackImplPtr& track,
	TrackBookkeeping* info) {
	// Compute the cutoff time we will use to decide wether or not to trim
	// packets. ForeachTracks has already updated our transformation, no need
	// for us to do so here.
	DCHECK(info);

	int64_t local_now_ticks = LocalClock::now().time_since_epoch().count();

	// The behavior of the RateControlBase implementation guarantees that the
	// transformation into the media timeline is never singular. If the
	// forward transformation fails it can only be because of an overflow,
	// which should be impossible unless the user has defined a playback rate
	// where the ratio between media time ticks and local time ticks is
	// greater than one.
	//
	// IOW - this should never happen. If it does, we just stop processing
	// payloads.
	//
	// TODO(johngro): Log an error? Communicate this to the user somehow?
	if (!info->lt_to_track_frames.DoForwardTransform(local_now_ticks,
	&trim_threshold_)) {
	return false;
	}

	return true;
	}

	bool StandardOutputBase::ProcessTrim(
	const AudioTrackImplPtr& track,
	TrackBookkeeping* info,
	const AudioPipe::AudioPacketRefPtr& pkt_ref) {
	DCHECK(pkt_ref);

	// If the presentation end of this packet is in the future, stop trimming.
	if (pkt_ref->end_pts() > trim_threshold_) {
	return false;
	}

	return true;
	}

	void StandardOutputBase::TrackBookkeeping::UpdateTrackTrans(
	const AudioTrackImplPtr& track) {
	LinearTransform tmp;
	uint32_t gen;

	DCHECK(track);
	track->SnapshotRateTrans(&tmp, &gen);

	// If the local time -> media time transformation has not changed since the
	// last time we examines it, just get out now.
	if (lt_to_track_frames_gen == gen) { return; }

	// The transformation has changed, re-compute the local time -> track frame
	// transformation.
	LinearTransform scale(0, track->FractionalFrameToMediaTimeRatio(), 0);
	bool good;

	lt_to_track_frames.a_zero = tmp.a_zero;
	good = scale.DoForwardTransform(tmp.b_zero, &lt_to_track_frames.b_zero);
	DCHECK(good);
	good = LinearTransform::Ratio::Compose(scale.scale,
	tmp.scale,
	&lt_to_track_frames.scale);
	DCHECK(good);

	// Update the generation, and invalidate the output to track generation.
	lt_to_track_frames_gen = gen;
	out_frames_to_track_frames_gen = MixJob::INVALID_GENERATION;
	}

	void StandardOutputBase::TrackBookkeeping::UpdateOutputTrans(
	const MixJob& job) {
	// We should not be here unless we have a valid mix job. From our point of
	// view, this means that we have a job which supplies a valid transformation
	// from local time to output frames.
	DCHECK(job.local_to_output);
	DCHECK(job.local_to_output_gen != MixJob::INVALID_GENERATION);

	// If our generations match, we don't need to re-compute anything. Just use
	// what we have already.
	if (out_frames_to_track_frames_gen == job.local_to_output_gen) { return; }

	// Assert that we have a good mapping from local time to fractional track
	// frames.
	//
	// TODO(johngro): Don't assume that 0 means invalid. Make it a proper
	// constant defined somewhere.
	DCHECK(lt_to_track_frames_gen);

	// Compose the job supplied transformation from local to output with the
	// track supplied mapping from local to fraction input frames to produce a
	// transformation which maps from output frames to fractional input frames.
	//
	// TODO(johngro): Make this composition operation part of the LinearTransform
	// class instead of doing it by hand here. Its a more complicated task that
	// one might initially think, because of the need to deal with the
	// intermediate offset term, and distributing it to either side of the end of
	// the transformation with a minimum amt of loss, while avoiding overflow.
	//
	// For now, we punt, do it by hand and just assume that everything went well.
	LinearTransform& dst = out_frames_to_track_frames;

	// Distribute the intermediate offset entirely to the fractional frame domain
	// for now. We can do better by extracting portions of the intermedate
	// offset that can be scaled by the ratios on either side of with without
	// loss, but for now this should be close enough.
	int64_t intermediate = job.local_to_output->a_zero
	- lt_to_track_frames.a_zero;
	int64_t track_frame_offset;

	// TODO(johngro): add routines to LinearTransform::Ratio which allow us to
	// scale using just a ratio without needing to create a linear transform with
	// empty offsets.
	LinearTransform tmp(0, lt_to_track_frames.scale, 0);
	bool good = tmp.DoForwardTransform(intermediate, &track_frame_offset);
	DCHECK(good);

	dst.a_zero = job.local_to_output->b_zero;
	dst.b_zero = lt_to_track_frames.b_zero + track_frame_offset;

	// TODO(johngro): Add options to allow us to invert one or both of the ratios
	// during composition instead of needing to make a temporary ratio to
	// acomplish the task.
	LinearTransform::Ratio tmp_ratio(job.local_to_output->scale.denominator,
	job.local_to_output->scale.numerator);
	good = LinearTransform::Ratio::Compose(tmp_ratio,
	lt_to_track_frames.scale,
	&dst.scale);;
	DCHECK(good);

	// Finally, compute the step size in fractional frames. IOW, every time we
	// move forward one output frame, how many fractional frames of input do we
	// consume. Don't bother doing the multiplication if we already know that the
	// numerator is zero.
	//
	// TODO(johngro): same complaint as before... Do this without a temp. The
	// special casing should be handled in the routine added to
	// LinearTransform::Ratio.
	DCHECK(dst.scale.denominator);
	if (!dst.scale.numerator) {
	step_size = 0;
	} else {
	LinearTransform tmp(0, dst.scale, 0);
	int64_t tmp_step_size;

	good = tmp.DoForwardTransform(1, &tmp_step_size);

	DCHECK(good);
	DCHECK_GE(tmp_step_size, 0);
	DCHECK_LE(tmp_step_size, std::numeric_limits<uint32_t>::max());

	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