Simplify AudioSplicer logic which slots buffers before or after a splice point.

media/base/audio_splicer.cc

 // Copyright (c) 2012 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 "media/base/audio_splicer.h"
 
 #include <cstdlib>
 #include <deque>
 
 #include "base/logging.h"
@@ skipping 73 matching lines @@
   // Returns true if the sanitizer has a buffer to return.
   bool HasNextBuffer() const;
 
   // Removes the next buffer from the output buffer queue and returns it; should
   // only be called if HasNextBuffer() returns true.
   scoped_refptr<AudioBuffer> GetNextBuffer();
 
   // Returns the total frame count of all buffers available for output.
   int GetFrameCount() const;
 
-  // Returns the duration of all buffers added to the output queue thus far.
-  base::TimeDelta GetDuration() const;
-
   const AudioTimestampHelper& timestamp_helper() {
     return output_timestamp_helper_;
   }
 
   // Transfer all buffers into |output|.  Returns false if AddInput() on the
   // |output| sanitizer fails for any buffer removed from |this|.
   bool DrainInto(AudioStreamSanitizer* output);
 
  private:
   void AddOutputBuffer(const scoped_refptr<AudioBuffer>& buffer);
@@ skipping 129 matching lines @@
 
 int AudioStreamSanitizer::GetFrameCount() const {
   int frame_count = 0;
   for (BufferQueue::const_iterator it = output_buffers_.begin();
        it != output_buffers_.end(); ++it) {
     frame_count += (*it)->frame_count();
   }
   return frame_count;
 }
 
-base::TimeDelta AudioStreamSanitizer::GetDuration() const {
-  DCHECK(output_timestamp_helper_.base_timestamp() != kNoTimestamp());
-  return output_timestamp_helper_.GetTimestamp() -
-         output_timestamp_helper_.base_timestamp();
-}
-
 bool AudioStreamSanitizer::DrainInto(AudioStreamSanitizer* output) {
   while (HasNextBuffer()) {
     if (!output->AddInput(GetNextBuffer()))
       return false;
   }
   return true;
 }
 
 AudioSplicer::AudioSplicer(int samples_per_second)
     : max_crossfade_duration_(
           base::TimeDelta::FromMilliseconds(kCrossfadeDurationInMilliseconds)),
       splice_timestamp_(kNoTimestamp()),
       max_splice_end_timestamp_(kNoTimestamp()),
       output_sanitizer_(new AudioStreamSanitizer(samples_per_second)),
       pre_splice_sanitizer_(new AudioStreamSanitizer(samples_per_second)),
