Enhance AudioSplicer to crossfade marked splice frames.

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"
 #include "media/base/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 static const SampleFormat kSampleFormat = kSampleFormatF32;
 static const int kChannels = 1;
 static const int kDefaultSampleRate = 44100;
 static const int kDefaultBufferSize = 100;
 
 class AudioSplicerTest : public ::testing::Test {
  public:
   AudioSplicerTest()
       : splicer_(kDefaultSampleRate),
-        input_timestamp_helper_(kDefaultSampleRate) {
+        input_timestamp_helper_(kDefaultSampleRate),
+        output_timestamp_helper_(kDefaultSampleRate) {
     input_timestamp_helper_.SetBaseTimestamp(base::TimeDelta());
+    output_timestamp_helper_.SetBaseTimestamp(base::TimeDelta());
   }
 
   scoped_refptr<AudioBuffer> GetNextInputBuffer(float value) {
     return GetNextInputBuffer(value, kDefaultBufferSize);
   }
 
   scoped_refptr<AudioBuffer> GetNextInputBuffer(float value, int frame_size) {
     scoped_refptr<AudioBuffer> buffer = MakeInterleavedAudioBuffer<float>(
         kSampleFormat,
         kChannels,
         value,
         0.0f,
         frame_size,
         input_timestamp_helper_.GetTimestamp(),
         input_timestamp_helper_.GetFrameDuration(frame_size));
     input_timestamp_helper_.AddFrames(frame_size);
     return buffer;
   }
 
-  bool VerifyData(scoped_refptr<AudioBuffer> buffer, float value) {
+  bool VerifyData(const scoped_refptr<AudioBuffer>& buffer, float value) {
     int frames = buffer->frame_count();
     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
     buffer->ReadFrames(frames, 0, 0, bus.get());
-    for (int i = 0; i < frames; ++i) {
-      if (bus->channel(0)[i] != value)
-        return false;
+    for (int ch = 0; ch < buffer->channel_count(); ++ch) {
+      for (int i = 0; i < frames; ++i) {
+        if (bus->channel(ch)[i] != value)
+          return false;
+      }
     }
     return true;
   }
 
+  void VerifyNextBuffer(const scoped_refptr<AudioBuffer>& input, float value) {
+    ASSERT_TRUE(splicer_.HasNextBuffer());
+    scoped_refptr<AudioBuffer> output = splicer_.GetNextBuffer();
+    EXPECT_EQ(input->timestamp(), output->timestamp());
+    EXPECT_EQ(input->duration(), output->duration());
+    EXPECT_EQ(input->frame_count(), output->frame_count());
+    EXPECT_TRUE(VerifyData(output, value));
+    output_timestamp_helper_.AddFrames(output->frame_count());
+  }
+
+  void VerifyPreSpliceOutput(
+      const scoped_refptr<AudioBuffer>& overlapped_buffer,
+      const scoped_refptr<AudioBuffer>& overlapping_buffer,
+      float overlapped_value) {
+    const base::TimeDelta kSpliceTimestamp = overlapping_buffer->timestamp();
+    const int kExpectedPreSpliceSize =
+        output_timestamp_helper_.GetFramesToTarget(kSpliceTimestamp);
+    const base::TimeDelta kExpectedPreSpliceDuration =
+        output_timestamp_helper_.GetFrameDuration(kExpectedPreSpliceSize);
+
+    ASSERT_TRUE(splicer_.HasNextBuffer());
+    scoped_refptr<AudioBuffer> pre_splice_output = splicer_.GetNextBuffer();
+    EXPECT_EQ(overlapped_buffer->timestamp(), pre_splice_output->timestamp());
+    EXPECT_EQ(kExpectedPreSpliceDuration, pre_splice_output->duration());
+    EXPECT_EQ(kExpectedPreSpliceSize, pre_splice_output->frame_count());
+    EXPECT_TRUE(VerifyData(pre_splice_output, overlapped_value));
+    output_timestamp_helper_.AddFrames(pre_splice_output->frame_count());
+  }
+
+  base::TimeDelta CalculateCrossfadeDuration(
+      const scoped_refptr<AudioBuffer>& overlapped_buffer,
+      const scoped_refptr<AudioBuffer>& overlapping_buffer) {
+    return std::min(max_crossfade_duration(),
+                    std::min(overlapped_buffer->timestamp() +
+                                 overlapped_buffer->duration() -
+                                 overlapping_buffer->timestamp(),
+                             overlapping_buffer->duration()));
+  }
+
+  void VerifyCrossfadeOutput(
+      const scoped_refptr<AudioBuffer>& overlapped_buffer,
+      const scoped_refptr<AudioBuffer>& overlapping_buffer,
+      float overlapped_value,
+      float overlapping_value,
+      base::TimeDelta* expected_crossfade_duration,
+      int64* expected_crossfade_size) {
+    ASSERT_TRUE(splicer_.HasNextBuffer());
+
+    const base::TimeDelta kSpliceTimestamp =

[acolwell GONE FROM CHROMIUM, 2014/02/27 17:10:14]

I'm a little concerned that we are trying to replicate too much of the real
logic in the tests. How about just verifying the timestamps, durations, and
sizes against constants instead? It would allow us to determine if the behavior
changes. You could probably also just summarize the crossfade by summing all the
samples and comparing it to frame_count * (a + b) / 2. I think that would result
in far less test code.

[DaleCurtis, 2014/02/27 19:45:01]

I generally dislike constant only verification in test code since they're: a)
hard to maintain. b) not explanatory.  They're more a test of "ensure this
doesn't change" rather than a correctness test.  However I am wary that this may
silently adapt to incorrect changes since it bases expected timestamps based on
what's handed out.  The correctness verification is subtle.

The constants in this case are slightly confusing too they won't match exactly
what the buffers are constructed with.  They're off by a microsecond here or
there depend on floating point precision (which means these values may be
different on ARM too).

We can try it though and see what happens.

[DaleCurtis, 2014/02/28 00:24:41]

Mostly done.  I also cleaned up the verify syntax.  I've left the crossfade
verification in because your proposal wouldn't be any shorter.

+        output_timestamp_helper_.GetTimestamp();
+    *expected_crossfade_size = output_timestamp_helper_.GetFramesToTarget(
+        kSpliceTimestamp +
+        CalculateCrossfadeDuration(overlapped_buffer, overlapping_buffer));
+    // Don't use the calculated duration directly as it may differ in truthiness
+    // by a few microseconds from what the AudioTimestampHelper is returning.
+    *expected_crossfade_duration =
+        output_timestamp_helper_.GetFrameDuration(*expected_crossfade_size);
+
+    scoped_refptr<AudioBuffer> crossfade_output = splicer_.GetNextBuffer();
+    EXPECT_EQ(kSpliceTimestamp, crossfade_output->timestamp());
+    EXPECT_EQ(*expected_crossfade_duration, crossfade_output->duration());
+    EXPECT_EQ(*expected_crossfade_size, crossfade_output->frame_count());
+    output_timestamp_helper_.AddFrames(crossfade_output->frame_count());
+
+    // Verify the actual crossfade.
+    const int frames = crossfade_output->frame_count();
+    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
+    crossfade_output->ReadFrames(frames, 0, 0, bus.get());
+    for (int ch = 0; ch < crossfade_output->channel_count(); ++ch) {
+      float cf_ratio = 0;
+      const float cf_increment = 1.0f / frames;
+      for (int i = 0; i < frames; ++i, cf_ratio += cf_increment) {
+        const float actual = bus->channel(ch)[i];
+        const float expected =
+            (1.0f - cf_ratio) * overlapped_value + cf_ratio * overlapping_value;
+        ASSERT_FLOAT_EQ(expected, actual) << "i=" << i;
+      }
+    }
+  }
+
+  bool AddInput(const scoped_refptr<AudioBuffer>& input) {
+    // Since the splicer doesn't make copies it's working directly on the input
+    // buffers.  We must make a copy before adding to ensure the original buffer
+    // is not modified in unexpected ways.
+    scoped_refptr<AudioBuffer> buffer_copy =
+        input->end_of_stream()
+            ? AudioBuffer::CreateEOSBuffer()
+            : AudioBuffer::CopyFrom(kSampleFormat,
+                                    input->channel_count(),
+                                    input->frame_count(),
+                                    &input->channel_data()[0],
+                                    input->timestamp(),
+                                    input->duration());
+    return splicer_.AddInput(buffer_copy);
+  }
+
+  base::TimeDelta max_crossfade_duration() {
+    return splicer_.max_crossfade_duration_;
+  }
+
  protected:
   AudioSplicer splicer_;
   AudioTimestampHelper input_timestamp_helper_;
+  AudioTimestampHelper output_timestamp_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioSplicerTest);
 };
 
 TEST_F(AudioSplicerTest, PassThru) {
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // Test single buffer pass-thru behavior.
   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
-  EXPECT_TRUE(splicer_.AddInput(input_1));
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-
-  scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
+  EXPECT_TRUE(AddInput(input_1));
+  VerifyNextBuffer(input_1, 0.1f);
   EXPECT_FALSE(splicer_.HasNextBuffer());
-  EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
-  EXPECT_EQ(input_1->duration(), output_1->duration());
-  EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
-  EXPECT_TRUE(VerifyData(output_1, 0.1f));
 
   // Test that multiple buffers can be queued in the splicer.
   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
-  EXPECT_TRUE(splicer_.AddInput(input_2));
-  EXPECT_TRUE(splicer_.AddInput(input_3));
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-
-  scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-  EXPECT_EQ(input_2->timestamp(), output_2->timestamp());
-  EXPECT_EQ(input_2->duration(), output_2->duration());
-  EXPECT_EQ(input_2->frame_count(), output_2->frame_count());
-
-  scoped_refptr<AudioBuffer> output_3 = splicer_.GetNextBuffer();
+  EXPECT_TRUE(AddInput(input_2));
+  EXPECT_TRUE(AddInput(input_3));
+  VerifyNextBuffer(input_2, 0.2f);
+  VerifyNextBuffer(input_3, 0.3f);
   EXPECT_FALSE(splicer_.HasNextBuffer());
-  EXPECT_EQ(input_3->timestamp(), output_3->timestamp());
-  EXPECT_EQ(input_3->duration(), output_3->duration());
-  EXPECT_EQ(input_3->frame_count(), output_3->frame_count());
 }
 
 TEST_F(AudioSplicerTest, Reset) {
   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
-  EXPECT_TRUE(splicer_.AddInput(input_1));
-  EXPECT_TRUE(splicer_.HasNextBuffer());
+  EXPECT_TRUE(AddInput(input_1));
+  ASSERT_TRUE(splicer_.HasNextBuffer());
 
   splicer_.Reset();
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // 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(splicer_.AddInput(input_2));
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-
-  scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
+  EXPECT_TRUE(AddInput(input_2));
+  ASSERT_TRUE(splicer_.HasNextBuffer());
+  VerifyNextBuffer(input_2, 0.2f);
   EXPECT_FALSE(splicer_.HasNextBuffer());
-  EXPECT_EQ(input_2->timestamp(), output_2->timestamp());
-  EXPECT_EQ(input_2->duration(), output_2->duration());
-  EXPECT_EQ(input_2->frame_count(), output_2->frame_count());
 }
 
 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());
 
