Add support for partial append window end trimming.

media/base/audio_discard_helper_unittest.cc

 // Copyright 2014 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_discard_helper.h"
 #include "media/base/buffers.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 307 matching lines @@
   const int kTestFrames = discard_helper.TimeDeltaToFrames(kDuration);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Set a discard padding equivalent to half of the buffer.
   encoded_buffer->set_discard_padding(
       std::make_pair(kDuration / 2, base::TimeDelta()));
 
-  // All of the first buffer should be discarded.
+  // All of the first buffer should be discarded, half from the inital delay and
+  // another half from the front discard padding.
+  //
+  //    Encoded                   Discard Delay
+  //   |--------|     |---------|     |----|
+  //   |AAAAAAAA| --> |....|AAAA| --> |AAAA| -------> NULL
+  //   |--------|     |---------|     |----|
+  //                    Decoded               Discard Front Padding
+  //
   ASSERT_FALSE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
 
-  // Processing another buffer (with the same discard padding) should discard
-  // the back half of the buffer since kDecoderDelay is half a buffer.
-  encoded_buffer->set_timestamp(kTimestamp + kDuration);
+  // Processing another buffer should discard the back half of the buffer since

[wolenetz, 2014/07/30 22:04:31]

nit: s/another buffer should/another buffer that has front discard set to half
the buffer's duration should/

[DaleCurtis, 2014/07/30 22:52:00]

Done.

+  // kDecoderDelay is half a buffer.  The end padding should not be discarded

[wolenetz, 2014/07/30 22:04:32]

nit: s/since kDecoderDelay is half a buffer/and front discard should start at
index kDecoderDelay, which is half a buffer/

[DaleCurtis, 2014/07/30 22:52:00]

I don't think this one is helpful and makes the sentence even more of a run on.

[wolenetz, 2014/07/30 23:12:34]

Acknowledged.

+  // until another buffer is processed.  kDuration / 4 is chosen for the end
+  // discard since it will force the end discard to start after position zero
+  // within the next decoded buffer.
+  //
+  //    Encoded                    Discard Front Padding (from B)
+  //   |--------|     |---------|             |----|
+  //   |BBBBBBBB| --> |AAAA|BBBB| ----------> |AAAA|
+  //   |--------|     |---------|             |----|
+  //                    Decoded
+  //           (includes carryover from A)
+  //
+  encoded_buffer->set_timestamp(encoded_buffer->timestamp() + kDuration);
+  encoded_buffer->set_discard_padding(
+      std::make_pair(kDuration / 2, kDuration / 4));
   decoded_buffer = CreateDecodedBuffer(kTestFrames);
   ASSERT_FLOAT_EQ(0.0f, ExtractDecodedData(decoded_buffer, 0));
   ASSERT_NEAR(kDecoderDelay * kDataStep,
               ExtractDecodedData(decoded_buffer, kDecoderDelay),
               kDataStep * 1000);

[wolenetz, 2014/07/30 22:04:31]

This nearness distance requirement seems too loose. kDecoderDelay is 48000 / 100
/ 2, which is 240. 1000 >> 240. ISTM we are allowing for the midpoint value of
the created buffer to be off by a factor of about 4 whole buffers worth of data.
Or am I missing sth obvious here? Remove the "* 1000" here?

[DaleCurtis, 2014/07/30 22:51:59]

Whoops, this should be kDataStep / 1000 meaning the accuracy needs to be
0.000010f.

   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration / 2, decoded_buffer->duration());
   EXPECT_EQ(kTestFrames / 2, decoded_buffer->frame_count());
 
   // Verify it was actually the latter half of the buffer that was removed.
   ASSERT_FLOAT_EQ(0.0f, ExtractDecodedData(decoded_buffer, 0));
+
+  // Verify the end discard padding is carried over to the next buffer.  Use
+  // kDuration / 2 so that the next buffer has its start entirely discarded.

[wolenetz, 2014/07/30 22:04:31]

nit: this "Use kDuration / 2" portion of the comment is confusing. Use it for
what? Which next buffer are we talking about vs the previous sentence?

[DaleCurtis, 2014/07/30 22:52:00]

As the end discard padding. I've clarified the sentence.

+  //
+  //    Encoded                      Discard End Padding (from B)
+  //   |--------|     |---------|             |-------|
+  //   |CCCCCCCC| --> |BBBB|CCCC| ----------> |BB|CCCC|
+  //   |--------|     |---------|             |-------|
+  //                    Decoded
+  //           (includes carryover from B)
+  //
+  encoded_buffer->set_timestamp(encoded_buffer->timestamp() + kDuration);
+  encoded_buffer->set_discard_padding(
+      std::make_pair(base::TimeDelta(), kDuration / 2));
+  decoded_buffer = CreateDecodedBuffer(kTestFrames);
+  ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
+  EXPECT_EQ(kTimestamp + kDuration / 2, decoded_buffer->timestamp());
+  EXPECT_EQ(3 * kDuration / 4, decoded_buffer->duration());
+  EXPECT_EQ(3 * kTestFrames / 4, decoded_buffer->frame_count());
+
+  // Verify it was actually the second quarter of the buffer that was removed.
+  const int kDiscardFrames = kTestFrames / 4;
+  ASSERT_FLOAT_EQ(0.0f, ExtractDecodedData(decoded_buffer, 0));
+  ASSERT_FLOAT_EQ(
+      kDiscardFrames * 2 * kDataStep,
+      ExtractDecodedData(decoded_buffer, kDecoderDelay - kDiscardFrames));
+
+  // One last test to ensure carryover discard from the start works.
+  //
+  //    Encoded                      Discard End Padding (from C)
+  //   |--------|     |---------|             |----|
+  //   |DDDDDDDD| --> |CCCC|DDDD| ----------> |DDDD|
+  //   |--------|     |---------|             |----|
+  //                    Decoded
+  //           (includes carryover from C)
+  //
+  encoded_buffer->set_timestamp(encoded_buffer->timestamp() + kDuration);
+  encoded_buffer->set_discard_padding(DecoderBuffer::DiscardPadding());
+  decoded_buffer = CreateDecodedBuffer(kTestFrames);
+  ASSERT_FLOAT_EQ(0.0f, ExtractDecodedData(decoded_buffer, 0));
+  ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
+  EXPECT_EQ(kTimestamp + kDuration / 2 + 3 * kDuration / 4,
+            decoded_buffer->timestamp());
+  EXPECT_EQ(kDuration / 2, decoded_buffer->duration());
+  EXPECT_EQ(kTestFrames / 2, decoded_buffer->frame_count());
+  ASSERT_FLOAT_EQ(kTestFrames / 2 * kDataStep,
+                  ExtractDecodedData(decoded_buffer, 0));
 }
 
 TEST(AudioDiscardHelperTest, DelayedDiscardInitialDiscardAndDiscardPadding) {
   AudioDiscardHelper discard_helper(kSampleRate, 0);
   ASSERT_FALSE(discard_helper.initialized());
 
   const base::TimeDelta kTimestamp = base::TimeDelta();
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(10);
   const int kTestFrames = discard_helper.TimeDeltaToFrames(kDuration);
 
@@ skipping 115 matching lines @@
   decoded_buffer = CreateDecodedBuffer(kTestFrames * 2);
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration * 2 - kDuration / 2, decoded_buffer->duration());
   EXPECT_EQ(kTestFrames * 2 - kDecoderDelay, decoded_buffer->frame_count());
   ASSERT_FLOAT_EQ(kDecoderDelay * kDataStep,
                   ExtractDecodedData(decoded_buffer, 0));
 }
 
 }  // namespace media