[Draft] RtpPacket sketched.

webrtc/modules/rtp_rtcp/source/rtp_sender_audio.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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h"
 
 #include <string.h>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 
 static const int kDtmfFrequencyHz = 8000;
 
 RTPSenderAudio::RTPSenderAudio(Clock* clock, RTPSender* rtpSender)
     : _clock(clock),
       _rtpSender(rtpSender),
       _packetSizeSamples(160),
@@ skipping 117 matching lines @@
   return markerBit;
 }
 
 int32_t RTPSenderAudio::SendAudio(FrameType frameType,
                                   int8_t payloadType,
                                   uint32_t captureTimeStamp,
                                   const uint8_t* payloadData,
                                   size_t dataSize,
                                   const RTPFragmentationHeader* fragmentation) {
   // TODO(pwestin) Breakup function in smaller functions.
-  size_t payloadSize = dataSize;
+  size_t payload_size = dataSize;
   size_t maxPayloadLength = _rtpSender->MaxPayloadLength();
   uint16_t dtmfLengthMS = 0;
   uint8_t key = 0;
   int red_payload_type;
   uint8_t audio_level_dbov;
   int8_t dtmf_payload_type;
   uint16_t packet_size_samples;
   {
     rtc::CritScope cs(&_sendAudioCritsect);
     red_payload_type = _REDPayloadType;
@@ skipping 65 matching lines @@
                                      static_cast<uint16_t>(dtmfDurationSamples),
                                      !_dtmfEventFirstPacketSent) != 0) {
           return -1;
         }
         _dtmfEventFirstPacketSent = true;
         return 0;
       }
     }
     return 0;
   }