-      post_splice_sanitizer_(new AudioStreamSanitizer(samples_per_second)) {}
+      post_splice_sanitizer_(new AudioStreamSanitizer(samples_per_second)),
+      have_all_pre_splice_buffers_(false) {}
 
 AudioSplicer::~AudioSplicer() {}
 
 void AudioSplicer::Reset() {
   output_sanitizer_->Reset();
   pre_splice_sanitizer_->Reset();
   post_splice_sanitizer_->Reset();
+  have_all_pre_splice_buffers_ = false;
   reset_splice_timestamps();
 }
 
 bool AudioSplicer::AddInput(const scoped_refptr<AudioBuffer>& input) {
   // If we're not processing a splice, add the input to the output queue.
   if (splice_timestamp_ == kNoTimestamp()) {
     DCHECK(!pre_splice_sanitizer_->HasNextBuffer());
     DCHECK(!post_splice_sanitizer_->HasNextBuffer());
     return output_sanitizer_->AddInput(input);
   }
 
   const AudioTimestampHelper& output_ts_helper =
       output_sanitizer_->timestamp_helper();
 
-  if (!post_splice_sanitizer_->HasNextBuffer()) {
-    // Due to inaccurate demuxer timestamps a splice may have been incorrectly
-    // marked such that the "pre splice buffers" were all entirely before the
-    // splice point.  Here we check for end of stream or buffers which couldn't
-    // possibly be part of the splice.
-    if (input->end_of_stream() ||
-        input->timestamp() >= max_splice_end_timestamp_) {
-      CHECK(pre_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
-      reset_splice_timestamps();
-      return output_sanitizer_->AddInput(input);
-    }
+  if (!have_all_pre_splice_buffers_) {
+    DCHECK(!input->end_of_stream());
 
     // If the provided buffer is entirely before the splice point it can also be
     // added to the output queue.
     if (input->timestamp() + input->duration() < splice_timestamp_) {
       DCHECK(!pre_splice_sanitizer_->HasNextBuffer());
       return output_sanitizer_->AddInput(input);
     }
 
     // If we've encountered the first pre splice buffer, reset the pre splice
     // sanitizer based on |output_sanitizer_|.  This is done so that gaps and
     // overlaps between buffers across the sanitizers are accounted for prior
     // to calculating crossfade.
     if (!pre_splice_sanitizer_->HasNextBuffer()) {
       pre_splice_sanitizer_->ResetTimestampState(
           output_ts_helper.frame_count(), output_ts_helper.base_timestamp());
     }
 
-    // The first overlapping buffer is expected to have a timestamp of exactly
-    // |splice_timestamp_|.  Until that timestamp is seen, all buffers go into
-    // |pre_splice_sanitizer_|.
-    if (!pre_splice_sanitizer_->HasNextBuffer() ||
-        input->timestamp() != splice_timestamp_) {
-      return pre_splice_sanitizer_->AddInput(input);
-    }
+    return pre_splice_sanitizer_->AddInput(input);
+  }
 
-    // We've received the first overlapping buffer.
-  } else if (!input->end_of_stream() &&
-             input->timestamp() == splice_timestamp_) {
-    // In this case we accidentally put a pre splice buffer in the post splice
-    // sanitizer, so we need to recover by transferring all current post splice
-    // buffers into the pre splice sanitizer and continuing with the splice.
-    post_splice_sanitizer_->DrainInto(pre_splice_sanitizer_.get());
-    post_splice_sanitizer_->Reset();
-  }
+  // The first post splice buffer is expected to match |splice_timestamp_|.
+  if (!post_splice_sanitizer_->HasNextBuffer())
+    DCHECK(splice_timestamp_ == input->timestamp());
 
   // At this point we have all the fade out preroll buffers from the decoder.
   // We now need to wait until we have enough data to perform the crossfade (or
   // we receive an end of stream).
   if (!post_splice_sanitizer_->AddInput(input))
     return false;
 
   // Ensure |output_sanitizer_| has a valid base timestamp so we can use it for
   // timestamp calculations.
   if (output_ts_helper.base_timestamp() == kNoTimestamp()) {
     output_sanitizer_->ResetTimestampState(
         0, pre_splice_sanitizer_->timestamp_helper().base_timestamp());
   }
 
   // If a splice frame was incorrectly marked due to poor demuxed timestamps, we
   // may not actually have a splice.  Here we check if any frames exist before
   // the splice.  In this case, just transfer all data to the output sanitizer.
   if (pre_splice_sanitizer_->GetFrameCount() <=
       output_ts_helper.GetFramesToTarget(splice_timestamp_)) {
     CHECK(pre_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
     CHECK(post_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
     reset_splice_timestamps();
     return true;
   }
 
-  // Since it's possible that a pre splice buffer after the first might have its
-  // timestamp fuzzed to be |splice_timestamp_| we need to always wait until we
-  // have seen all possible post splice buffers to ensure we didn't mistakenly
-  // put a pre splice buffer into the post splice sanitizer.
-  if (!input->end_of_stream() && input->timestamp() < max_splice_end_timestamp_)
+  // Wait until we have enough data to crossfade or end of stream.
+  if (!input->end_of_stream() &&
+      input->timestamp() + input->duration() < max_splice_end_timestamp_) {
     return true;
+  }
 
   scoped_refptr<AudioBuffer> crossfade_buffer;
   scoped_ptr<AudioBus> pre_splice =
       ExtractCrossfadeFromPreSplice(&crossfade_buffer);
 
   // Crossfade the pre splice and post splice sections and transfer all relevant
   // buffers into |output_sanitizer_|.
   CrossfadePostSplice(pre_splice.Pass(), crossfade_buffer);
 
   // Clear the splice timestamp so new splices can be accepted.
   reset_splice_timestamps();
   return true;
 }
 
 bool AudioSplicer::HasNextBuffer() const {
   return output_sanitizer_->HasNextBuffer();
 }
 
 scoped_refptr<AudioBuffer> AudioSplicer::GetNextBuffer() {
   return output_sanitizer_->GetNextBuffer();
 }
 
 void AudioSplicer::SetSpliceTimestamp(base::TimeDelta splice_timestamp) {
-  DCHECK(splice_timestamp != kNoTimestamp());
+  if (splice_timestamp == kNoTimestamp()) {
+    DCHECK(splice_timestamp_ != kNoTimestamp());
+    DCHECK(!have_all_pre_splice_buffers_);
+    have_all_pre_splice_buffers_ = true;
+    return;
+  }
+
   if (splice_timestamp_ == splice_timestamp)
     return;
 
   // TODO(dalecurtis): We may need the concept of a future_splice_timestamp_ to
   // handle cases where another splice comes in before we've received 5ms of
   // data from the last one.  Leave this as a CHECK for now to figure out if
   // this case is possible.
   CHECK(splice_timestamp_ == kNoTimestamp());
   splice_timestamp_ = splice_timestamp;
   max_splice_end_timestamp_ = splice_timestamp_ + max_crossfade_duration_;
   pre_splice_sanitizer_->Reset();
   post_splice_sanitizer_->Reset();
+  have_all_pre_splice_buffers_ = false;
 }
 
 scoped_ptr<AudioBus> AudioSplicer::ExtractCrossfadeFromPreSplice(
     scoped_refptr<AudioBuffer>* crossfade_buffer) {
   DCHECK(crossfade_buffer);
   const AudioTimestampHelper& output_ts_helper =
       output_sanitizer_->timestamp_helper();
 
   int frames_before_splice =
       output_ts_helper.GetFramesToTarget(splice_timestamp_);
@@ skipping 120 matching lines @@
     AccurateTrimStart(frames_to_trim, remainder, output_ts_helper);
     CHECK(output_sanitizer_->AddInput(remainder));
   }
 
   // Transfer all remaining buffers out and reset once empty.
   CHECK(post_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
   post_splice_sanitizer_->Reset();
 }
 
 }  // namespace media