-  EXPECT_TRUE(splicer_.AddInput(input_1));
-  EXPECT_TRUE(splicer_.AddInput(input_2));
-  EXPECT_TRUE(splicer_.HasNextBuffer());
+  EXPECT_TRUE(AddInput(input_1));
+  EXPECT_TRUE(AddInput(input_2));
 
-  scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
+  VerifyNextBuffer(input_1, 0.1f);
+
   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
   EXPECT_FALSE(splicer_.HasNextBuffer());
-  EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
-  EXPECT_EQ(input_1->duration(), output_1->duration());
-  EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
-
   EXPECT_TRUE(output_2->end_of_stream());
 
   // Verify that buffers can be added again after Reset().
   splicer_.Reset();
-  EXPECT_TRUE(splicer_.AddInput(input_3));
-  scoped_refptr<AudioBuffer> output_3 = splicer_.GetNextBuffer();
+  EXPECT_TRUE(AddInput(input_3));
+  VerifyNextBuffer(input_3, 0.2f);
   EXPECT_FALSE(splicer_.HasNextBuffer());
-  EXPECT_EQ(input_3->timestamp(), output_3->timestamp());
-  EXPECT_EQ(input_3->duration(), output_3->duration());
-  EXPECT_EQ(input_3->frame_count(), output_3->frame_count());
 }
 
