[Opus] Update to v1.2.1

media/cast/receiver/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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
@@ skipping 40 matching lines @@
                                           GetParam().sampling_rate,
                                           GetParam().codec));
     CHECK_EQ(STATUS_INITIALIZED, audio_decoder_->InitializationResult());
 
     audio_bus_factory_.reset(
         new TestAudioBusFactory(GetParam().num_channels,
                                 GetParam().sampling_rate,
                                 TestAudioBusFactory::kMiddleANoteFreq,
                                 0.5f));
     last_frame_id_ = FrameId::first();
-    seen_a_decoded_frame_ = false;
+    decoded_frames_seen_ = 0;
 
     if (GetParam().codec == CODEC_AUDIO_OPUS) {
       opus_encoder_memory_.reset(
           new uint8_t[opus_encoder_get_size(GetParam().num_channels)]);
       OpusEncoder* const opus_encoder =
           reinterpret_cast<OpusEncoder*>(opus_encoder_memory_.get());
       CHECK_EQ(OPUS_OK, opus_encoder_init(opus_encoder,
                                           GetParam().sampling_rate,
                                           GetParam().num_channels,
                                           OPUS_APPLICATION_AUDIO));
@@ skipping 80 matching lines @@
                       bool is_continuous) {
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
     // A NULL |audio_bus| indicates a decode error, which we don't expect.
     ASSERT_TRUE(audio_bus);
 
     // Did the decoder detect whether frames were dropped?
     EXPECT_EQ(should_be_continuous, is_continuous);
 
     // Does the audio data seem to be intact?  For Opus, we have to ignore the
-    // first frame seen at the start (and immediately after dropped packet
+    // first two frames seen at the start (and immediately after dropped packet
     // recovery) because it introduces a tiny, significant delay.
     bool examine_signal = true;
     if (GetParam().codec == CODEC_AUDIO_OPUS) {
-      examine_signal = seen_a_decoded_frame_ && should_be_continuous;
-      seen_a_decoded_frame_ = true;
+      ++decoded_frames_seen_;
+      examine_signal = (decoded_frames_seen_ > 2) && should_be_continuous;
     }
     if (examine_signal) {
       for (int ch = 0; ch < audio_bus->channels(); ++ch) {
         EXPECT_NEAR(
             TestAudioBusFactory::kMiddleANoteFreq * 2 * audio_bus->frames() /
                 GetParam().sampling_rate,
             CountZeroCrossings(audio_bus->channel(ch), audio_bus->frames()),
             1);
       }
     }
 
     // Signal the main test thread that more audio was decoded.
     base::AutoLock auto_lock(lock_);
     total_audio_decoded_ += base::TimeDelta::FromSeconds(1) *
         audio_bus->frames() / GetParam().sampling_rate;
     cond_.Signal();
   }
 
   const scoped_refptr<StandaloneCastEnvironment> cast_environment_;
   std::unique_ptr<AudioDecoder> audio_decoder_;
   std::unique_ptr<TestAudioBusFactory> audio_bus_factory_;
   FrameId last_frame_id_;
-  bool seen_a_decoded_frame_;
+  int decoded_frames_seen_;
   std::unique_ptr<uint8_t[]> opus_encoder_memory_;
 
   base::Lock lock_;
   base::ConditionVariable cond_;
   base::TimeDelta total_audio_feed_in_;
   base::TimeDelta total_audio_decoded_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderTest);
 };
 
@@ skipping 40 matching lines @@
     AudioDecoderTestScenarios,
     AudioDecoderTest,
     ::testing::Values(
          TestScenario(CODEC_AUDIO_PCM16, 1, 8000),
          TestScenario(CODEC_AUDIO_PCM16, 2, 48000),
          TestScenario(CODEC_AUDIO_OPUS, 1, 8000),
          TestScenario(CODEC_AUDIO_OPUS, 2, 48000)));
 
 }  // namespace cast
 }  // namespace media