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

media/base/audio_splicer_unittest.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 "base/memory/scoped_ptr.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/buffers.h"
@@ skipping 173 matching lines @@
 
   // Add some bytes to the timestamp helper so that the
   // next buffer starts many frames beyond the end of
   // |input_1|. This is to make sure that Reset() actually
   // clears its state and doesn't try to insert a gap.
   input_timestamp_helper_.AddFrames(100);
 
   // Verify that a new input buffer passes through as expected.
   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
   EXPECT_TRUE(AddInput(input_2));
-  ASSERT_TRUE(splicer_.HasNextBuffer());
   VerifyNextBuffer(input_2);
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 TEST_F(AudioSplicerTest, EndOfStream) {
   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
   scoped_refptr<AudioBuffer> input_2 = AudioBuffer::CreateEOSBuffer();
   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.2f);
   EXPECT_TRUE(input_2->end_of_stream());
 
@@ skipping 121 matching lines @@
   input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
   input_timestamp_helper_.AddFrames(input_1->frame_count() - kOverlapSize);
 
   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
 
   EXPECT_TRUE(AddInput(input_1));
   EXPECT_TRUE(AddInput(input_2));
 
   // Verify that the first input buffer passed through unmodified.
   VerifyNextBuffer(input_1);
+
   ASSERT_TRUE(splicer_.HasNextBuffer());
-
   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // Verify that the second input buffer was truncated to only contain
   // the samples that are after the end of |input_1|.
   base::TimeDelta expected_timestamp =
       input_1->timestamp() + input_1->duration();
   base::TimeDelta expected_duration =
       (input_2->timestamp() + input_2->duration()) - expected_timestamp;
   EXPECT_EQ(expected_timestamp, output_2->timestamp());