-
 // Test the gap insertion code.
 // +--------------+    +--------------+
 // |11111111111111|    |22222222222222|
 // +--------------+    +--------------+
 // Results in:
 // +--------------+----+--------------+
 // |11111111111111|0000|22222222222222|
 // +--------------+----+--------------+
 TEST_F(AudioSplicerTest, GapInsertion) {
   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
 
   // Add bytes to the timestamp helper so that the next buffer
   // will have a starting timestamp that indicates a gap is
   // present.
   const int kGapSize = 7;
   input_timestamp_helper_.AddFrames(kGapSize);
   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
 
-  EXPECT_TRUE(splicer_.AddInput(input_1));
-  EXPECT_TRUE(splicer_.AddInput(input_2));
-
-  // Verify that a gap buffer is generated.
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-  scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
-  scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
-  scoped_refptr<AudioBuffer> output_3 = splicer_.GetNextBuffer();
-  EXPECT_FALSE(splicer_.HasNextBuffer());
+  EXPECT_TRUE(AddInput(input_1));
+  EXPECT_TRUE(AddInput(input_2));
 
   // Verify that the first input buffer passed through unmodified.
-  EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
-  EXPECT_EQ(input_1->duration(), output_1->duration());
-  EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
-  EXPECT_TRUE(VerifyData(output_1, 0.1f));
+  VerifyNextBuffer(input_1, 0.1f);
 
   // Verify the contents of the gap buffer.
+  scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
   base::TimeDelta gap_timestamp =
       input_1->timestamp() + input_1->duration();
   base::TimeDelta gap_duration = input_2->timestamp() - gap_timestamp;
   EXPECT_GT(gap_duration, base::TimeDelta());
   EXPECT_EQ(gap_timestamp, output_2->timestamp());
   EXPECT_EQ(gap_duration, output_2->duration());
   EXPECT_EQ(kGapSize, output_2->frame_count());
   EXPECT_TRUE(VerifyData(output_2, 0.0f));
 
   // Verify that the second input buffer passed through unmodified.
-  EXPECT_EQ(input_2->timestamp(), output_3->timestamp());
-  EXPECT_EQ(input_2->duration(), output_3->duration());
-  EXPECT_EQ(input_2->frame_count(), output_3->frame_count());
-  EXPECT_TRUE(VerifyData(output_3, 0.2f));
+  VerifyNextBuffer(input_2, 0.2f);
+  EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
-
 // Test that an error is signalled when the gap between input buffers is
 // too large.
 TEST_F(AudioSplicerTest, GapTooLarge) {
   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
 
   // Add a seconds worth of bytes so that an unacceptably large
   // gap exists between |input_1| and |input_2|.
   const int kGapSize = kDefaultSampleRate;
   input_timestamp_helper_.AddFrames(kGapSize);
   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
 
-  EXPECT_TRUE(splicer_.AddInput(input_1));
-  EXPECT_FALSE(splicer_.AddInput(input_2));
+  EXPECT_TRUE(AddInput(input_1));
+  EXPECT_FALSE(AddInput(input_2));
 
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-  scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
-
-  // Verify that the first input buffer passed through unmodified.
-  EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
-  EXPECT_EQ(input_1->duration(), output_1->duration());
-  EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
-  EXPECT_TRUE(VerifyData(output_1, 0.1f));
+  VerifyNextBuffer(input_1, 0.1f);
 
   // Verify that the second buffer is not available.
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // Reset the timestamp helper so it can generate a buffer that is
   // right after |input_1|.
   input_timestamp_helper_.SetBaseTimestamp(
       input_1->timestamp() + input_1->duration());
 
   // Verify that valid buffers are still accepted.
   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
-  EXPECT_TRUE(splicer_.AddInput(input_3));
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-  scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
+  EXPECT_TRUE(AddInput(input_3));
+  VerifyNextBuffer(input_3, 0.3f);
   EXPECT_FALSE(splicer_.HasNextBuffer());
-  EXPECT_EQ(input_3->timestamp(), output_2->timestamp());
-  EXPECT_EQ(input_3->duration(), output_2->duration());
-  EXPECT_EQ(input_3->frame_count(), output_2->frame_count());
-  EXPECT_TRUE(VerifyData(output_2, 0.3f));
 }
 
-
 // Verifies that an error is signalled if AddInput() is called
 // with a timestamp that is earlier than the first buffer added.
 TEST_F(AudioSplicerTest, BufferAddedBeforeBase) {
   input_timestamp_helper_.SetBaseTimestamp(
       base::TimeDelta::FromMicroseconds(10));
   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
 
   // Reset the timestamp helper so the next buffer will have a timestamp earlier
   // than |input_1|.
   input_timestamp_helper_.SetBaseTimestamp(base::TimeDelta::FromSeconds(0));
   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.1f);
 
   EXPECT_GT(input_1->timestamp(), input_2->timestamp());
-  EXPECT_TRUE(splicer_.AddInput(input_1));
-  EXPECT_FALSE(splicer_.AddInput(input_2));
+  EXPECT_TRUE(AddInput(input_1));
+  EXPECT_FALSE(AddInput(input_2));
 }
 