-  if (payloadSize == 0 || payloadData == NULL) {
+  if (payload_size == 0 || payloadData == NULL) {
     if (frameType == kEmptyFrame) {
       // we don't send empty audio RTP packets
       // no error since we use it to drive DTMF when we use VAD
       return 0;
     }
     return -1;
   }
-  uint8_t dataBuffer[IP_PACKET_SIZE];
+  std::unique_ptr<RtpPacketToSend> packet = _rtpSender->CreatePacket();
   bool markerBit = MarkerBit(frameType, payloadType);
 
-  int32_t rtpHeaderLength = 0;
   uint16_t timestampOffset = 0;
 
   if (red_payload_type >= 0 && fragmentation && !markerBit &&
       fragmentation->fragmentationVectorSize > 1) {
     // have we configured RED? use its payload type
     // we need to get the current timestamp to calc the diff
     uint32_t oldTimeStamp = _rtpSender->Timestamp();
-    rtpHeaderLength = _rtpSender->BuildRTPheader(dataBuffer, red_payload_type,
-                                                 markerBit, captureTimeStamp,
-                                                 _clock->TimeInMilliseconds());
+    _rtpSender->BuildRtpHeader(packet.get(), captureTimeStamp, true);
+    timestampOffset = uint16_t(_rtpSender->Timestamp() - oldTimeStamp);
+    packet->SetPayloadType(red_payload_type);
+  } else {
+    _rtpSender->BuildRtpHeader(packet.get(), captureTimeStamp, true);
+    packet->SetPayloadType(payloadType);
+  }
+  packet->SetMarker(markerBit);
+  // Update audio level extension, if included.
+  packet->SetExtension<AudioLevel>(frameType == kAudioFrameSpeech,
+                                   audio_level_dbov);
 
-    timestampOffset = uint16_t(_rtpSender->Timestamp() - oldTimeStamp);
-  } else {
-    rtpHeaderLength = _rtpSender->BuildRTPheader(dataBuffer, payloadType,
-                                                 markerBit, captureTimeStamp,
-                                                 _clock->TimeInMilliseconds());
-  }
-  if (rtpHeaderLength <= 0) {
-    return -1;
-  }
-  if (maxPayloadLength < (rtpHeaderLength + payloadSize)) {
+  if (maxPayloadLength < (packet->headers_size() + payload_size)) {
     // Too large payload buffer.
     return -1;
   }
+  size_t red_header_size = 0;
   if (red_payload_type >= 0 &&  // Have we configured RED?
       fragmentation && fragmentation->fragmentationVectorSize > 1 &&
       !markerBit) {
     if (timestampOffset <= 0x3fff) {
       if (fragmentation->fragmentationVectorSize != 2) {
         // we only support 2 codecs when using RED
         return -1;
       }
+      red_header_size = 5;
+      payload_size = fragmentation->fragmentationLength[0] +
+                     fragmentation->fragmentationLength[1];
+
+      uint8_t* payload =
+          packet->AllocatePayload(red_header_size + payload_size);
       // only 0x80 if we have multiple blocks
-      dataBuffer[rtpHeaderLength++] =
-          0x80 + fragmentation->fragmentationPlType[1];
+      payload[0] = 0x80 + fragmentation->fragmentationPlType[1];
       size_t blockLength = fragmentation->fragmentationLength[1];
 
       // sanity blockLength
       if (blockLength > 0x3ff) {  // block length 10 bits 1023 bytes
         return -1;
       }
       uint32_t REDheader = (timestampOffset << 10) + blockLength;
-      ByteWriter<uint32_t>::WriteBigEndian(dataBuffer + rtpHeaderLength,
-                                           REDheader);
-      rtpHeaderLength += 3;
+      ByteWriter<uint32_t, 3>::WriteBigEndian(payload + 1, REDheader);
 
-      dataBuffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
+      payload[4] = fragmentation->fragmentationPlType[0];
       // copy the RED data
-      memcpy(dataBuffer + rtpHeaderLength,
+      memcpy(payload + red_header_size,
              payloadData + fragmentation->fragmentationOffset[1],
              fragmentation->fragmentationLength[1]);
 
       // copy the normal data
-      memcpy(
-          dataBuffer + rtpHeaderLength + fragmentation->fragmentationLength[1],
-          payloadData + fragmentation->fragmentationOffset[0],
-          fragmentation->fragmentationLength[0]);
-
-      payloadSize = fragmentation->fragmentationLength[0] +
-                    fragmentation->fragmentationLength[1];
-    } else {
-      // silence for too long send only new data
-      dataBuffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
-      memcpy(dataBuffer + rtpHeaderLength,
+      memcpy(payload + red_header_size + fragmentation->fragmentationLength[1],
              payloadData + fragmentation->fragmentationOffset[0],
              fragmentation->fragmentationLength[0]);
-
-      payloadSize = fragmentation->fragmentationLength[0];
+    } else {
+      red_header_size = 1;
+      payload_size = fragmentation->fragmentationLength[0];
+      uint8_t* payload =
+          packet->AllocatePayload(red_header_size + payload_size);
+      // silence for too long send only new data
+      payload[0] = fragmentation->fragmentationPlType[0];
+      memcpy(payload + red_header_size,
+             payloadData + fragmentation->fragmentationOffset[0],
+             fragmentation->fragmentationLength[0]);
     }
   } else {
     if (fragmentation && fragmentation->fragmentationVectorSize > 0) {
       // use the fragment info if we have one
-      dataBuffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
-      memcpy(dataBuffer + rtpHeaderLength,
+      red_header_size = 1;
+      payload_size = fragmentation->fragmentationLength[0];
+      uint8_t* payload =
+          packet->AllocatePayload(red_header_size + payload_size);
+      payload[0] = fragmentation->fragmentationPlType[0];
+      memcpy(payload + red_header_size,
              payloadData + fragmentation->fragmentationOffset[0],
              fragmentation->fragmentationLength[0]);
-
-      payloadSize = fragmentation->fragmentationLength[0];
     } else {
-      memcpy(dataBuffer + rtpHeaderLength, payloadData, payloadSize);
+      uint8_t* payload = packet->AllocatePayload(payload_size);
+      memcpy(payload, payloadData, payload_size);
     }
   }
 
   {
     rtc::CritScope cs(&_sendAudioCritsect);
     _lastPayloadType = payloadType;
   }
-  // Update audio level extension, if included.
-  size_t packetSize = payloadSize + rtpHeaderLength;
-  RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize);
-  RTPHeader rtp_header;
-  rtp_parser.Parse(&rtp_header);
-  _rtpSender->UpdateAudioLevel(dataBuffer, packetSize, rtp_header,
-                               (frameType == kAudioFrameSpeech),
-                               audio_level_dbov);
   TRACE_EVENT_ASYNC_END2("webrtc", "Audio", captureTimeStamp, "timestamp",
-                         _rtpSender->Timestamp(), "seqnum",
-                         _rtpSender->SequenceNumber());
-  int32_t send_result = _rtpSender->SendToNetwork(
-      dataBuffer, payloadSize, rtpHeaderLength,
-      TickTime::MillisecondTimestamp(), kAllowRetransmission,
-      RtpPacketSender::kHighPriority);
-  if (first_packet_sent_()) {
-    LOG(LS_INFO) << "First audio RTP packet sent to pacer";
-  }
-  return send_result;
+                         packet->Timestamp(), "seqnum",
+                         packet->SequenceNumber());
+  return _rtpSender->SendToNetwork(
+      std::move(packet), payload_size, TickTime::MillisecondTimestamp(),
+      kAllowRetransmission, RtpPacketSender::kHighPriority);
 }
 
 // Audio level magnitude and voice activity flag are set for each RTP packet
 int32_t RTPSenderAudio::SetAudioLevel(uint8_t level_dBov) {
   if (level_dBov > 127) {
     return -1;
   }
   rtc::CritScope cs(&_sendAudioCritsect);
   _audioLevel_dBov = level_dBov;
   return 0;
@@ skipping 32 matching lines @@
     }
   }
   return AddDTMF(key, time_ms, level);
 }
 
 int32_t RTPSenderAudio::SendTelephoneEventPacket(bool ended,
                                                  int8_t dtmf_payload_type,
                                                  uint32_t dtmfTimeStamp,
                                                  uint16_t duration,
                                                  bool markerBit) {
-  uint8_t dtmfbuffer[IP_PACKET_SIZE];
   uint8_t sendCount = 1;
   int32_t retVal = 0;
 
   if (ended) {
     // resend last packet in an event 3 times
     sendCount = 3;
   }
   do {
+    std::unique_ptr<RtpPacketToSend> packet = _rtpSender->CreatePacket();
     // Send DTMF data
-    _rtpSender->BuildRTPheader(dtmfbuffer, dtmf_payload_type, markerBit,
-                               dtmfTimeStamp, _clock->TimeInMilliseconds());
-
-    // reset CSRC and X bit
-    dtmfbuffer[0] &= 0xe0;
-
+    _rtpSender->BuildRtpHeader(packet.get(), dtmfTimeStamp, false);
+    packet->SetMarker(markerBit);
+    packet->SetPayloadType(dtmf_payload_type);
     // Create DTMF data
     /*    From RFC 2833:
 
      0                   1                   2                   3
      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |     event     |E|R| volume    |          duration             |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     */
     // R bit always cleared
     uint8_t R = 0x00;
     uint8_t volume = _dtmfLevel;
 
     // First packet un-ended
     uint8_t E = ended ? 0x80 : 0x00;
+    uint8_t* dtmfbuffer = packet->AllocatePayload(4);
 
     // First byte is Event number, equals key number
-    dtmfbuffer[12] = _dtmfKey;
-    dtmfbuffer[13] = E | R | volume;
-    ByteWriter<uint16_t>::WriteBigEndian(dtmfbuffer + 14, duration);
+    dtmfbuffer[0] = _dtmfKey;
+    dtmfbuffer[1] = E | R | volume;
+    ByteWriter<uint16_t>::WriteBigEndian(dtmfbuffer + 2, duration);
 
     TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                          "Audio::SendTelephoneEvent", "timestamp",
                          dtmfTimeStamp, "seqnum", _rtpSender->SequenceNumber());
     retVal = _rtpSender->SendToNetwork(
-        dtmfbuffer, 4, 12, TickTime::MillisecondTimestamp(),
+        std::move(packet), 4, TickTime::MillisecondTimestamp(),
         kAllowRetransmission, RtpPacketSender::kHighPriority);
     sendCount--;
   } while (sendCount > 0 && retVal == 0);
 
   return retVal;
 }
 }  // namespace webrtc