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

webrtc/modules/audio_coding/neteq/neteq_unittest.cc

 /*
  *  Copyright (c) 2011 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 325 matching lines @@
   rtp_source_.reset(test::RtpFileSource::Create(rtp_file));
 }
 
 void NetEqDecodingTest::Process(size_t* out_len) {
   // Check if time to receive.
   while (packet_ && sim_clock_ >= packet_->time_ms()) {
     if (packet_->payload_length_bytes() > 0) {
       WebRtcRTPHeader rtp_header;
       packet_->ConvertHeader(&rtp_header);
       ASSERT_EQ(0, neteq_->InsertPacket(
-                       rtp_header, packet_->payload(),
-                       packet_->payload_length_bytes(),
-                       static_cast<uint32_t>(
-                           packet_->time_ms() * (output_sample_rate_ / 1000))));
+                       rtp_header,
+                       rtc::ArrayView<const uint8_t>(
+                           packet_->payload(), packet_->payload_length_bytes()),
+                       static_cast<uint32_t>(packet_->time_ms() *
+                                             (output_sample_rate_ / 1000))));
     }
     // Get next packet.
     packet_.reset(rtp_source_->NextPacket());
   }
 
   // Get audio from NetEq.
   NetEqOutputType type;
   int num_channels;
   ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, out_len,
                                 &num_channels, &type));
@@ skipping 128 matching lines @@
     config_.playout_mode = kPlayoutFax;
   }
 };
 
 TEST_F(NetEqDecodingTestFaxMode, TestFrameWaitingTimeStatistics) {
   // Insert 30 dummy packets at once. Each packet contains 10 ms 16 kHz audio.
   size_t num_frames = 30;
   const size_t kSamples = 10 * 16;
   const size_t kPayloadBytes = kSamples * 2;
   for (size_t i = 0; i < num_frames; ++i) {
-    uint16_t payload[kSamples] = {0};
+    const uint8_t payload[kPayloadBytes] = {0};
     WebRtcRTPHeader rtp_info;
     rtp_info.header.sequenceNumber = i;
     rtp_info.header.timestamp = i * kSamples;
     rtp_info.header.ssrc = 0x1234;  // Just an arbitrary SSRC.
     rtp_info.header.payloadType = 94;  // PCM16b WB codec.
     rtp_info.header.markerBit = 0;
-    ASSERT_EQ(0, neteq_->InsertPacket(
-        rtp_info,
-        reinterpret_cast<uint8_t*>(payload),
-        kPayloadBytes, 0));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
   }
   // Pull out all data.
   for (size_t i = 0; i < num_frames; ++i) {
     size_t out_len;
     int num_channels;
     NetEqOutputType type;
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
@@ skipping 23 matching lines @@
   const size_t kSamples = 10 * 16;
   const size_t kPayloadBytes = kSamples * 2;
   while (frame_index < kNumFrames) {
     // Insert one packet each time, except every 10th time where we insert two
     // packets at once. This will create a negative clock-drift of approx. 10%.
     int num_packets = (frame_index % 10 == 0 ? 2 : 1);
     for (int n = 0; n < num_packets; ++n) {
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(frame_index, frame_index * kSamples, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
       ++frame_index;
     }
 
     // Pull out data once.
     size_t out_len;
     int num_channels;
     NetEqOutputType type;
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
@@ skipping 10 matching lines @@
   const size_t kSamples = 10 * 16;
   const size_t kPayloadBytes = kSamples * 2;
   for (int i = 0; i < kNumFrames; ++i) {
     // Insert one packet each time, except every 10th time where we don't insert
     // any packet. This will create a positive clock-drift of approx. 11%.
     int num_packets = (i % 10 == 9 ? 0 : 1);
     for (int n = 0; n < num_packets; ++n) {
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(frame_index, frame_index * kSamples, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
       ++frame_index;
     }
 
     // Pull out data once.
     size_t out_len;
     int num_channels;
     NetEqOutputType type;
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
@@ skipping 22 matching lines @@
 
   // Insert speech for 5 seconds.
   const int kSpeechDurationMs = 5000;
   for (t_ms = 0; t_ms < kSpeechDurationMs; t_ms += 10) {
     // Each turn in this for loop is 10 ms.
     while (next_input_time_ms <= t_ms) {
       // Insert one 30 ms speech frame.
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
       ++seq_no;
       timestamp += kSamples;
       next_input_time_ms += static_cast<double>(kFrameSizeMs) * drift_factor;
     }
     // Pull out data once.
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
 
   EXPECT_EQ(kOutputNormal, type);
   int32_t delay_before = timestamp - PlayoutTimestamp();
 
   // Insert CNG for 1 minute (= 60000 ms).
   const int kCngPeriodMs = 100;
   const int kCngPeriodSamples = kCngPeriodMs * 16;  // Period in 16 kHz samples.
   const int kCngDurationMs = 60000;
   for (; t_ms < kSpeechDurationMs + kCngDurationMs; t_ms += 10) {
     // Each turn in this for loop is 10 ms.
     while (next_input_time_ms <= t_ms) {
       // Insert one CNG frame each 100 ms.
       uint8_t payload[kPayloadBytes];
       size_t payload_len;
       WebRtcRTPHeader rtp_info;
       PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, payload_len, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(
+                       rtp_info,
+                       rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
       ++seq_no;
       timestamp += kCngPeriodSamples;
       next_input_time_ms += static_cast<double>(kCngPeriodMs) * drift_factor;
     }
     // Pull out data once.
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
 
@@ skipping 26 matching lines @@
                 kMaxBlockSize, out_data_, &out_len, &num_channels, &type));
         ASSERT_EQ(kBlockSize16kHz, out_len);
         EXPECT_EQ(kOutputCNG, type);
         t_ms += 10;
       }
       // Insert one CNG frame each 100 ms.
       uint8_t payload[kPayloadBytes];
       size_t payload_len;
       WebRtcRTPHeader rtp_info;
       PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, payload_len, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(
+                       rtp_info,
+                       rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
       ++seq_no;
       timestamp += kCngPeriodSamples;
       next_input_time_ms += kCngPeriodMs * drift_factor;
     }
   }
 
   // Insert speech again until output type is speech.
   double speech_restart_time_ms = t_ms;
   while (type != kOutputNormal) {
     // Each turn in this for loop is 10 ms.
     while (next_input_time_ms <= t_ms) {
       // Insert one 30 ms speech frame.
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
       ++seq_no;
       timestamp += kSamples;
       next_input_time_ms += kFrameSizeMs * drift_factor;
     }
     // Pull out data once.
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
     // Increase clock.
     t_ms += 10;
@@ skipping 90 matching lines @@
                         kDelayToleranceMs,
                         kMaxTimeToSpeechMs);
 }
 
 TEST_F(NetEqDecodingTest, UnknownPayloadType) {
   const size_t kPayloadBytes = 100;
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = 1;  // Not registered as a decoder.
-  EXPECT_EQ(NetEq::kFail,
-            neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+  EXPECT_EQ(NetEq::kFail, neteq_->InsertPacket(rtp_info, payload, 0));
   EXPECT_EQ(NetEq::kUnknownRtpPayloadType, neteq_->LastError());
 }
 
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
 #define IF_ISAC(x) x
 #else
 #define IF_ISAC(x) DISABLED_##x
 #endif
 
 TEST_F(NetEqDecodingTest, DISABLED_ON_ANDROID(IF_ISAC(DecoderError))) {
   const size_t kPayloadBytes = 100;
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = 103;  // iSAC, but the payload is invalid.
-  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
   NetEqOutputType type;
   // Set all of |out_data_| to 1, and verify that it was set to 0 by the call
   // to GetAudio.
   for (size_t i = 0; i < kMaxBlockSize; ++i) {
     out_data_[i] = 1;
   }
   int num_channels;
   size_t samples_per_channel;
   EXPECT_EQ(NetEq::kFail,
             neteq_->GetAudio(kMaxBlockSize, out_data_,
@@ skipping 86 matching lines @@
     uint32_t receive_timestamp = 0;
     for (int n = 0; n < 10; ++n) {  // Insert few packets and get audio.
       auto block = input.GetNextBlock();
       ASSERT_EQ(expected_samples_per_channel, block.size());
       size_t enc_len_bytes =
           WebRtcPcm16b_Encode(block.data(), block.size(), payload);
       ASSERT_EQ(enc_len_bytes, expected_samples_per_channel * 2);
 
       number_channels = 0;
       samples_per_channel = 0;
-      ASSERT_EQ(0,
-                neteq_->InsertPacket(rtp_info, payload, enc_len_bytes,
-                                     receive_timestamp));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, rtc::ArrayView<const uint8_t>(
+                                                      payload, enc_len_bytes),
+                                        receive_timestamp));
       ASSERT_EQ(0,
                 neteq_->GetAudio(kBlockSize32kHz,
                                  output,
                                  &samples_per_channel,
                                  &number_channels,
                                  &type));
       ASSERT_EQ(1, number_channels);
       ASSERT_EQ(expected_samples_per_channel, samples_per_channel);
       ASSERT_EQ(kOutputNormal, type);
 
@@ skipping 138 matching lines @@
 
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = kPcm16WbPayloadType;
 
   // The first packet injected cannot be sync-packet.
   EXPECT_EQ(-1, neteq_->InsertSyncPacket(rtp_info, receive_timestamp));
 
   // Payload length of 10 ms PCM16 16 kHz.
   const size_t kPayloadBytes = kBlockSize16kHz * sizeof(int16_t);
   uint8_t payload[kPayloadBytes] = {0};
-  ASSERT_EQ(0, neteq_->InsertPacket(
-      rtp_info, payload, kPayloadBytes, receive_timestamp));
+  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, receive_timestamp));
 
   // Next packet. Last packet contained 10 ms audio.
   rtp_info.header.sequenceNumber++;
   rtp_info.header.timestamp += kBlockSize16kHz;
   receive_timestamp += kBlockSize16kHz;
 
   // Unacceptable payload types CNG, AVT (DTMF), RED.
   rtp_info.header.payloadType = kCngNbPayloadType;
   EXPECT_EQ(-1, neteq_->InsertSyncPacket(rtp_info, receive_timestamp));
 
@@ skipping 41 matching lines @@
   for (size_t n = 0; n < kPayloadBytes; ++n) {
     payload[n] = (rand() & 0xF0) + 1;  // Non-zero random sequence.
   }
   // Insert some packets which decode to noise. We are not interested in
   // actual decoded values.
   NetEqOutputType output_type;
   int num_channels;
   size_t samples_per_channel;
   uint32_t receive_timestamp = 0;
   for (int n = 0; n < 100; ++n) {
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes,
-                                      receive_timestamp));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, receive_timestamp));
     ASSERT_EQ(0, neteq_->GetAudio(kBlockSize16kHz, decoded,
                                   &samples_per_channel, &num_channels,
                                   &output_type));
     ASSERT_EQ(kBlockSize16kHz, samples_per_channel);
     ASSERT_EQ(1, num_channels);
 
     rtp_info.header.sequenceNumber++;
     rtp_info.header.timestamp += kBlockSize16kHz;
     receive_timestamp += kBlockSize16kHz;
   }
@@ skipping 14 matching lines @@
       EXPECT_TRUE(IsAllZero(decoded, samples_per_channel * num_channels));
     }
     rtp_info.header.sequenceNumber++;
     rtp_info.header.timestamp += kBlockSize16kHz;
     receive_timestamp += kBlockSize16kHz;
   }
 
   // We insert regular packets, if sync packet are not correctly buffered then
   // network statistics would show some packet loss.
   for (int n = 0; n <= algorithmic_frame_delay + 10; ++n) {
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes,
-                                      receive_timestamp));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, receive_timestamp));
     ASSERT_EQ(0, neteq_->GetAudio(kBlockSize16kHz, decoded,
                                   &samples_per_channel, &num_channels,
                                   &output_type));
     if (n >= algorithmic_frame_delay + 1) {
       // Expect that this frame contain samples from regular RTP.
       EXPECT_TRUE(IsAllNonZero(decoded, samples_per_channel * num_channels));
     }
     rtp_info.header.sequenceNumber++;
     rtp_info.header.timestamp += kBlockSize16kHz;
     receive_timestamp += kBlockSize16kHz;
@@ skipping 21 matching lines @@
     payload[n] = (rand() & 0xF0) + 1;  // Non-zero random sequence.
   }
   // Insert some packets which decode to noise. We are not interested in
   // actual decoded values.
   NetEqOutputType output_type;
   int num_channels;
   size_t samples_per_channel;
   uint32_t receive_timestamp = 0;
   int algorithmic_frame_delay = algorithmic_delay_ms_ / 10 + 1;
   for (int n = 0; n < algorithmic_frame_delay; ++n) {
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes,
-                                      receive_timestamp));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, receive_timestamp));
     ASSERT_EQ(0, neteq_->GetAudio(kBlockSize16kHz, decoded,
                                   &samples_per_channel, &num_channels,
                                   &output_type));
     ASSERT_EQ(kBlockSize16kHz, samples_per_channel);
     ASSERT_EQ(1, num_channels);
     rtp_info.header.sequenceNumber++;
     rtp_info.header.timestamp += kBlockSize16kHz;
     receive_timestamp += kBlockSize16kHz;
   }
   const int kNumSyncPackets = 10;
@@ skipping 11 matching lines @@
   NetEqNetworkStatistics network_stats;
   ASSERT_EQ(0, neteq_->NetworkStatistics(&network_stats));
   EXPECT_EQ(kNumSyncPackets * 10 + algorithmic_delay_ms_,
             network_stats.current_buffer_size_ms);
 
   // Rewind |rtp_info| to that of the first sync packet.
   memcpy(&rtp_info, &first_sync_packet_rtp_info, sizeof(rtp_info));
 
   // Insert.
   for (int n = 0; n < kNumSyncPackets; ++n) {
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes,
-                                      receive_timestamp));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, receive_timestamp));
     rtp_info.header.sequenceNumber++;
     rtp_info.header.timestamp += kBlockSize16kHz;
     receive_timestamp += kBlockSize16kHz;
   }
 
   // Decode.
   for (int n = 0; n < kNumSyncPackets; ++n) {
     ASSERT_EQ(0, neteq_->GetAudio(kBlockSize16kHz, decoded,
                                   &samples_per_channel, &num_channels,
                                   &output_type));
@@ skipping 31 matching lines @@
   for (double t_ms = 0; t_ms < kSpeechDurationMs; t_ms += 10) {
     // Each turn in this for loop is 10 ms.
     while (next_input_time_ms <= t_ms) {
       // Insert one 30 ms speech frame.
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(seq_no, timestamp, &rtp_info);
       if (drop_seq_numbers.find(seq_no) == drop_seq_numbers.end()) {
         // This sequence number was not in the set to drop. Insert it.
         ASSERT_EQ(0,
-                  neteq_->InsertPacket(rtp_info, payload, kPayloadBytes,
-                                       receive_timestamp));
+                  neteq_->InsertPacket(rtp_info, payload, receive_timestamp));
         ++packets_inserted;
       }
       NetEqNetworkStatistics network_stats;
       ASSERT_EQ(0, neteq_->NetworkStatistics(&network_stats));
 
       // Due to internal NetEq logic, preferred buffer-size is about 4 times the
       // packet size for first few packets. Therefore we refrain from checking
       // the criteria.
       if (packets_inserted > 4) {
         // Expect preferred and actual buffer size to be no more than 2 frames.
@@ skipping 67 matching lines @@
       algorithmic_delay_ms_ * kSampleRateKhz, 5 * kSampleRateKhz / 8);
   // Insert three speech packets. Three are needed to get the frame length
   // correct.
   size_t out_len;
   int num_channels;
   NetEqOutputType type;
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
   for (int i = 0; i < 3; ++i) {
     PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
     ++seq_no;
     timestamp += kSamples;
 
     // Pull audio once.
     ASSERT_EQ(0,
               neteq_->GetAudio(
                   kMaxBlockSize, out_data_, &out_len, &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
   // Verify speech output.
   EXPECT_EQ(kOutputNormal, type);
 
   // Insert same CNG packet twice.
   const int kCngPeriodMs = 100;
   const int kCngPeriodSamples = kCngPeriodMs * kSampleRateKhz;
   size_t payload_len;
   PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
   // This is the first time this CNG packet is inserted.
-  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, payload_len, 0));
+  ASSERT_EQ(
+      0, neteq_->InsertPacket(
+             rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
 
   // Pull audio once and make sure CNG is played.
   ASSERT_EQ(0,
             neteq_->GetAudio(
                 kMaxBlockSize, out_data_, &out_len, &num_channels, &type));
   ASSERT_EQ(kBlockSize16kHz, out_len);
   EXPECT_EQ(kOutputCNG, type);
   EXPECT_EQ(timestamp - algorithmic_delay_samples, PlayoutTimestamp());
 
   // Insert the same CNG packet again. Note that at this point it is old, since
   // we have already decoded the first copy of it.
-  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, payload_len, 0));
+  ASSERT_EQ(
+      0, neteq_->InsertPacket(
+             rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
 
   // Pull audio until we have played |kCngPeriodMs| of CNG. Start at 10 ms since
   // we have already pulled out CNG once.
   for (int cng_time_ms = 10; cng_time_ms < kCngPeriodMs; cng_time_ms += 10) {
     ASSERT_EQ(0,
               neteq_->GetAudio(
                   kMaxBlockSize, out_data_, &out_len, &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
     EXPECT_EQ(kOutputCNG, type);
     EXPECT_EQ(timestamp - algorithmic_delay_samples,
               PlayoutTimestamp());
   }
 
   // Insert speech again.
   ++seq_no;
   timestamp += kCngPeriodSamples;
   PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
 
   // Pull audio once and verify that the output is speech again.
   ASSERT_EQ(0,
             neteq_->GetAudio(
                 kMaxBlockSize, out_data_, &out_len, &num_channels, &type));
   ASSERT_EQ(kBlockSize16kHz, out_len);
   EXPECT_EQ(kOutputNormal, type);
   EXPECT_EQ(timestamp + kSamples - algorithmic_delay_samples,
             PlayoutTimestamp());
 }
@@ skipping 14 matching lines @@
   const int kSamples = kFrameSizeMs * kSampleRateKhz;
   const int kPayloadBytes = kSamples * 2;
   const int kCngPeriodMs = 100;
   const int kCngPeriodSamples = kCngPeriodMs * kSampleRateKhz;
   size_t payload_len;
 
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
 
   PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
-  ASSERT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_info, payload, payload_len, 0));
+  ASSERT_EQ(
+      NetEq::kOK,
+      neteq_->InsertPacket(
+          rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
   ++seq_no;
   timestamp += kCngPeriodSamples;
 
   // Pull audio once and make sure CNG is played.
   size_t out_len;
   int num_channels;
   NetEqOutputType type;
   ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                 &num_channels, &type));
   ASSERT_EQ(kBlockSize16kHz, out_len);
   EXPECT_EQ(kOutputCNG, type);
 
   // Insert some speech packets.
   for (int i = 0; i < 3; ++i) {
     PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
     ++seq_no;
     timestamp += kSamples;
 
     // Pull audio once.
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
   // Verify speech output.
   EXPECT_EQ(kOutputNormal, type);
 }
 
 }  // namespace webrtc