AudioDecoder: Remove the default implementation of SampleRateHz

webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 416 matching lines @@
                        SpeechType* speech_type) override {
       for (size_t i = 0; i < encoded_len; ++i) {
         decoded[i] = next_value_++;
       }
       *speech_type = kSpeech;
       return encoded_len;
     }
 
     void Reset() override { next_value_ = 1; }
 
+    int SampleRateHz() const override { return kSampleRateHz; }
+
     size_t Channels() const override { return 1; }
 
     uint16_t next_value() const { return next_value_; }
 
    private:
     int16_t next_value_;
   } decoder_;
 
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
                             &decoder_, NetEqDecoder::kDecoderPCM16B,
@@ skipping 354 matching lines @@
   class MockAudioDecoder : public AudioDecoder {
    public:
     // TODO(nisse): Valid overrides commented out, because the gmock
     // methods don't use any override declarations, and we want to avoid
     // warnings from -Winconsistent-missing-override. See
     // http://crbug.com/428099.
     void Reset() /* override */ {}
     MOCK_CONST_METHOD2(PacketDuration, int(const uint8_t*, size_t));
     MOCK_METHOD5(DecodeInternal, int(const uint8_t*, size_t, int, int16_t*,
                                      SpeechType*));
+    int SampleRateHz() const /* override */ { return kSampleRateHz; }
     size_t Channels() const /* override */ { return kChannels; }
   } decoder_;
 
   const uint8_t kFirstPayloadValue = 1;
   const uint8_t kSecondPayloadValue = 2;
 
   EXPECT_CALL(decoder_, PacketDuration(Pointee(kFirstPayloadValue),
                                        kPayloadLengthBytes))
     .Times(AtLeast(1))
     .WillRepeatedly(Return(kNetEqMaxFrameSize + 1));
@@ skipping 385 matching lines @@
   ASSERT_TRUE(tick_timer_);
   EXPECT_EQ(0u, tick_timer_->ticks());
   AudioFrame output;
   bool muted;
   EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(1u, tick_timer_->ticks());
 }
 
 class Decoder120ms : public AudioDecoder {
  public:
-  Decoder120ms(SpeechType speech_type)
-      : next_value_(1),
+  Decoder120ms(int sample_rate_hz, SpeechType speech_type)
+      : sample_rate_hz_(sample_rate_hz),
+        next_value_(1),
         speech_type_(speech_type) {}
 
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override {
+    EXPECT_EQ(sample_rate_hz_, sample_rate_hz);
     size_t decoded_len =
         rtc::CheckedDivExact(sample_rate_hz, 1000) * 120 * Channels();
     for (size_t i = 0; i < decoded_len; ++i) {
       decoded[i] = next_value_++;
     }
     *speech_type = speech_type_;
     return decoded_len;
   }
 
   void Reset() override { next_value_ = 1; }
+  int SampleRateHz() const override { return sample_rate_hz_; }
   size_t Channels() const override { return 2; }
 
  private:
+  int sample_rate_hz_;
   int16_t next_value_;
   SpeechType speech_type_;
 };
 
 class NetEqImplTest120ms : public NetEqImplTest {
  protected:
   NetEqImplTest120ms() : NetEqImplTest() {}
   virtual ~NetEqImplTest120ms() {}
 
   void CreateInstanceNoMocks() {
@@ skipping 27 matching lines @@
     rtp_header.header.sequenceNumber = sequence_number_;
     rtp_header.header.timestamp = timestamp;
     rtp_header.header.ssrc = 15;
     const size_t kPayloadLengthBytes = 1;  // This can be arbitrary.
     uint8_t payload[kPayloadLengthBytes] = {0};
     EXPECT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header, payload, 10));
     sequence_number_++;
   }
 
   void Register120msCodec(AudioDecoder::SpeechType speech_type) {
-    decoder_.reset(new Decoder120ms(speech_type));
+    decoder_.reset(new Decoder120ms(kSamplingFreq_, speech_type));
     ASSERT_EQ(2u, decoder_->Channels());
     EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
                               decoder_.get(), NetEqDecoder::kDecoderOpus_2ch,
                               "120ms codec", kPayloadType, kSamplingFreq_));
   }
 
   std::unique_ptr<Decoder120ms> decoder_;
   AudioFrame output_;
   const uint32_t kPayloadType = 17;
   const uint32_t kSamplingFreq_ = 48000;
@@ skipping 129 matching lines @@
   EXPECT_CALL(*mock_delay_manager_, BufferLimits(_, _))
       .Times(1)
       .WillOnce(DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2)));
 
   bool muted;
   EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kAccelerate, neteq_->last_operation_for_test());
 }
 
 }// namespace webrtc