Removed RTPHeader from NetEq's Packet struct.

webrtc/modules/audio_coding/neteq/red_payload_splitter.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 51 matching lines @@
     size_t sum_length = 0;
     while (!last_block) {
       RedHeader new_header;
       // Check the F bit. If F == 0, this was the last block.
       last_block = ((*payload_ptr & 0x80) == 0);
       // Bits 1 through 7 are payload type.
       new_header.payload_type = payload_ptr[0] & 0x7F;
       if (last_block) {
         // No more header data to read.
         ++sum_length;  // Account for RED header size of 1 byte.
-        new_header.timestamp = red_packet->header.timestamp;
+        new_header.timestamp = red_packet->timestamp;
         new_header.payload_length = red_packet->payload.size() - sum_length;
         payload_ptr += 1;  // Advance to first payload byte.
       } else {
         // Bits 8 through 21 are timestamp offset.
         int timestamp_offset =
             (payload_ptr[1] << 6) + ((payload_ptr[2] & 0xFC) >> 2);
-        new_header.timestamp = red_packet->header.timestamp - timestamp_offset;
+        new_header.timestamp = red_packet->timestamp - timestamp_offset;
         // Bits 22 through 31 are payload length.
         new_header.payload_length =
             ((payload_ptr[2] & 0x03) << 8) + payload_ptr[3];
         payload_ptr += 4;  // Advance to next RED header.
       }
       sum_length += new_header.payload_length;
       sum_length += 4;  // Account for RED header size of 4 bytes.
       // Store in new list of packets.
       new_headers.push_back(new_header);
     }
 
     if (new_headers.size() <= kMaxRedBlocks) {
       // Populate the new packets with payload data.
       // |payload_ptr| now points at the first payload byte.
       PacketList new_packets;  // An empty list to store the split packets in.
       for (size_t i = 0; i != new_headers.size(); ++i) {
         const auto& new_header = new_headers[i];
         size_t payload_length = new_header.payload_length;
         if (payload_ptr + payload_length >
             red_packet->payload.data() + red_packet->payload.size()) {
           // The block lengths in the RED headers do not match the overall
           // packet length. Something is corrupt. Discard this and the remaining
           // payloads from this packet.
           LOG(LS_WARNING) << "SplitRed length mismatch";
           ret = false;
           break;
         }
 
         Packet* new_packet = new Packet;
-        new_packet->header = red_packet->header;
-        new_packet->header.timestamp = new_header.timestamp;
-        new_packet->header.payloadType = new_header.payload_type;
+        new_packet->timestamp = new_header.timestamp;
+        new_packet->payload_type = new_header.payload_type;
+        new_packet->sequence_number = red_packet->sequence_number;
         new_packet->priority.red_level =
             rtc::checked_cast<int>((new_headers.size() - 1) - i);
         new_packet->payload.SetData(payload_ptr, payload_length);
         new_packets.push_front(new_packet);
         payload_ptr += payload_length;
       }
       // Insert new packets into original list, before the element pointed to by
       // iterator |it|.
       packet_list->splice(it, new_packets, new_packets.begin(),
                           new_packets.end());
@@ skipping 11 matching lines @@
   return ret;
 }
 
 int RedPayloadSplitter::CheckRedPayloads(
     PacketList* packet_list,
     const DecoderDatabase& decoder_database) {
   PacketList::iterator it = packet_list->begin();
   int main_payload_type = -1;
   int num_deleted_packets = 0;
   while (it != packet_list->end()) {
-    uint8_t this_payload_type = (*it)->header.payloadType;
+    uint8_t this_payload_type = (*it)->payload_type;
     if (!decoder_database.IsDtmf(this_payload_type) &&
         !decoder_database.IsComfortNoise(this_payload_type)) {
       if (main_payload_type == -1) {
         // This is the first packet in the list which is non-DTMF non-CNG.
         main_payload_type = this_payload_type;
       } else {
         if (this_payload_type != main_payload_type) {
           // We do not allow redundant payloads of a different type.
           // Discard this payload.
           delete (*it);
           // Remove |it| from the packet list. This operation effectively
           // moves the iterator |it| to the next packet in the list. Thus, we
           // do not have to increment it manually.
           it = packet_list->erase(it);
           ++num_deleted_packets;
           continue;
         }
       }
     }
     ++it;
   }
   return num_deleted_packets;
 }
 
 }  // namespace webrtc