AcmReceiver::InsertPacket and NetEq::InsertPacket: Take ArrayView arguments

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 145 matching lines @@
 int AcmReceiver::LeastRequiredDelayMs() const {
   return neteq_->LeastRequiredDelayMs();
 }
 
 int AcmReceiver::current_sample_rate_hz() const {
   CriticalSectionScoped lock(crit_sect_.get());
   return current_sample_rate_hz_;
 }
 
 int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header,
-                              const uint8_t* incoming_payload,
-                              size_t length_payload) {
+                              rtc::ArrayView<const uint8_t> incoming_payload) {
   uint32_t receive_timestamp = 0;
   const RTPHeader* header = &rtp_header.header;  // Just a shorthand.
 
   {
     CriticalSectionScoped lock(crit_sect_.get());
 
-    const Decoder* decoder = RtpHeaderToDecoder(*header, incoming_payload);
+    const Decoder* decoder = RtpHeaderToDecoder(*header, incoming_payload[0]);
     if (!decoder) {
       LOG_F(LS_ERROR) << "Payload-type "
                       << static_cast<int>(header->payloadType)
                       << " is not registered.";
       return -1;
     }
     const int sample_rate_hz = [&decoder] {
       const auto ci = RentACodec::CodecIdFromIndex(decoder->acm_codec_id);
       return ci ? RentACodec::CodecInstById(*ci)->plfreq : -1;
     }();
     receive_timestamp = NowInTimestamp(sample_rate_hz);
 
     // 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;
     }
 
   }  // |crit_sect_| is released.
 
-  if (neteq_->InsertPacket(rtp_header, incoming_payload, length_payload,
-                           receive_timestamp) < 0) {
+  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;
   }
   return 0;
 }
 
 int AcmReceiver::GetAudio(int desired_freq_hz, AudioFrame* audio_frame) {
   enum NetEqOutputType type;
@@ skipping 293 matching lines @@
   return neteq_->GetNackList(round_trip_time_ms);
 }
 
 void AcmReceiver::ResetInitialDelay() {
   neteq_->SetMinimumDelay(0);
   // TODO(turajs): Should NetEq Buffer be flushed?
 }
 
 const AcmReceiver::Decoder* AcmReceiver::RtpHeaderToDecoder(
     const RTPHeader& rtp_header,
-    const uint8_t* payload) const {
+    uint8_t payload_type) const {
   auto it = decoders_.find(rtp_header.payloadType);
   const auto red_index =
       RentACodec::CodecIndexFromId(RentACodec::CodecId::kRED);
   if (red_index &&  // This ensures that RED is defined in WebRTC.
       it != decoders_.end() && it->second.acm_codec_id == *red_index) {
     // This is a RED packet, get the payload of the audio codec.
-    it = decoders_.find(payload[0] & 0x7F);
+    it = decoders_.find(payload_type & 0x7F);
   }
 
   // Check if the payload is registered.
   return it != decoders_.end() ? &it->second : nullptr;
 }
 
 uint32_t AcmReceiver::NowInTimestamp(int decoder_sampling_rate) const {
   // Down-cast the time to (32-6)-bit since we only care about
   // the least significant bits. (32-6) bits cover 2^(32-6) = 67108864 ms.
   // We masked 6 most significant bits of 32-bit so there is no overflow in
   // the conversion from milliseconds to timestamp.
   const uint32_t now_in_ms = static_cast<uint32_t>(
       clock_->TimeInMilliseconds() & 0x03ffffff);
   return static_cast<uint32_t>(
       (decoder_sampling_rate / 1000) * now_in_ms);
 }
 
 void AcmReceiver::GetDecodingCallStatistics(
     AudioDecodingCallStats* stats) const {
   CriticalSectionScoped lock(crit_sect_.get());
   *stats = call_stats_.GetDecodingStatistics();
 }
 
 }  // namespace acm2
 
 }  // namespace webrtc