Removed RTPHeader from NetEq's Packet struct.

webrtc/modules/audio_coding/neteq/neteq_impl.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 563 matching lines @@
 
 int NetEqImpl::InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
                                     rtc::ArrayView<const uint8_t> payload,
                                     uint32_t receive_timestamp) {
   if (payload.empty()) {
     LOG_F(LS_ERROR) << "payload is empty";
     return kInvalidPointer;
   }
 
   PacketList packet_list;
-  RTPHeader main_header;
   {
     // Convert to Packet.
     // Create |packet| within this separate scope, since it should not be used
     // directly once it's been inserted in the packet list. This way, |packet|
     // is not defined outside of this block.
     Packet* packet = new Packet;
-    packet->header.markerBit = false;
-    packet->header.payloadType = rtp_header.header.payloadType;
-    packet->header.sequenceNumber = rtp_header.header.sequenceNumber;
-    packet->header.timestamp = rtp_header.header.timestamp;
-    packet->header.ssrc = rtp_header.header.ssrc;
-    packet->header.numCSRCs = 0;
+    packet->payload_type = rtp_header.header.payloadType;
+    packet->sequence_number = rtp_header.header.sequenceNumber;
+    packet->timestamp = rtp_header.header.timestamp;
     packet->payload.SetData(payload.data(), payload.size());
     // Waiting time will be set upon inserting the packet in the buffer.
     RTC_DCHECK(!packet->waiting_time);
     // Insert packet in a packet list.
     packet_list.push_back(packet);
-    // Save main payloads header for later.
-    memcpy(&main_header, &packet->header, sizeof(main_header));
   }
 
   bool update_sample_rate_and_channels = false;
   // Reinitialize NetEq if it's needed (changed SSRC or first call).
-  if ((main_header.ssrc != ssrc_) || first_packet_) {
+  if ((rtp_header.header.ssrc != ssrc_) || first_packet_) {
     // Note: |first_packet_| will be cleared further down in this method, once
     // the packet has been successfully inserted into the packet buffer.
 
-    rtcp_.Init(main_header.sequenceNumber);
+    rtcp_.Init(rtp_header.header.sequenceNumber);
 
     // Flush the packet buffer and DTMF buffer.
     packet_buffer_->Flush();
     dtmf_buffer_->Flush();
 
     // Store new SSRC.
-    ssrc_ = main_header.ssrc;
+    ssrc_ = rtp_header.header.ssrc;
 
     // Update audio buffer timestamp.
-    sync_buffer_->IncreaseEndTimestamp(main_header.timestamp - timestamp_);
+    sync_buffer_->IncreaseEndTimestamp(rtp_header.header.timestamp -
+                                       timestamp_);
 
     // Update codecs.
-    timestamp_ = main_header.timestamp;
+    timestamp_ = rtp_header.header.timestamp;
 
     // Reset timestamp scaling.
     timestamp_scaler_->Reset();
 
     // Trigger an update of sampling rate and the number of channels.
     update_sample_rate_and_channels = true;
   }
 
   // Update RTCP statistics, only for regular packets.
-  rtcp_.Update(main_header, receive_timestamp);
+  rtcp_.Update(rtp_header.header, receive_timestamp);
+
+  if (nack_enabled_) {
+    RTC_DCHECK(nack_);
+    if (update_sample_rate_and_channels) {
+      nack_->Reset();
+    }
+    nack_->UpdateLastReceivedPacket(rtp_header.header.sequenceNumber,
+                                    rtp_header.header.timestamp);
+  }
 
   // Check for RED payload type, and separate payloads into several packets.
-  if (decoder_database_->IsRed(main_header.payloadType)) {
+  if (decoder_database_->IsRed(rtp_header.header.payloadType)) {
     if (!red_payload_splitter_->SplitRed(&packet_list)) {
       PacketBuffer::DeleteAllPackets(&packet_list);
       return kRedundancySplitError;
     }
     // Only accept a few RED payloads of the same type as the main data,
     // DTMF events and CNG.
     red_payload_splitter_->CheckRedPayloads(&packet_list, *decoder_database_);
-    // Update the stored main payload header since the main payload has now
-    // changed.
-    memcpy(&main_header, &packet_list.front()->header, sizeof(main_header));
   }
 
   // Check payload types.
   if (decoder_database_->CheckPayloadTypes(packet_list) ==
       DecoderDatabase::kDecoderNotFound) {
     PacketBuffer::DeleteAllPackets(&packet_list);
     return kUnknownRtpPayloadType;
   }
 
+  RTC_DCHECK(!packet_list.empty());
+  // Store these for later use, since the first packet may very well disappear
+  // before we need these values.
+  const uint32_t main_timestamp = packet_list.front()->timestamp;
+  const uint8_t main_payload_type = packet_list.front()->payload_type;
+  const uint16_t main_sequence_number = packet_list.front()->sequence_number;
+
   // Scale timestamp to internal domain (only for some codecs).
   timestamp_scaler_->ToInternal(&packet_list);
 
   // Process DTMF payloads. Cycle through the list of packets, and pick out any
   // DTMF payloads found.
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
     Packet* current_packet = (*it);
     assert(current_packet);
     assert(!current_packet->payload.empty());
-    if (decoder_database_->IsDtmf(current_packet->header.payloadType)) {
+    if (decoder_database_->IsDtmf(current_packet->payload_type)) {
       DtmfEvent event;
-      int ret = DtmfBuffer::ParseEvent(current_packet->header.timestamp,
+      int ret = DtmfBuffer::ParseEvent(current_packet->timestamp,
                                        current_packet->payload.data(),
                                        current_packet->payload.size(), &event);
       if (ret != DtmfBuffer::kOK) {
         PacketBuffer::DeleteAllPackets(&packet_list);
         return kDtmfParsingError;
       }
       if (dtmf_buffer_->InsertEvent(event) != DtmfBuffer::kOK) {
         PacketBuffer::DeleteAllPackets(&packet_list);
         return kDtmfInsertError;
       }
       delete current_packet;
       it = packet_list.erase(it);
     } else {
       ++it;
     }
   }
 
   // Update bandwidth estimate, if the packet is not comfort noise.
   if (!packet_list.empty() &&
-      !decoder_database_->IsComfortNoise(main_header.payloadType)) {
+      !decoder_database_->IsComfortNoise(main_payload_type)) {
     // The list can be empty here if we got nothing but DTMF payloads.
-    AudioDecoder* decoder =
-        decoder_database_->GetDecoder(main_header.payloadType);
-    assert(decoder);  // Should always get a valid object, since we have
-    // already checked that the payload types are known.
+    AudioDecoder* decoder = decoder_database_->GetDecoder(main_payload_type);
+    RTC_DCHECK(decoder);  // Should always get a valid object, since we have
+                          // already checked that the payload types are known.
     decoder->IncomingPacket(packet_list.front()->payload.data(),
                             packet_list.front()->payload.size(),
-                            packet_list.front()->header.sequenceNumber,
-                            packet_list.front()->header.timestamp,
+                            packet_list.front()->sequence_number,
+                            packet_list.front()->timestamp,
                             receive_timestamp);
   }
 
   PacketList parsed_packet_list;
   while (!packet_list.empty()) {
     std::unique_ptr<Packet> packet(packet_list.front());
     packet_list.pop_front();
     const DecoderDatabase::DecoderInfo* info =
-        decoder_database_->GetDecoderInfo(packet->header.payloadType);
+        decoder_database_->GetDecoderInfo(packet->payload_type);
     if (!info) {
       LOG(LS_WARNING) << "SplitAudio unknown payload type";
       return kUnknownRtpPayloadType;
     }
 
     if (info->IsComfortNoise()) {
       // Carry comfort noise packets along.
       parsed_packet_list.push_back(packet.release());
     } else {
       std::vector<AudioDecoder::ParseResult> results =
           info->GetDecoder()->ParsePayload(std::move(packet->payload),
-                                           packet->header.timestamp);
-      const RTPHeader& original_header = packet->header;
+                                           packet->timestamp);
+      const auto sequence_number = packet->sequence_number;
+      const auto payload_type = packet->payload_type;
       const Packet::Priority original_priority = packet->priority;
       for (auto& result : results) {
         RTC_DCHECK(result.frame);
         // Reuse the packet if possible.
         if (!packet) {
           packet.reset(new Packet);
-          packet->header = original_header;
+          packet->sequence_number = sequence_number;
+          packet->payload_type = payload_type;
         }
-        packet->header.timestamp = result.timestamp;
+        packet->timestamp = result.timestamp;
         RTC_DCHECK_GE(result.priority, 0);
         packet->priority.codec_level = result.priority;
         packet->priority.red_level = original_priority.red_level;
         packet->frame = std::move(result.frame);
         parsed_packet_list.push_back(packet.release());
       }
     }
   }
 
-  if (nack_enabled_) {
-    RTC_DCHECK(nack_);
-    if (update_sample_rate_and_channels) {
-      nack_->Reset();
-    }
-    nack_->UpdateLastReceivedPacket(
-        parsed_packet_list.front()->header.sequenceNumber,
-        parsed_packet_list.front()->header.timestamp);
-  }
-
   // Insert packets in buffer.
   const size_t buffer_length_before_insert =
       packet_buffer_->NumPacketsInBuffer();
   const int ret = packet_buffer_->InsertPacketList(
       &parsed_packet_list, *decoder_database_, &current_rtp_payload_type_,
       &current_cng_rtp_payload_type_);
   if (ret == PacketBuffer::kFlushed) {
     // Reset DSP timestamp etc. if packet buffer flushed.
     new_codec_ = true;
     update_sample_rate_and_channels = true;
@@ skipping 14 matching lines @@
         << " is unknown where it shouldn't be";
   }
 
   if (update_sample_rate_and_channels && !packet_buffer_->Empty()) {
     // We do not use |current_rtp_payload_type_| to |set payload_type|, but
     // get the next RTP header from |packet_buffer_| to obtain the payload type.
     // The reason for it is the following corner case. If NetEq receives a
     // CNG packet with a sample rate different than the current CNG then it
     // flushes its buffer, assuming send codec must have been changed. However,
     // payload type of the hypothetically new send codec is not known.
-    const RTPHeader* rtp_header = packet_buffer_->NextRtpHeader();
-    assert(rtp_header);
-    int payload_type = rtp_header->payloadType;
+    const Packet* next_packet = packet_buffer_->PeekNextPacket();
+    RTC_DCHECK(next_packet);
+    const int payload_type = next_packet->payload_type;
     size_t channels = 1;
     if (!decoder_database_->IsComfortNoise(payload_type)) {
       AudioDecoder* decoder = decoder_database_->GetDecoder(payload_type);
       assert(decoder);  // Payloads are already checked to be valid.
       channels = decoder->Channels();
     }
     const DecoderDatabase::DecoderInfo* decoder_info =
         decoder_database_->GetDecoderInfo(payload_type);
     assert(decoder_info);
     if (decoder_info->SampleRateHz() != fs_hz_ ||
         channels != algorithm_buffer_->Channels()) {
       SetSampleRateAndChannels(decoder_info->SampleRateHz(),
                                channels);
     }
     if (nack_enabled_) {
       RTC_DCHECK(nack_);
       // Update the sample rate even if the rate is not new, because of Reset().
       nack_->UpdateSampleRate(fs_hz_);
     }
   }
 
   // TODO(hlundin): Move this code to DelayManager class.
   const DecoderDatabase::DecoderInfo* dec_info =
-          decoder_database_->GetDecoderInfo(main_header.payloadType);
+      decoder_database_->GetDecoderInfo(main_payload_type);
   assert(dec_info);  // Already checked that the payload type is known.
   delay_manager_->LastDecodedWasCngOrDtmf(dec_info->IsComfortNoise() ||
                                           dec_info->IsDtmf());
   if (delay_manager_->last_pack_cng_or_dtmf() == 0) {
     // Calculate the total speech length carried in each packet.
     const size_t buffer_length_after_insert =
         packet_buffer_->NumPacketsInBuffer();
 
     if (buffer_length_after_insert > buffer_length_before_insert) {
       const size_t packet_length_samples =
           (buffer_length_after_insert - buffer_length_before_insert) *
           decoder_frame_length_;
       if (packet_length_samples != decision_logic_->packet_length_samples()) {
         decision_logic_->set_packet_length_samples(packet_length_samples);
         delay_manager_->SetPacketAudioLength(
             rtc::checked_cast<int>((1000 * packet_length_samples) / fs_hz_));
       }
     }
 
     // Update statistics.
-    if ((int32_t) (main_header.timestamp - timestamp_) >= 0 &&
-        !new_codec_) {
+    if ((int32_t)(main_timestamp - timestamp_) >= 0 && !new_codec_) {
       // Only update statistics if incoming packet is not older than last played
       // out packet, and if new codec flag is not set.
-      delay_manager_->Update(main_header.sequenceNumber, main_header.timestamp,
-                             fs_hz_);
+      delay_manager_->Update(main_sequence_number, main_timestamp, fs_hz_);
     }
   } else if (delay_manager_->last_pack_cng_or_dtmf() == -1) {
     // This is first "normal" packet after CNG or DTMF.
     // Reset packet time counter and measure time until next packet,
     // but don't update statistics.
     delay_manager_->set_last_pack_cng_or_dtmf(0);
     delay_manager_->ResetPacketIatCount();
   }
   return 0;
 }
@@ skipping 237 matching lines @@
   // Initialize output variables.
   *play_dtmf = false;
   *operation = kUndefined;
 
   assert(sync_buffer_.get());
   uint32_t end_timestamp = sync_buffer_->end_timestamp();
   if (!new_codec_) {
     const uint32_t five_seconds_samples = 5 * fs_hz_;
     packet_buffer_->DiscardOldPackets(end_timestamp, five_seconds_samples);
   }
-  const RTPHeader* header = packet_buffer_->NextRtpHeader();
+  const Packet* packet = packet_buffer_->PeekNextPacket();
 
   RTC_DCHECK(!generated_noise_stopwatch_ ||
              generated_noise_stopwatch_->ElapsedTicks() >= 1);
   uint64_t generated_noise_samples =
       generated_noise_stopwatch_
           ? (generated_noise_stopwatch_->ElapsedTicks() - 1) *
                     output_size_samples_ +
                 decision_logic_->noise_fast_forward()
           : 0;
 
   if (decision_logic_->CngRfc3389On() || last_mode_ == kModeRfc3389Cng) {
     // Because of timestamp peculiarities, we have to "manually" disallow using
     // a CNG packet with the same timestamp as the one that was last played.
     // This can happen when using redundancy and will cause the timing to shift.
-    while (header && decoder_database_->IsComfortNoise(header->payloadType) &&
-           (end_timestamp >= header->timestamp ||
-            end_timestamp + generated_noise_samples > header->timestamp)) {
+    while (packet && decoder_database_->IsComfortNoise(packet->payload_type) &&
+           (end_timestamp >= packet->timestamp ||
+            end_timestamp + generated_noise_samples > packet->timestamp)) {
       // Don't use this packet, discard it.
       if (packet_buffer_->DiscardNextPacket() != PacketBuffer::kOK) {
         assert(false);  // Must be ok by design.
       }
       // Check buffer again.
       if (!new_codec_) {
         packet_buffer_->DiscardOldPackets(end_timestamp, 5 * fs_hz_);
       }
-      header = packet_buffer_->NextRtpHeader();
+      packet = packet_buffer_->PeekNextPacket();
     }
   }
 
   assert(expand_.get());
   const int samples_left = static_cast<int>(sync_buffer_->FutureLength() -
       expand_->overlap_length());
   if (last_mode_ == kModeAccelerateSuccess ||
       last_mode_ == kModeAccelerateLowEnergy ||
       last_mode_ == kModePreemptiveExpandSuccess ||
       last_mode_ == kModePreemptiveExpandLowEnergy) {
@@ skipping 12 matching lines @@
 
   // Get instruction.
   assert(sync_buffer_.get());
   assert(expand_.get());
   generated_noise_samples =
       generated_noise_stopwatch_
           ? generated_noise_stopwatch_->ElapsedTicks() * output_size_samples_ +
                 decision_logic_->noise_fast_forward()
           : 0;
   *operation = decision_logic_->GetDecision(
-      *sync_buffer_, *expand_, decoder_frame_length_, header, last_mode_,
+      *sync_buffer_, *expand_, decoder_frame_length_, packet, last_mode_,
       *play_dtmf, generated_noise_samples, &reset_decoder_);
 
   // Check if we already have enough samples in the |sync_buffer_|. If so,
   // change decision to normal, unless the decision was merge, accelerate, or
   // preemptive expand.
   if (samples_left >= rtc::checked_cast<int>(output_size_samples_) &&
       *operation != kMerge &&
       *operation != kAccelerate &&
       *operation != kFastAccelerate &&
       *operation != kPreemptiveExpand) {
     *operation = kNormal;
     return 0;
   }
 
   decision_logic_->ExpandDecision(*operation);
 
   // Check conditions for reset.
   if (new_codec_ || *operation == kUndefined) {
     // The only valid reason to get kUndefined is that new_codec_ is set.
     assert(new_codec_);
-    if (*play_dtmf && !header) {
+    if (*play_dtmf && !packet) {
       timestamp_ = dtmf_event->timestamp;
     } else {
-      if (!header) {
+      if (!packet) {
         LOG(LS_ERROR) << "Packet missing where it shouldn't.";
         return -1;
       }
-      timestamp_ = header->timestamp;
+      timestamp_ = packet->timestamp;
       if (*operation == kRfc3389CngNoPacket &&
-          decoder_database_->IsComfortNoise(header->payloadType)) {
+          decoder_database_->IsComfortNoise(packet->payload_type)) {
         // Change decision to CNG packet, since we do have a CNG packet, but it
         // was considered too early to use. Now, use it anyway.
         *operation = kRfc3389Cng;
       } else if (*operation != kRfc3389Cng) {
         *operation = kNormal;
       }
     }
     // Adjust |sync_buffer_| timestamp before setting |end_timestamp| to the
     // new value.
     sync_buffer_->IncreaseEndTimestamp(timestamp_ - end_timestamp);
@@ skipping 93 matching lines @@
           std::max(merge_->RequiredFutureSamples(), required_samples);
       break;
     }
     default: {
       // Do nothing.
     }
   }
 
   // Get packets from buffer.
   int extracted_samples = 0;
-  if (header &&
-      *operation != kAlternativePlc &&
+  if (packet && *operation != kAlternativePlc &&
       *operation != kAlternativePlcIncreaseTimestamp &&
       *operation != kAudioRepetition &&
       *operation != kAudioRepetitionIncreaseTimestamp) {
-    sync_buffer_->IncreaseEndTimestamp(header->timestamp - end_timestamp);
+    sync_buffer_->IncreaseEndTimestamp(packet->timestamp - end_timestamp);
     if (decision_logic_->CngOff()) {
       // Adjustment of timestamp only corresponds to an actual packet loss
       // if comfort noise is not played. If comfort noise was just played,
       // this adjustment of timestamp is only done to get back in sync with the
       // stream timestamp; no loss to report.
-      stats_.LostSamples(header->timestamp - end_timestamp);
+      stats_.LostSamples(packet->timestamp - end_timestamp);
     }
 
     if (*operation != kRfc3389Cng) {
       // We are about to decode and use a non-CNG packet.
       decision_logic_->SetCngOff();
     }
 
     extracted_samples = ExtractPackets(required_samples, packet_list);
     if (extracted_samples < 0) {
       return kPacketBufferCorruption;
@@ skipping 23 matching lines @@
                       int* decoded_length,
                       AudioDecoder::SpeechType* speech_type) {
   *speech_type = AudioDecoder::kSpeech;
 
   // When packet_list is empty, we may be in kCodecInternalCng mode, and for
   // that we use current active decoder.
   AudioDecoder* decoder = decoder_database_->GetActiveDecoder();
 
   if (!packet_list->empty()) {
     const Packet* packet = packet_list->front();
-    uint8_t payload_type = packet->header.payloadType;
+    uint8_t payload_type = packet->payload_type;
     if (!decoder_database_->IsComfortNoise(payload_type)) {
       decoder = decoder_database_->GetDecoder(payload_type);
       assert(decoder);
       if (!decoder) {
         LOG(LS_WARNING) << "Unknown payload type "
                         << static_cast<int>(payload_type);
         PacketBuffer::DeleteAllPackets(packet_list);
         return kDecoderNotFound;
       }
       bool decoder_changed;
@@ skipping 115 matching lines @@
 
 int NetEqImpl::DecodeLoop(PacketList* packet_list, const Operations& operation,
                           AudioDecoder* decoder, int* decoded_length,
                           AudioDecoder::SpeechType* speech_type) {
   Packet* packet = NULL;
   if (!packet_list->empty()) {
     packet = packet_list->front();
   }
 
   // Do decoding.
-  while (packet &&
-      !decoder_database_->IsComfortNoise(packet->header.payloadType)) {
+  while (packet && !decoder_database_->IsComfortNoise(packet->payload_type)) {
     assert(decoder);  // At this point, we must have a decoder object.
     // The number of channels in the |sync_buffer_| should be the same as the
     // number decoder channels.
     assert(sync_buffer_->Channels() == decoder->Channels());
     assert(decoded_buffer_length_ >= kMaxFrameSize * decoder->Channels());
     assert(operation == kNormal || operation == kAccelerate ||
            operation == kFastAccelerate || operation == kMerge ||
            operation == kPreemptiveExpand);
     packet_list->pop_front();
     auto opt_result = packet->frame->Decode(
@@ skipping 28 matching lines @@
       packet = packet_list->front();
     } else {
       packet = NULL;
     }
   }  // End of decode loop.
 
   // If the list is not empty at this point, either a decoding error terminated
   // the while-loop, or list must hold exactly one CNG packet.
   assert(packet_list->empty() || *decoded_length < 0 ||
          (packet_list->size() == 1 && packet &&
-             decoder_database_->IsComfortNoise(packet->header.payloadType)));
+          decoder_database_->IsComfortNoise(packet->payload_type)));
   return 0;
 }
 
 void NetEqImpl::DoNormal(const int16_t* decoded_buffer, size_t decoded_length,
                          AudioDecoder::SpeechType speech_type, bool play_dtmf) {
   assert(normal_.get());
   assert(mute_factor_array_.get());
   normal_->Process(decoded_buffer, decoded_length, last_mode_,
                    mute_factor_array_.get(), algorithm_buffer_.get());
   if (decoded_length != 0) {
@@ skipping 221 matching lines @@
   expand_->Reset();
   return 0;
 }
 
 int NetEqImpl::DoRfc3389Cng(PacketList* packet_list, bool play_dtmf) {
   if (!packet_list->empty()) {
     // Must have exactly one SID frame at this point.
     assert(packet_list->size() == 1);
     Packet* packet = packet_list->front();
     packet_list->pop_front();
-    if (!decoder_database_->IsComfortNoise(packet->header.payloadType)) {
+    if (!decoder_database_->IsComfortNoise(packet->payload_type)) {
       LOG(LS_ERROR) << "Trying to decode non-CNG payload as CNG.";
       return kOtherError;
     }
     // UpdateParameters() deletes |packet|.
     if (comfort_noise_->UpdateParameters(packet) ==
         ComfortNoise::kInternalError) {
       algorithm_buffer_->Zeros(output_size_samples_);
       return -comfort_noise_->internal_error_code();
     }
   }
@@ skipping 155 matching lines @@
 }
 
 int NetEqImpl::ExtractPackets(size_t required_samples,
                               PacketList* packet_list) {
   bool first_packet = true;
   uint8_t prev_payload_type = 0;
   uint32_t prev_timestamp = 0;
   uint16_t prev_sequence_number = 0;
   bool next_packet_available = false;
 
-  const RTPHeader* header = packet_buffer_->NextRtpHeader();
-  assert(header);
-  if (!header) {
+  const Packet* next_packet = packet_buffer_->PeekNextPacket();
+  RTC_DCHECK(next_packet);
+  if (!next_packet) {
     LOG(LS_ERROR) << "Packet buffer unexpectedly empty.";
     return -1;
   }
-  uint32_t first_timestamp = header->timestamp;
+  uint32_t first_timestamp = next_packet->timestamp;
   size_t extracted_samples = 0;
 
   // Packet extraction loop.
   do {
-    timestamp_ = header->timestamp;
+    timestamp_ = next_packet->timestamp;
     size_t discard_count = 0;
     Packet* packet = packet_buffer_->GetNextPacket(&discard_count);
-    // |header| may be invalid after the |packet_buffer_| operation.
-    header = NULL;
+    // |next_packet| may be invalid after the |packet_buffer_| operation.
+    next_packet = NULL;
     if (!packet) {
       LOG(LS_ERROR) << "Should always be able to extract a packet here";
       assert(false);  // Should always be able to extract a packet here.
       return -1;
     }
     stats_.PacketsDiscarded(discard_count);
     stats_.StoreWaitingTime(packet->waiting_time->ElapsedMs());
     RTC_DCHECK(!packet->empty());
     packet_list->push_back(packet);  // Store packet in list.
 
     if (first_packet) {
       first_packet = false;
       if (nack_enabled_) {
         RTC_DCHECK(nack_);
         // TODO(henrik.lundin): Should we update this for all decoded packets?
-        nack_->UpdateLastDecodedPacket(packet->header.sequenceNumber,
-                                       packet->header.timestamp);
+        nack_->UpdateLastDecodedPacket(packet->sequence_number,
+                                       packet->timestamp);
       }
-      prev_sequence_number = packet->header.sequenceNumber;
-      prev_timestamp = packet->header.timestamp;
-      prev_payload_type = packet->header.payloadType;
+      prev_sequence_number = packet->sequence_number;
+      prev_timestamp = packet->timestamp;
+      prev_payload_type = packet->payload_type;
     }
 
     // Store number of extracted samples.
     size_t packet_duration = 0;
     if (packet->frame) {
       packet_duration = packet->frame->Duration();
       // TODO(ossu): Is this the correct way to track Opus FEC packets?
       if (packet->priority.codec_level > 0) {
         stats_.SecondaryDecodedSamples(rtc::checked_cast<int>(packet_duration));
       }
-    } else if (!decoder_database_->IsComfortNoise(packet->header.payloadType)) {
+    } else if (!decoder_database_->IsComfortNoise(packet->payload_type)) {
       LOG(LS_WARNING) << "Unknown payload type "
-                      << static_cast<int>(packet->header.payloadType);
+                      << static_cast<int>(packet->payload_type);
       RTC_NOTREACHED();
     }
 
     if (packet_duration == 0) {
       // Decoder did not return a packet duration. Assume that the packet
       // contains the same number of samples as the previous one.
       packet_duration = decoder_frame_length_;
     }
-    extracted_samples = packet->header.timestamp - first_timestamp +
-        packet_duration;
+    extracted_samples = packet->timestamp - first_timestamp + packet_duration;
 
     // Check what packet is available next.
-    header = packet_buffer_->NextRtpHeader();
+    next_packet = packet_buffer_->PeekNextPacket();
     next_packet_available = false;
-    if (header && prev_payload_type == header->payloadType) {
-      int16_t seq_no_diff = header->sequenceNumber - prev_sequence_number;
-      size_t ts_diff = header->timestamp - prev_timestamp;
+    if (next_packet && prev_payload_type == next_packet->payload_type) {
+      int16_t seq_no_diff = next_packet->sequence_number - prev_sequence_number;
+      size_t ts_diff = next_packet->timestamp - prev_timestamp;
       if (seq_no_diff == 1 ||
           (seq_no_diff == 0 && ts_diff == decoder_frame_length_)) {
         // The next sequence number is available, or the next part of a packet
         // that was split into pieces upon insertion.
         next_packet_available = true;
       }
-      prev_sequence_number = header->sequenceNumber;
+      prev_sequence_number = next_packet->sequence_number;
     }
   } while (extracted_samples < required_samples && next_packet_available);
 
   if (extracted_samples > 0) {
     // Delete old packets only when we are going to decode something. Otherwise,
     // we could end up in the situation where we never decode anything, since
     // all incoming packets are considered too old but the buffer will also
     // never be flooded and flushed.
     packet_buffer_->DiscardAllOldPackets(timestamp_);
   }
@@ skipping 98 matching lines @@
   }
 }
 
 void NetEqImpl::CreateDecisionLogic() {
   decision_logic_.reset(DecisionLogic::Create(
       fs_hz_, output_size_samples_, playout_mode_, decoder_database_.get(),
       *packet_buffer_.get(), delay_manager_.get(), buffer_level_filter_.get(),
       tick_timer_.get()));
 }
 }  // namespace webrtc