Revert of Change NetEq::InsertPacket to take an RTPHeader

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 113 matching lines @@
     SetSampleRateAndChannels(fs, 1);  // Default is 1 channel.
   }
   RTC_DCHECK(!vad_->enabled());
   if (config.enable_post_decode_vad) {
     vad_->Enable();
   }
 }
 
 NetEqImpl::~NetEqImpl() = default;
 
-int NetEqImpl::InsertPacket(const RTPHeader& rtp_header,
+int NetEqImpl::InsertPacket(const WebRtcRTPHeader& rtp_header,
                             rtc::ArrayView<const uint8_t> payload,
                             uint32_t receive_timestamp) {
   rtc::MsanCheckInitialized(payload);
   TRACE_EVENT0("webrtc", "NetEqImpl::InsertPacket");
   rtc::CritScope lock(&crit_sect_);
   int error =
       InsertPacketInternal(rtp_header, payload, receive_timestamp);
   if (error != 0) {
     error_code_ = error;
     return kFail;
@@ skipping 429 matching lines @@
   return sync_buffer_.get();
 }
 
 Operations NetEqImpl::last_operation_for_test() const {
   rtc::CritScope lock(&crit_sect_);
   return last_operation_;
 }
 
 // Methods below this line are private.
 
-int NetEqImpl::InsertPacketInternal(const RTPHeader& rtp_header,
+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;
   // Insert packet in a packet list.
   packet_list.push_back([&rtp_header, &payload] {
     // Convert to Packet.
     Packet packet;
-    packet.payload_type = rtp_header.payloadType;
-    packet.sequence_number = rtp_header.sequenceNumber;
-    packet.timestamp = rtp_header.timestamp;
+    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);
     return packet;
   }());
 
-  bool update_sample_rate_and_channels =
-      first_packet_ || (rtp_header.ssrc != ssrc_);
+  bool update_sample_rate_and_channels = first_packet_ ||
+    (rtp_header.header.ssrc != ssrc_);
 
   if (update_sample_rate_and_channels) {
     // Reset timestamp scaling.
     timestamp_scaler_->Reset();
   }
 
-  if (!decoder_database_->IsRed(rtp_header.payloadType)) {
+  if (!decoder_database_->IsRed(rtp_header.header.payloadType)) {
     // Scale timestamp to internal domain (only for some codecs).
     timestamp_scaler_->ToInternal(&packet_list);
   }
 
   // Store these for later use, since the first packet may very well disappear
   // before we need these values.
   uint32_t main_timestamp = packet_list.front().timestamp;
   uint8_t main_payload_type = packet_list.front().payload_type;
   uint16_t main_sequence_number = packet_list.front().sequence_number;
 
   // Reinitialize NetEq if it's needed (changed SSRC or first call).
   if (update_sample_rate_and_channels) {
     // Note: |first_packet_| will be cleared further down in this method, once
     // the packet has been successfully inserted into the packet buffer.
 
-    rtcp_.Init(rtp_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_ = rtp_header.ssrc;
+    ssrc_ = rtp_header.header.ssrc;
 
     // Update audio buffer timestamp.
     sync_buffer_->IncreaseEndTimestamp(main_timestamp - timestamp_);
 
     // Update codecs.
     timestamp_ = main_timestamp;
   }
 
   // Update RTCP statistics, only for regular packets.
-  rtcp_.Update(rtp_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.sequenceNumber,
-                                    rtp_header.timestamp);
+    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(rtp_header.payloadType)) {
+  if (decoder_database_->IsRed(rtp_header.header.payloadType)) {
     if (!red_payload_splitter_->SplitRed(&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_);
   }
 
   // Check payload types.
   if (decoder_database_->CheckPayloadTypes(packet_list) ==
       DecoderDatabase::kDecoderNotFound) {
     return kUnknownRtpPayloadType;
   }
 
   RTC_DCHECK(!packet_list.empty());
 
   // Update main_timestamp, if new packets appear in the list
   // after RED splitting.
-  if (decoder_database_->IsRed(rtp_header.payloadType)) {
+  if (decoder_database_->IsRed(rtp_header.header.payloadType)) {
     timestamp_scaler_->ToInternal(&packet_list);
     main_timestamp = packet_list.front().timestamp;
     main_payload_type = packet_list.front().payload_type;
     main_sequence_number = packet_list.front().sequence_number;
   }
 
   // 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()) {
@@ skipping 1460 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