@@ skipping 77 matching lines @@
   // |extra_pre_splice_buffer| is entirely before the splice and should be ready
   // for output.
   EXPECT_TRUE(AddInput(extra_pre_splice_buffer));
   VerifyNextBuffer(extra_pre_splice_buffer);
 
   // The splicer should be internally queuing input since |overlapped_buffer| is
   // part of the splice.
   EXPECT_TRUE(AddInput(overlapped_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
-  // Even though |overlapping_buffer| completes the splice, one extra buffer is
-  // required to confirm it's actually a splice.
+  // |overlapping_buffer| completes the splice.
+  splicer_.SetSpliceTimestamp(kNoTimestamp());
   EXPECT_TRUE(AddInput(overlapping_buffer));
-  EXPECT_FALSE(splicer_.HasNextBuffer());
+  ASSERT_TRUE(splicer_.HasNextBuffer());
 
   // Add one more buffer to make sure it's passed through untouched.
   scoped_refptr<AudioBuffer> extra_post_splice_buffer =
       GetNextInputBuffer(0.5f, kBufferSize);
   EXPECT_TRUE(AddInput(extra_post_splice_buffer));
 
   VerifyPreSpliceOutput(overlapped_buffer,
                         overlapping_buffer,
                         221,
                         base::TimeDelta::FromMicroseconds(5012));
@@ skipping 53 matching lines @@
   scoped_refptr<AudioBuffer> overlapping_buffer =
       GetNextInputBuffer(0.0f, kCrossfadeSize / 3);
 
   // The splicer should be internally queuing input since |overlapped_buffer| is
   // part of the splice.
   EXPECT_TRUE(AddInput(overlapped_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |overlapping_buffer| should not have enough data to complete the splice, so
   // ensure output is not available.
+  splicer_.SetSpliceTimestamp(kNoTimestamp());
   EXPECT_TRUE(AddInput(overlapping_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // Now add an EOS buffer which should complete the splice.
   EXPECT_TRUE(AddInput(AudioBuffer::CreateEOSBuffer()));
-  ASSERT_TRUE(splicer_.HasNextBuffer());
 
   VerifyPreSpliceOutput(overlapped_buffer,
                         overlapping_buffer,
                         331,
                         base::TimeDelta::FromMicroseconds(7505));
   VerifyCrossfadeOutput(overlapped_buffer,
                         NULL,
                         overlapping_buffer,
                         0,
                         overlapping_buffer->frame_count(),
@@ skipping 33 matching lines @@
   input_timestamp_helper_.AddFrames(overlapped_buffer->frame_count() / 2);
   splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
   scoped_refptr<AudioBuffer> overlapping_buffer =
       GetNextInputBuffer(0.0f, kCrossfadeSize * 2);
 
   // The splicer should be internally queuing input since |overlapped_buffer| is
   // part of the splice.
   EXPECT_TRUE(AddInput(overlapped_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
-  // Even though |overlapping_buffer| completes the splice, one extra buffer is
-  // required to confirm it's actually a splice.
+  // |overlapping_buffer| completes the splice.
+  splicer_.SetSpliceTimestamp(kNoTimestamp());
   EXPECT_TRUE(AddInput(overlapping_buffer));
-  EXPECT_FALSE(splicer_.HasNextBuffer());
-
-  // Add an EOS buffer to complete the splice.
-  EXPECT_TRUE(AddInput(AudioBuffer::CreateEOSBuffer()));
-  ASSERT_TRUE(splicer_.HasNextBuffer());
 
   const int kExpectedPreSpliceSize = 55;
   const base::TimeDelta kExpectedPreSpliceDuration =
       base::TimeDelta::FromMicroseconds(1247);
   VerifyPreSpliceOutput(overlapped_buffer,
                         overlapping_buffer,
                         kExpectedPreSpliceSize,
                         kExpectedPreSpliceDuration);
   VerifyCrossfadeOutput(overlapped_buffer,
                         NULL,
                         overlapping_buffer,
                         0,
                         kExpectedPreSpliceSize,
                         kExpectedPreSpliceDuration);
 
   // Retrieve the remaining portion after crossfade.
   ASSERT_TRUE(splicer_.HasNextBuffer());
   scoped_refptr<AudioBuffer> post_splice_output = splicer_.GetNextBuffer();
   EXPECT_EQ(overlapping_buffer->timestamp() + kExpectedPreSpliceDuration,
             post_splice_output->timestamp());
   EXPECT_EQ(overlapping_buffer->frame_count() - kExpectedPreSpliceSize,
             post_splice_output->frame_count());
   EXPECT_EQ(overlapping_buffer->duration() - kExpectedPreSpliceDuration,
             post_splice_output->duration());
 
   EXPECT_TRUE(VerifyData(post_splice_output, GetValue(overlapping_buffer)));
-
-  post_splice_output = splicer_.GetNextBuffer();
-  EXPECT_TRUE(post_splice_output->end_of_stream());
-
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 // Test behavior when a splice frame is incorrectly marked and does not actually
 // overlap.
 // +----------+
 // |1111111111|
 // +----------+
 //            +--------------+
 //            |22222222222222|
@@ skipping 16 matching lines @@
   scoped_refptr<AudioBuffer> second_buffer =
       GetNextInputBuffer(0.0f, kBufferSize);
 
   // The splicer should be internally queuing input since |first_buffer| is part
   // of the supposed splice.
   EXPECT_TRUE(AddInput(first_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |second_buffer| should complete the supposed splice, so ensure output is
   // now available.
+  splicer_.SetSpliceTimestamp(kNoTimestamp());
   EXPECT_TRUE(AddInput(second_buffer));
-  ASSERT_TRUE(splicer_.HasNextBuffer());
 
   VerifyNextBuffer(first_buffer);
   VerifyNextBuffer(second_buffer);
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 // Test behavior when a splice frame is incorrectly marked and there is a gap
 // between whats in the pre splice and post splice.
 // +--------+
 // |11111111|
@@ skipping 14 matching lines @@
       GetNextInputBuffer(1.0f, kBufferSize - kGapSize);
   scoped_refptr<AudioBuffer> gap_buffer =
       GetNextInputBuffer(0.0f, kGapSize);
   splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
   scoped_refptr<AudioBuffer> second_buffer =
       GetNextInputBuffer(0.0f, kBufferSize);
 
   // The splicer should pass through the first buffer since it's not part of the
   // splice.
   EXPECT_TRUE(AddInput(first_buffer));
-  EXPECT_TRUE(splicer_.HasNextBuffer());
   VerifyNextBuffer(first_buffer);
 
   // Do not add |gap_buffer|.
 
-  // |second_buffer| will trigger an exact overlap splice check.
+  // |second_buffer| will complete the supposed splice.
+  splicer_.SetSpliceTimestamp(kNoTimestamp());
   EXPECT_TRUE(AddInput(second_buffer));
-  EXPECT_FALSE(splicer_.HasNextBuffer());
-
-  // When the next buffer is not an exact overlap, the bad splice detection code
-  // will kick in and release the buffers.
-  EXPECT_TRUE(AddInput(AudioBuffer::CreateEOSBuffer()));
-  ASSERT_TRUE(splicer_.HasNextBuffer());
 
   VerifyNextBuffer(gap_buffer);
   VerifyNextBuffer(second_buffer);
-  scoped_refptr<AudioBuffer> eos_buffer = splicer_.GetNextBuffer();
-  EXPECT_TRUE(eos_buffer->end_of_stream());
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
-// Test behavior when a splice frame gets fuzzed such that there is a pre splice
-// buffer after the first which has a timestamp equal to the splice timestamp.
-// +-----------+
-// |11111111111|
-// +-----------+
-//           +-------+
-//           |2222222|
-//           +-------+
-//           +--------------+
-//           |33333333333333|
-//           +--------------+
-// Results in:
-// +---------+--------------+
-// |111111111|xyyyyyy3333333|
-// +---------+--------------+
-// Where x represents a crossfade between buffers 1 and 3; while y is a
-// crossfade between buffers 2 and 3.
-TEST_F(AudioSplicerTest, SpliceIncorrectlySlotted) {
-  const int kBufferSize =
-      input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration());
-  const int kOverlapSize = 2;
-
-  scoped_refptr<AudioBuffer> buffer_1 =
-      GetNextInputBuffer(1.0f, kBufferSize + kOverlapSize);
-  input_timestamp_helper_.SetBaseTimestamp(buffer_1->timestamp());
-  input_timestamp_helper_.AddFrames(kBufferSize);
-
-  const base::TimeDelta splice_timestamp =
-      input_timestamp_helper_.GetTimestamp();
-  splicer_.SetSpliceTimestamp(splice_timestamp);
-
-  scoped_refptr<AudioBuffer> buffer_2 = GetNextInputBuffer(0.5f, kBufferSize);
-
-  // Create an overlap buffer which is just short of the crossfade size.
-  input_timestamp_helper_.SetBaseTimestamp(splice_timestamp);
-  scoped_refptr<AudioBuffer> buffer_3 =
-      GetNextInputBuffer(0.0f, kBufferSize - kOverlapSize);
-
-  // The splicer should be internally queuing input since |buffer_1| is part of
-  // the supposed splice.
-  EXPECT_TRUE(AddInput(buffer_1));
-  EXPECT_FALSE(splicer_.HasNextBuffer());
-
-  // Adding |buffer_2| should look like a completion of the splice, but still no
-  // buffer should be handed out.
-  EXPECT_TRUE(AddInput(buffer_2));
-  EXPECT_FALSE(splicer_.HasNextBuffer());
-
-  // Adding |buffer_3| should complete the splice correctly, but there is still
-  // not enough data for crossfade, so it shouldn't return yet.
-  EXPECT_TRUE(AddInput(buffer_3));
-  EXPECT_FALSE(splicer_.HasNextBuffer());
-
-  // Add an EOS buffer which should trigger completion of the splice.
-  EXPECT_TRUE(AddInput(AudioBuffer::CreateEOSBuffer()));
-  ASSERT_TRUE(splicer_.HasNextBuffer());
-
-  const int kExpectedPreSpliceSize = kBufferSize;
-  const base::TimeDelta kExpectedPreSpliceDuration = splice_timestamp;
-  const base::TimeDelta kExpectedCrossfadeDuration =
-      base::TimeDelta::FromMicroseconds(4966);
-  VerifyPreSpliceOutput(
-      buffer_1, buffer_3, kExpectedPreSpliceSize, kExpectedPreSpliceDuration);
-  VerifyCrossfadeOutput(buffer_1,
-                        buffer_2,
-                        buffer_3,
-                        kOverlapSize,
-                        buffer_3->frame_count(),
-                        kExpectedCrossfadeDuration);
-
-  scoped_refptr<AudioBuffer> eos_buffer = splicer_.GetNextBuffer();
-  EXPECT_TRUE(eos_buffer->end_of_stream());
-
-  EXPECT_FALSE(splicer_.HasNextBuffer());
-}
-
 }  // namespace media