-
 // Test when one buffer partially overlaps another.
 // +--------------+
 // |11111111111111|
 // +--------------+
 //            +--------------+
 //            |22222222222222|
 //            +--------------+
 // Results in:
 // +--------------+----------+
 // |11111111111111|2222222222|
 // +--------------+----------+
 TEST_F(AudioSplicerTest, PartialOverlap) {
   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
 
   // Reset timestamp helper so that the next buffer will have a
   // timestamp that starts in the middle of |input_1|.
   const int kOverlapSize = input_1->frame_count() / 4;
   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(splicer_.AddInput(input_1));
-  EXPECT_TRUE(splicer_.AddInput(input_2));
+  EXPECT_TRUE(AddInput(input_1));
+  EXPECT_TRUE(AddInput(input_2));
 
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-  scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
+  // Verify that the first input buffer passed through unmodified.
+  VerifyNextBuffer(input_1, 0.1f);
+  ASSERT_TRUE(splicer_.HasNextBuffer());
+
   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
-  // Verify that the first input buffer passed through unmodified.
-  EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
-  EXPECT_EQ(input_1->duration(), output_1->duration());
-  EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
-  EXPECT_TRUE(VerifyData(output_1, 0.1f));
-
   // Verify that the second input buffer was truncated to only contain
-  // the samples that are after the end of |input_1|. Note that data is not
-  // copied, so |input_2|'s values are modified.
+  // 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());
   EXPECT_EQ(expected_duration, output_2->duration());
   EXPECT_TRUE(VerifyData(output_2, 0.2f));
 }
 
