Add new method AcmReceiver::last_packet_sample_rate_hz()

webrtc/modules/audio_coding/main/acm2/acm_receiver.cc

 /*
  *  Copyright (c) 2013 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 110 matching lines @@
 AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config)
     : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       id_(config.id),
       last_audio_decoder_(nullptr),
       previous_audio_activity_(AudioFrame::kVadPassive),
       audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
       last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
       neteq_(NetEq::Create(config.neteq_config)),
       vad_enabled_(config.neteq_config.enable_post_decode_vad),
       clock_(config.clock),
-      resampled_last_output_frame_(true) {
+      resampled_last_output_frame_(true),
+      last_packet_sample_rate_hz_() {

[kwiberg-webrtc, 2015/11/23 13:03:50]

No need to call the default constructor explicitly.

[hlundin-webrtc, 2015/11/23 13:50:45]

Done.

   assert(clock_);
   memset(audio_buffer_.get(), 0, AudioFrame::kMaxDataSizeSamples);
   memset(last_audio_buffer_.get(), 0, AudioFrame::kMaxDataSizeSamples);
 }
 
 AcmReceiver::~AcmReceiver() {
   delete neteq_;
 }
 
 int AcmReceiver::SetMinimumDelay(int delay_ms) {
   if (neteq_->SetMinimumDelay(delay_ms))
     return 0;
   LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms;
   return -1;
 }
 
 int AcmReceiver::SetMaximumDelay(int delay_ms) {
   if (neteq_->SetMaximumDelay(delay_ms))
     return 0;
   LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms;
   return -1;
 }
 
 int AcmReceiver::LeastRequiredDelayMs() const {
   return neteq_->LeastRequiredDelayMs();
 }
 
+rtc::Optional<int> AcmReceiver::last_packet_sample_rate_hz() const {
+  CriticalSectionScoped lock(crit_sect_.get());
+  return last_packet_sample_rate_hz_;
+}
+
 int AcmReceiver::last_output_sample_rate_hz() const {
   return neteq_->last_output_sample_rate_hz();
 }
 
 int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header,
                               rtc::ArrayView<const uint8_t> incoming_payload) {
   uint32_t receive_timestamp = 0;
   const RTPHeader* header = &rtp_header.header;  // Just a shorthand.
 
   {
@@ skipping 14 matching lines @@
 
     // If this is a CNG while the audio codec is not mono, skip pushing in
     // packets into NetEq.
     if (IsCng(decoder->acm_codec_id) && last_audio_decoder_ &&
         last_audio_decoder_->channels > 1)
         return 0;
     if (!IsCng(decoder->acm_codec_id) &&
         decoder->acm_codec_id !=
             *RentACodec::CodecIndexFromId(RentACodec::CodecId::kAVT)) {
       last_audio_decoder_ = decoder;
+      last_packet_sample_rate_hz_ = rtc::Optional<int>(decoder->sample_rate_hz);
     }
 
   }  // |crit_sect_| is released.
 
   if (neteq_->InsertPacket(rtp_header, incoming_payload, receive_timestamp) <
       0) {
     LOG(LERROR) << "AcmReceiver::InsertPacket "
                 << static_cast<int>(header->payloadType)
                 << " Failed to insert packet";
     return -1;
@@ skipping 182 matching lines @@
       decoders_.erase(cur);
     } else {
       LOG_F(LS_ERROR) << "Cannot remove payload "
                       << static_cast<int>(cur->second.payload_type);
       ret_val = -1;
     }
   }
 
   // No codec is registered, invalidate last audio decoder.
   last_audio_decoder_ = nullptr;
+  last_packet_sample_rate_hz_ = rtc::Optional<int>();
   return ret_val;
 }
 
 int AcmReceiver::RemoveCodec(uint8_t payload_type) {
   CriticalSectionScoped lock(crit_sect_.get());
   auto it = decoders_.find(payload_type);
   if (it == decoders_.end()) {  // Such a payload-type is not registered.
     return 0;
   }
   if (neteq_->RemovePayloadType(payload_type) != NetEq::kOK) {
     LOG(LERROR) << "AcmReceiver::RemoveCodec" << static_cast<int>(payload_type);
     return -1;
   }
-  if (last_audio_decoder_ == &it->second)
+  if (last_audio_decoder_ == &it->second) {
     last_audio_decoder_ = nullptr;
+    last_packet_sample_rate_hz_ = rtc::Optional<int>();
+  }
   decoders_.erase(it);
   return 0;
 }
 
 void AcmReceiver::set_id(int id) {
   CriticalSectionScoped lock(crit_sect_.get());
   id_ = id;
 }
 
 bool AcmReceiver::GetPlayoutTimestamp(uint32_t* timestamp) {
   return neteq_->GetPlayoutTimestamp(timestamp);
 }
 
-int AcmReceiver::last_audio_codec_id() const {
-  CriticalSectionScoped lock(crit_sect_.get());
-  return last_audio_decoder_ ? last_audio_decoder_->acm_codec_id : -1;
-}
-
 int AcmReceiver::LastAudioCodec(CodecInst* codec) const {
   CriticalSectionScoped lock(crit_sect_.get());
   if (!last_audio_decoder_) {
     return -1;
   }
   *codec = *RentACodec::CodecInstById(
       *RentACodec::CodecIdFromIndex(last_audio_decoder_->acm_codec_id));
   codec->pltype = last_audio_decoder_->payload_type;
   codec->channels = last_audio_decoder_->channels;
   codec->plfreq = last_audio_decoder_->sample_rate_hz;
@@ skipping 89 matching lines @@
 
 void AcmReceiver::GetDecodingCallStatistics(
     AudioDecodingCallStats* stats) const {
   CriticalSectionScoped lock(crit_sect_.get());
   *stats = call_stats_.GetDecodingStatistics();
 }
 
 }  // namespace acm2
 
 }  // namespace webrtc