To M56: Use ffmpeg for opus decoding, no need to maintain our decoder.

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 "media/base/audio_discard_helper.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 27 matching lines @@
                                 int index) {
   // This is really inefficient, but we can't access the raw AudioBuffer if any
   // start trimming has been applied.
   std::unique_ptr<AudioBus> temp_bus =
       AudioBus::Create(buffer->channel_count(), 1);
   buffer->ReadFrames(1, index, 0, temp_bus.get());
   return temp_bus->channel(0)[0];
 }
 
 TEST(AudioDiscardHelperTest, TimeDeltaToFrames) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
 
   EXPECT_EQ(0u, discard_helper.TimeDeltaToFrames(base::TimeDelta()));
   EXPECT_EQ(
       kSampleRate / 100,
       discard_helper.TimeDeltaToFrames(base::TimeDelta::FromMilliseconds(10)));
 
   // Ensure partial frames are rounded down correctly.  The equation below
   // calculates a frame count with a fractional part < 0.5.
   const int small_remainder =
       base::Time::kMicrosecondsPerSecond * (kSampleRate - 0.9) / kSampleRate;
   EXPECT_EQ(kSampleRate - 1,
             discard_helper.TimeDeltaToFrames(
                 base::TimeDelta::FromMicroseconds(small_remainder)));
 
   // Ditto, but rounded up using a fractional part > 0.5.
   const int large_remainder =
       base::Time::kMicrosecondsPerSecond * (kSampleRate - 0.4) / kSampleRate;
   EXPECT_EQ(kSampleRate,
             discard_helper.TimeDeltaToFrames(
                 base::TimeDelta::FromMicroseconds(large_remainder)));
 }
 
 TEST(AudioDiscardHelperTest, BasicProcessBuffers) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   ASSERT_FALSE(discard_helper.initialized());
 
   const base::TimeDelta kTimestamp = base::TimeDelta();
 
   // Use an estimated duration which doesn't match the number of decoded frames
   // to ensure the helper is correctly setting durations based on output frames.
   const base::TimeDelta kEstimatedDuration =
       base::TimeDelta::FromMilliseconds(9);
   const base::TimeDelta kActualDuration = base::TimeDelta::FromMilliseconds(10);
   const int kTestFrames = discard_helper.TimeDeltaToFrames(kActualDuration);
@@ skipping 11 matching lines @@
 
   // Verify a Reset() takes us back to an uninitialized state.
   discard_helper.Reset(0);
   ASSERT_FALSE(discard_helper.initialized());
 
   // Verify a NULL output buffer returns false.
   ASSERT_FALSE(discard_helper.ProcessBuffers(encoded_buffer, NULL));
 }
 
 TEST(AudioDiscardHelperTest, NegativeTimestampClampsToZero) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   ASSERT_FALSE(discard_helper.initialized());
 
   const base::TimeDelta kTimestamp = -base::TimeDelta::FromSeconds(1);
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(10);
   const int kTestFrames = discard_helper.TimeDeltaToFrames(kDuration);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Verify the basic case where nothing is discarded.
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
   EXPECT_EQ(base::TimeDelta(), decoded_buffer->timestamp());
   EXPECT_EQ(kDuration, decoded_buffer->duration());
   EXPECT_EQ(kTestFrames, decoded_buffer->frame_count());
 }
 
 TEST(AudioDiscardHelperTest, ProcessBuffersWithInitialDiscard) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
 
   // Tell the helper we want to discard half of the initial frames.
   const int kDiscardFrames = kTestFrames / 2;
   discard_helper.Reset(kDiscardFrames);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Verify half the frames end up discarded.
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration / 2, decoded_buffer->duration());
   EXPECT_EQ(kDiscardFrames, decoded_buffer->frame_count());
   ASSERT_FLOAT_EQ(kDiscardFrames * kDataStep,
                   ExtractDecodedData(decoded_buffer, 0));
 }
 
 TEST(AudioDiscardHelperTest, ProcessBuffersWithLargeInitialDiscard) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
 
   // Tell the helper we want to discard 1.5 buffers worth of frames.
   discard_helper.Reset(kTestFrames * 1.5);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
