Fix incorrect opus seek preroll and flaky pre-skip removal.

media/filters/audio_decoder_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 <deque>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/md5.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 46 matching lines @@
 
 // Tells gtest how to print our DecoderTestData structure.
 std::ostream& operator<<(std::ostream& os, const DecoderTestData& data) {
   return os << data.filename;
 }
 
 // Marks negative timestamp buffers for discard or transfers FFmpeg's built in
 // discard metadata in favor of setting DiscardPadding on the DecoderBuffer.
 // Allows better testing of AudioDiscardHelper usage.
 static void SetDiscardPadding(AVPacket* packet,
+                              bool first_packet,
+                              const AVStream* stream,
                               const scoped_refptr<DecoderBuffer> buffer,
                               double samples_per_second) {
   // Discard negative timestamps.
   if (buffer->timestamp() + buffer->duration() < base::TimeDelta()) {
     buffer->set_discard_padding(
         std::make_pair(kInfiniteDuration(), base::TimeDelta()));
     return;
   }
   if (buffer->timestamp() < base::TimeDelta()) {
     buffer->set_discard_padding(
         std::make_pair(-buffer->timestamp(), base::TimeDelta()));
     return;
   }
 
   // If the timestamp is positive, try to use FFmpeg's discard data.
+  int skip_samples = 0;
   int skip_samples_size = 0;
   const uint32* skip_samples_ptr =
       reinterpret_cast<const uint32*>(av_packet_get_side_data(
           packet, AV_PKT_DATA_SKIP_SAMPLES, &skip_samples_size));
-  if (skip_samples_size < 4)
+  if (skip_samples_size >= 4)
+    skip_samples = base::ByteSwapToLE32(*skip_samples_ptr);
+  else if (first_packet && stream->codec->delay)
+    skip_samples = stream->codec->delay;
+  else
     return;
+
   buffer->set_discard_padding(std::make_pair(
-      base::TimeDelta::FromSecondsD(base::ByteSwapToLE32(*skip_samples_ptr) /
-                                    samples_per_second),
+      base::TimeDelta::FromSecondsD(skip_samples / samples_per_second),
       base::TimeDelta()));
 }
 
 class AudioDecoderTest : public testing::TestWithParam<DecoderTestData> {
  public:
   AudioDecoderTest()
       : pending_decode_(false),
         pending_reset_(false),
         last_decode_status_(AudioDecoder::kDecodeError) {
     switch (GetParam().decoder_type) {
@@ skipping 80 matching lines @@
 
     scoped_refptr<DecoderBuffer> buffer =
         DecoderBuffer::CopyFrom(packet.data, packet.size);
     buffer->set_timestamp(ConvertFromTimeBase(
         reader_->GetAVStreamForTesting()->time_base, packet.pts));
     buffer->set_duration(ConvertFromTimeBase(
         reader_->GetAVStreamForTesting()->time_base, packet.duration));
     if (packet.flags & AV_PKT_FLAG_KEY)
       buffer->set_is_key_frame(true);
 
-    // Don't set discard padding for Opus, it already has discard behavior set
-    // based on the codec delay in the AudioDecoderConfig.
-    if (GetParam().decoder_type == FFMPEG)
-      SetDiscardPadding(&packet, buffer, GetParam().samples_per_second);
+    SetDiscardPadding(&packet, buffer->timestamp() == start_timestamp_,
+                      reader_->GetAVStreamForTesting(), buffer,
+                      GetParam().samples_per_second);
 
     // DecodeBuffer() shouldn't need the original packet since it uses the copy.
     av_free_packet(&packet);
     DecodeBuffer(buffer);
   }
 
   void Reset() {
     ASSERT_FALSE(pending_reset_);
     pending_reset_ = true;
     decoder_->Reset(
@@ skipping 326 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderTest,
                         AudioDecoderTest,
                         testing::ValuesIn(kFFmpegTests));
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderBehavioralTest,
                         FFmpegAudioDecoderBehavioralTest,
                         testing::ValuesIn(kFFmpegBehavioralTest));
 
 }  // namespace media