-
 // Test that an input buffer that is completely overlapped by a buffer
 // that was already added is dropped.
 // +--------------+
 // |11111111111111|
 // +--------------+
 //       +-----+
 //       |22222|
 //       +-----+
 //                +-------------+
 //                |3333333333333|
@@ skipping 13 matching lines @@
   input_timestamp_helper_.AddFrames(kOverlapOffset);
 
   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f, kOverlapSize);
 
   // Reset the timestamp helper so the next buffer will be right after
   // |input_1|.
   input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
   input_timestamp_helper_.AddFrames(input_1->frame_count());
   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
 
-  EXPECT_TRUE(splicer_.AddInput(input_1));
-  EXPECT_TRUE(splicer_.AddInput(input_2));
-  EXPECT_TRUE(splicer_.AddInput(input_3));
-
-  EXPECT_TRUE(splicer_.HasNextBuffer());
-  scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
-  scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
-  EXPECT_FALSE(splicer_.HasNextBuffer());
-
-  // Verify that the first input buffer passed through unmodified.
-  EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
-  EXPECT_EQ(input_1->duration(), output_1->duration());
-  EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
-  EXPECT_TRUE(VerifyData(output_1, 0.1f));
-
-  // Verify that the second output buffer only contains
-  // the samples that are in |input_3|.
-  EXPECT_EQ(input_3->timestamp(), output_2->timestamp());
-  EXPECT_EQ(input_3->duration(), output_2->duration());
-  EXPECT_EQ(input_3->frame_count(), output_2->frame_count());
-  EXPECT_TRUE(VerifyData(output_2, 0.3f));
+  EXPECT_TRUE(AddInput(input_1));
+  EXPECT_TRUE(AddInput(input_2));
+  EXPECT_TRUE(AddInput(input_3));
+
+  VerifyNextBuffer(input_1, 0.1f);
+  VerifyNextBuffer(input_3, 0.3f);
+  EXPECT_FALSE(splicer_.HasNextBuffer());
+}
+
+// Test crossfade when one buffer partially overlaps another.
+// +--------------+
+// |11111111111111|
+// +--------------+
+//            +--------------+
+//            |22222222222222|
+//            +--------------+
+// Results in:
+// +----------+----+----------+
+// |1111111111|xxxx|2222222222|
+// +----------+----+----------+
+// Where "xxxx" represents the crossfaded portion of the signal.
+TEST_F(AudioSplicerTest, PartialOverlapCrossfade) {
+  const int kCrossfadeSize =
+      input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration());
+  const int kBufferSize = kCrossfadeSize * 2;
+
+  scoped_refptr<AudioBuffer> extra_pre_splice_buffer =
+      GetNextInputBuffer(0.2f, kBufferSize);
+  scoped_refptr<AudioBuffer> overlapped_buffer =
+      GetNextInputBuffer(1.0f, kBufferSize);
+
+  // Reset timestamp helper so that the next buffer will have a timestamp that
+  // starts in the middle of |overlapped_buffer|.
+  input_timestamp_helper_.SetBaseTimestamp(overlapped_buffer->timestamp());
+  input_timestamp_helper_.AddFrames(overlapped_buffer->frame_count() -
+                                    kCrossfadeSize);
+  const base::TimeDelta splice_timestamp =
+      input_timestamp_helper_.GetTimestamp();
+  splicer_.SetSpliceTimestamp(splice_timestamp);
+  scoped_refptr<AudioBuffer> overlapping_buffer =
+      GetNextInputBuffer(0.0f, kBufferSize);
+
+  // |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, 0.2f);
+
+  // 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 complete the splice, so ensure output is now
+  // available.
+  EXPECT_TRUE(AddInput(overlapping_buffer));
+  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, 1.0f);
+
+  int64 expected_crossfade_size = 0;
+  base::TimeDelta expected_crossfade_duration;
+  VerifyCrossfadeOutput(overlapped_buffer,
+                        overlapping_buffer,
+                        1.0f,
+                        0.0f,
+                        &expected_crossfade_duration,
+                        &expected_crossfade_size);
+  const int kExpectedPostSpliceSize =
+      overlapping_buffer->frame_count() - expected_crossfade_size;
+
+  // Retrieve the remaining portion after crossfade.
+  ASSERT_TRUE(splicer_.HasNextBuffer());
+  scoped_refptr<AudioBuffer> post_splice_output = splicer_.GetNextBuffer();
+  EXPECT_EQ(output_timestamp_helper_.GetTimestamp(),
+            post_splice_output->timestamp());
+  EXPECT_EQ(kExpectedPostSpliceSize, post_splice_output->frame_count());
+  EXPECT_EQ(output_timestamp_helper_.GetFrameDuration(kExpectedPostSpliceSize),
+            post_splice_output->duration());
+
+  EXPECT_TRUE(VerifyData(post_splice_output, 0.0f));
+
+  VerifyNextBuffer(extra_post_splice_buffer, 0.5f);
+  EXPECT_FALSE(splicer_.HasNextBuffer());
+}
+
+// Test crossfade when one buffer partially overlaps another, but an end of
+// stream buffer is received before the crossfade duration is reached.
+// +--------------+
+// |11111111111111|
+// +--------------+
+//            +---------++---+
+//            |222222222||EOS|
+//            +---------++---+
+// Results in:
+// +----------+----+----++---+
+// |1111111111|xxxx|2222||EOS|
+// +----------+----+----++---+
+// Where "x" represents the crossfaded portion of the signal.
+TEST_F(AudioSplicerTest, PartialOverlapCrossfadeEndOfStream) {
+  const int kCrossfadeSize =
+      input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration());
+
+  scoped_refptr<AudioBuffer> overlapped_buffer =
+      GetNextInputBuffer(1.0f, kCrossfadeSize * 2);
+
+  // Reset timestamp helper so that the next buffer will have a timestamp that
+  // starts 3/4 of the way into |overlapped_buffer|.
+  input_timestamp_helper_.SetBaseTimestamp(overlapped_buffer->timestamp());
+  input_timestamp_helper_.AddFrames(3 * overlapped_buffer->frame_count() / 4);
+  const base::TimeDelta splice_timestamp =
+      input_timestamp_helper_.GetTimestamp();
+  splicer_.SetSpliceTimestamp(splice_timestamp);
+  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.
+  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, 1.0f);
+  int64 expected_crossfade_size = 0;
+  base::TimeDelta expected_crossfade_duration;
+  VerifyCrossfadeOutput(overlapped_buffer,
+                        overlapping_buffer,
+                        1.0f,
+                        0.0f,
+                        &expected_crossfade_duration,
+                        &expected_crossfade_size);
+
+  // Ensure the last buffer is an EOS buffer.
+  ASSERT_TRUE(splicer_.HasNextBuffer());
+  scoped_refptr<AudioBuffer> post_splice_output = splicer_.GetNextBuffer();
+  EXPECT_TRUE(post_splice_output->end_of_stream());
+
+  EXPECT_FALSE(splicer_.HasNextBuffer());
+}
+
+// Test crossfade when one buffer partially overlaps another, but the amount of
+// overlapped data is less than the crossfade duration.
+// +------------+
+// |111111111111|
+// +------------+
+//            +--------------+
+//            |22222222222222|
+//            +--------------+
+// Results in:
+// +----------+-+------------+
+// |1111111111|x|222222222222|
+// +----------+-+------------+
+// Where "x" represents the crossfaded portion of the signal.
+TEST_F(AudioSplicerTest, PartialOverlapCrossfadeShortPreSplice) {
+  const int kCrossfadeSize =
+      input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration());
+
+  scoped_refptr<AudioBuffer> overlapped_buffer =
+      GetNextInputBuffer(1.0f, kCrossfadeSize / 2);
+
+  // Reset timestamp helper so that the next buffer will have a timestamp that
+  // starts in the middle of |overlapped_buffer|.
+  input_timestamp_helper_.SetBaseTimestamp(overlapped_buffer->timestamp());
+  input_timestamp_helper_.AddFrames(overlapped_buffer->frame_count() / 2);
+  const base::TimeDelta splice_timestamp =
+      input_timestamp_helper_.GetTimestamp();
+  splicer_.SetSpliceTimestamp(splice_timestamp);
+  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());
+
+  // |overlapping_buffer| should complete the splice, so ensure output is now
+  // available.
+  EXPECT_TRUE(AddInput(overlapping_buffer));
+  ASSERT_TRUE(splicer_.HasNextBuffer());
+
+  VerifyPreSpliceOutput(overlapped_buffer, overlapping_buffer, 1.0f);
+
+  int64 expected_crossfade_size = 0;
+  base::TimeDelta expected_crossfade_duration;
+  VerifyCrossfadeOutput(overlapped_buffer,
+                        overlapping_buffer,
+                        1.0f,
+                        0.0f,
+                        &expected_crossfade_duration,
+                        &expected_crossfade_size);
+
+  // Retrieve the remaining portion after crossfade.
+  ASSERT_TRUE(splicer_.HasNextBuffer());
+  scoped_refptr<AudioBuffer> post_splice_output = splicer_.GetNextBuffer();
+  EXPECT_EQ(output_timestamp_helper_.GetTimestamp(),
+            post_splice_output->timestamp());
+  EXPECT_EQ(overlapping_buffer->duration() - expected_crossfade_duration,
+            post_splice_output->duration());
+  EXPECT_EQ(overlapping_buffer->frame_count() - expected_crossfade_size,
+            post_splice_output->frame_count());
+  EXPECT_TRUE(VerifyData(post_splice_output, 0.0f));
+
+  EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 }  // namespace media