Don't double correct for discarded codec delay frames.

media/filters/opus_audio_decoder_unittest.cc

Index: media/filters/opus_audio_decoder_unittest.cc
diff --git a/media/filters/ffmpeg_audio_decoder_unittest.cc b/media/filters/opus_audio_decoder_unittest.cc
similarity index 51%
copy from media/filters/ffmpeg_audio_decoder_unittest.cc
copy to media/filters/opus_audio_decoder_unittest.cc
index 60d1f405baa2fbef084b582e18f21ea22ead553a..6aea7b5f1044d788e2e28cd21b2e02a50f360df1 100644
--- a/media/filters/ffmpeg_audio_decoder_unittest.cc
+++ b/media/filters/opus_audio_decoder_unittest.cc
@@ -14,8 +14,9 @@
 #include "media/base/test_data_util.h"
 #include "media/base/test_helpers.h"
 #include "media/ffmpeg/ffmpeg_common.h"
-#include "media/filters/ffmpeg_audio_decoder.h"
-#include "media/filters/ffmpeg_glue.h"
+#include "media/filters/audio_file_reader.h"
+#include "media/filters/in_memory_url_protocol.h"
+#include "media/filters/opus_audio_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
@@ -23,73 +24,67 @@ using ::testing::StrictMock;
 
 namespace media {
 
-class FFmpegAudioDecoderTest : public testing::Test {
+class OpusAudioDecoderTest : public testing::Test {
  public:
-  FFmpegAudioDecoderTest()
-      : decoder_(new FFmpegAudioDecoder(message_loop_.message_loop_proxy())),
+  OpusAudioDecoderTest()
+      : decoder_(new OpusAudioDecoder(message_loop_.message_loop_proxy())),
         pending_decode_(false),
         pending_reset_(false) {
-    FFmpegGlue::InitializeFFmpeg();
-
-    vorbis_extradata_ = ReadTestDataFile("vorbis-extradata");
-
-    // Refer to media/test/data/README for details on vorbis test data.
-    for (int i = 0; i < 4; ++i) {
-      scoped_refptr<DecoderBuffer> buffer =
-          ReadTestDataFile(base::StringPrintf("vorbis-packet-%d", i));
-
-      if (i < 3) {
-        buffer->set_timestamp(base::TimeDelta());
-      } else {
-        buffer->set_timestamp(base::TimeDelta::FromMicroseconds(2902));
-      }
-
-      buffer->set_duration(base::TimeDelta());
-      encoded_audio_.push_back(buffer);
-    }
-
-    // Push in an EOS buffer.
-    encoded_audio_.push_back(DecoderBuffer::CreateEOSBuffer());
+    // Load the test data file.
+    data_ = ReadTestDataFile("bear-opus.ogg");
+    protocol_.reset(
+        new InMemoryUrlProtocol(data_->data(), data_->data_size(), false));
+    reader_.reset(new AudioFileReader(protocol_.get()));
+    reader_->Open();
 
     Initialize();
   }
 
-  virtual ~FFmpegAudioDecoderTest() {
+  virtual ~OpusAudioDecoderTest() {
     EXPECT_FALSE(pending_decode_);
     EXPECT_FALSE(pending_reset_);
   }
 
   void Initialize() {
-    AudioDecoderConfig config(kCodecVorbis,
-                              kSampleFormatPlanarF32,
-                              CHANNEL_LAYOUT_STEREO,
-                              44100,
-                              vorbis_extradata_->data(),
-                              vorbis_extradata_->data_size(),
-                              false);  // Not encrypted.
-    decoder_->Initialize(config,
-                         NewExpectedStatusCB(PIPELINE_OK));
+    AudioDecoderConfig config;
+    AVCodecContextToAudioDecoderConfig(
+        reader_->codec_context_for_testing(), false, &config, false);
+    decoder_->Initialize(config, NewExpectedStatusCB(PIPELINE_OK));
     base::RunLoop().RunUntilIdle();
   }
 
-  void SatisfyPendingDecode() {
+  void SatisfyPendingDecode() { base::RunLoop().RunUntilIdle(); }
+
+  void SendEndOfStream() {
+    pending_decode_ = true;
+    decoder_->Decode(DecoderBuffer::CreateEOSBuffer(),
+                     base::Bind(&OpusAudioDecoderTest::DecodeFinished,
+                                base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void Decode() {
     pending_decode_ = true;
-    scoped_refptr<DecoderBuffer> buffer(encoded_audio_.front());
-    encoded_audio_.pop_front();
+
+    AVPacket packet;
+    ASSERT_TRUE(reader_->ReadPacketForTesting(&packet));
+    scoped_refptr<DecoderBuffer> buffer =
+        DecoderBuffer::CopyFrom(packet.data, packet.size);
+    buffer->set_timestamp(ConvertFromTimeBase(
+        reader_->codec_context_for_testing()->time_base, packet.pts));
+    buffer->set_duration(ConvertFromTimeBase(
+        reader_->codec_context_for_testing()->time_base, packet.duration));
     decoder_->Decode(buffer,
-                     base::Bind(&FFmpegAudioDecoderTest::DecodeFinished,
+                     base::Bind(&OpusAudioDecoderTest::DecodeFinished,
                                 base::Unretained(this)));
+    av_free_packet(&packet);
     base::RunLoop().RunUntilIdle();
   }
 
   void Reset() {
     pending_reset_ = true;
-    decoder_->Reset(base::Bind(
-        &FFmpegAudioDecoderTest::ResetFinished, base::Unretained(this)));
+    decoder_->Reset(base::Bind(&OpusAudioDecoderTest::ResetFinished,
+                               base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
@@ -142,72 +137,58 @@ class FFmpegAudioDecoderTest : public testing::Test {
   }
 
   base::MessageLoop message_loop_;
-  scoped_ptr<FFmpegAudioDecoder> decoder_;
+  scoped_refptr<DecoderBuffer> data_;
+  scoped_ptr<InMemoryUrlProtocol> protocol_;
+  scoped_ptr<AudioFileReader> reader_;
+
+  scoped_ptr<OpusAudioDecoder> decoder_;
   bool pending_decode_;
   bool pending_reset_;
 
-  scoped_refptr<DecoderBuffer> vorbis_extradata_;
-
-  std::deque<scoped_refptr<DecoderBuffer> > encoded_audio_;
   std::deque<scoped_refptr<AudioBuffer> > decoded_audio_;
 };
 
-TEST_F(FFmpegAudioDecoderTest, Initialize) {
-  AudioDecoderConfig config(kCodecVorbis,
-                            kSampleFormatPlanarF32,
-                            CHANNEL_LAYOUT_STEREO,
-                            44100,
-                            vorbis_extradata_->data(),
-                            vorbis_extradata_->data_size(),
-                            false);  // Not encrypted.
+TEST_F(OpusAudioDecoderTest, Initialize) {
+  Initialize();
   Stop();
 }
 
-TEST_F(FFmpegAudioDecoderTest, ProduceAudioSamples) {
-  // Vorbis requires N+1 packets to produce audio data for N packets.
-  //
-  // This will should result in the demuxer receiving three reads for two
-  // requests to produce audio samples.
+TEST_F(OpusAudioDecoderTest, ProduceAudioSamples) {
   Decode();
   Decode();
   Decode();
 
   ASSERT_EQ(3u, decoded_audio_.size());
-  ExpectDecodedAudio(0, 0, 2902);
-  ExpectDecodedAudio(1, 2902, 13061);
-  ExpectDecodedAudio(2, 15963, 23220);
+  ExpectDecodedAudio(0, 0, 3500);
+  ExpectDecodedAudio(1, 3500, 10000);
+  ExpectDecodedAudio(2, 13500, 10000);
 
   // Call one more time to trigger EOS.
-  Decode();
+  SendEndOfStream();
   ASSERT_EQ(4u, decoded_audio_.size());
   ExpectEndOfStream(3);
   Stop();
 }
 
-TEST_F(FFmpegAudioDecoderTest, DecodeAbort) {
-  encoded_audio_.clear();
-  encoded_audio_.push_back(NULL);
+TEST_F(OpusAudioDecoderTest, DecodeAbort) {
   Decode();
-
-  EXPECT_EQ(decoded_audio_.size(), 1u);
-  EXPECT_TRUE(decoded_audio_[0].get() ==  NULL);
   Stop();
 }
 
-TEST_F(FFmpegAudioDecoderTest, PendingDecode_Stop) {
+TEST_F(OpusAudioDecoderTest, PendingDecode_Stop) {
   Decode();
   Stop();
   SatisfyPendingDecode();
 }
 
-TEST_F(FFmpegAudioDecoderTest, PendingDecode_Reset) {
+TEST_F(OpusAudioDecoderTest, PendingDecode_Reset) {
   Decode();
   Reset();
   SatisfyPendingDecode();
   Stop();
 }
 
-TEST_F(FFmpegAudioDecoderTest, PendingDecode_ResetStop) {
+TEST_F(OpusAudioDecoderTest, PendingDecode_ResetStop) {
   Decode();
   Reset();
   Stop();