@@ skipping 12 matching lines @@
   // The timestamp should match that of the initial buffer.
   const int kDiscardFrames = kTestFrames / 2;
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration / 2, decoded_buffer->duration());
   EXPECT_EQ(kDiscardFrames, decoded_buffer->frame_count());
   ASSERT_FLOAT_EQ(kDiscardFrames * kDataStep,
                   ExtractDecodedData(decoded_buffer, 0));
 }
 
 TEST(AudioDiscardHelperTest, AllowNonMonotonicTimestamps) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration, decoded_buffer->duration());
   EXPECT_EQ(kTestFrames, decoded_buffer->frame_count());
 
   // Process the same input buffer again to ensure input timestamps which go
   // backwards in time are not errors.
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   EXPECT_EQ(kTimestamp + kDuration, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration, decoded_buffer->duration());
   EXPECT_EQ(kTestFrames, decoded_buffer->frame_count());
 }
 
 TEST(AudioDiscardHelperTest, DiscardEndPadding) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Set a discard padding equivalent to half the buffer.
   encoded_buffer->set_discard_padding(
       std::make_pair(base::TimeDelta(), kDuration / 2));
 
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration / 2, decoded_buffer->duration());
   EXPECT_EQ(kTestFrames / 2, decoded_buffer->frame_count());
 }
 
 TEST(AudioDiscardHelperTest, BadDiscardEndPadding) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Set a discard padding equivalent to double the buffer size.
   encoded_buffer->set_discard_padding(
       std::make_pair(base::TimeDelta(), kDuration * 2));
 
   // Verify the end discard padding is rejected.
   ASSERT_FALSE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
 }
 
 TEST(AudioDiscardHelperTest, InitialDiscardAndDiscardEndPadding) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Set a discard padding equivalent to a quarter of the buffer.
   encoded_buffer->set_discard_padding(
       std::make_pair(base::TimeDelta(), kDuration / 4));
 
   // Set an initial discard of a quarter of the buffer.
   const int kDiscardFrames = kTestFrames / 4;
   discard_helper.Reset(kDiscardFrames);
 
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration / 2, decoded_buffer->duration());
   EXPECT_EQ(kTestFrames / 2, decoded_buffer->frame_count());
   ASSERT_FLOAT_EQ(kDiscardFrames * kDataStep,
                   ExtractDecodedData(decoded_buffer, 0));
 }
 
 TEST(AudioDiscardHelperTest, InitialDiscardAndDiscardPadding) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Set all the discard values to be different to ensure each is properly used.
   const int kDiscardFrames = kTestFrames / 4;
   encoded_buffer->set_discard_padding(
       std::make_pair(kDuration / 8, kDuration / 16));
   discard_helper.Reset(kDiscardFrames);
 
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration - kDuration / 4 - kDuration / 8 - kDuration / 16,
             decoded_buffer->duration());
   EXPECT_EQ(kTestFrames - kTestFrames / 4 - kTestFrames / 8 - kTestFrames / 16,
             decoded_buffer->frame_count());
 }
 
 TEST(AudioDiscardHelperTest, InitialDiscardAndDiscardPaddingAndDecoderDelay) {
   // Use a decoder delay of 5ms.
   const int kDecoderDelay = kSampleRate / 100 / 2;
-  AudioDiscardHelper discard_helper(kSampleRate, kDecoderDelay);
+  AudioDiscardHelper discard_helper(kSampleRate, kDecoderDelay, false);
   ASSERT_FALSE(discard_helper.initialized());
   discard_helper.Reset(kDecoderDelay);
 
   const base::TimeDelta kTimestamp = base::TimeDelta();
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(10);
   const int kTestFrames = discard_helper.TimeDeltaToFrames(kDuration);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
@@ skipping 87 matching lines @@
   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);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, true);
   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);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
 
   // Set all the discard values to be different to ensure each is properly used.
@@ skipping 14 matching lines @@
   // previous encoded buffer are applied.
   ASSERT_TRUE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   EXPECT_EQ(kTimestamp, decoded_buffer->timestamp());
   EXPECT_EQ(kDuration - kDuration / 4 - kDuration / 8 - kDuration / 16,
             decoded_buffer->duration());
   EXPECT_EQ(kTestFrames - kTestFrames / 4 - kTestFrames / 8 - kTestFrames / 16,
             decoded_buffer->frame_count());
 }
 
 TEST(AudioDiscardHelperTest, CompleteDiscard) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, false);
   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);
   discard_helper.Reset(0);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   encoded_buffer->set_discard_padding(
       std::make_pair(kInfiniteDuration, base::TimeDelta()));
   scoped_refptr<AudioBuffer> decoded_buffer = CreateDecodedBuffer(kTestFrames);
 
   // Verify all of the first buffer is discarded.
   ASSERT_FALSE(discard_helper.ProcessBuffers(encoded_buffer, decoded_buffer));
   ASSERT_TRUE(discard_helper.initialized());
   encoded_buffer->set_timestamp(kTimestamp + kDuration);
   encoded_buffer->set_discard_padding(DecoderBuffer::DiscardPadding());
 
   // Verify a second buffer goes through untouched.
   decoded_buffer = CreateDecodedBuffer(kTestFrames / 2);
   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());
   ASSERT_FLOAT_EQ(0.0f, ExtractDecodedData(decoded_buffer, 0));
 }
 
 TEST(AudioDiscardHelperTest, CompleteDiscardWithDelayedDiscard) {
-  AudioDiscardHelper discard_helper(kSampleRate, 0);
+  AudioDiscardHelper discard_helper(kSampleRate, 0, true);
   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);
   discard_helper.Reset(0);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   encoded_buffer->set_discard_padding(
@@ skipping 15 matching lines @@
   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());
   ASSERT_FLOAT_EQ(0.0f, ExtractDecodedData(decoded_buffer, 0));
 }
 
 TEST(AudioDiscardHelperTest, CompleteDiscardWithInitialDiscardDecoderDelay) {
   // Use a decoder delay of 5ms.
   const int kDecoderDelay = kSampleRate / 100 / 2;
-  AudioDiscardHelper discard_helper(kSampleRate, kDecoderDelay);
+  AudioDiscardHelper discard_helper(kSampleRate, kDecoderDelay, false);
   ASSERT_FALSE(discard_helper.initialized());
   discard_helper.Reset(kDecoderDelay);
 
   const base::TimeDelta kTimestamp = base::TimeDelta();
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(10);
   const int kTestFrames = discard_helper.TimeDeltaToFrames(kDuration);
 
   scoped_refptr<DecoderBuffer> encoded_buffer =
       CreateEncodedBuffer(kTimestamp, kDuration);
   encoded_buffer->set_discard_padding(
@@ skipping 10 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