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]);

[hlundin-webrtc, 2015/11/10 10:14:35]

What happens if it is empty?

[kwiberg-webrtc, 2015/11/10 10:27:58]

We'll fail a DCHECK, and then proceed to read out of bounds. (The old behavior
was to do the exact same illegal read but without DCHECKing first.)

Would you like an improvement here? (I was thinking of
DCHECK(incoming_payload.size() >= 1).) As part of this CL?

[hlundin-webrtc, 2015/11/11 14:55:53]

Let's keep it as it is.

     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