Use RtpPacketToSend in RtpSenderVideo

webrtc/modules/rtp_rtcp/source/rtp_sender.h

 /*
  *  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 96 matching lines @@
                         int8_t payload_type,
                         uint32_t timestamp,
                         int64_t capture_time_ms,
                         const uint8_t* payload_data,
                         size_t payload_size,
                         const RTPFragmentationHeader* fragmentation,
                         const RTPVideoHeader* rtp_header,
                         uint32_t* transport_frame_id_out);
 
   // RTP header extension
-  int32_t SetTransmissionTimeOffset(int32_t transmission_time_offset);
-  int32_t SetAbsoluteSendTime(uint32_t absolute_send_time);
-  void SetVideoRotation(VideoRotation rotation);
-  int32_t SetTransportSequenceNumber(uint16_t sequence_number);
-
   int32_t RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id);
   bool IsRtpHeaderExtensionRegistered(RTPExtensionType type);
   int32_t DeregisterRtpHeaderExtension(RTPExtensionType type);
 
   size_t RtpHeaderExtensionLength() const;
 
-  uint16_t BuildRtpHeaderExtension(uint8_t* data_buffer, bool marker_bit) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-
-  uint8_t BuildTransmissionTimeOffsetExtension(uint8_t* data_buffer) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-  uint8_t BuildAudioLevelExtension(uint8_t* data_buffer) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-  uint8_t BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-  uint8_t BuildVideoRotationExtension(uint8_t* data_buffer) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-  uint8_t BuildTransportSequenceNumberExtension(uint8_t* data_buffer,
-                                                uint16_t sequence_number) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-  uint8_t BuildPlayoutDelayExtension(uint8_t* data_buffer,
-                                     uint16_t min_playout_delay_ms,
-                                     uint16_t max_playout_delay_ms) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-
-  // Verifies that the specified extension is registered, and that it is
-  // present in rtp packet. If extension is not registered kNotRegistered is
-  // returned. If extension cannot be found in the rtp header, or if it is
-  // malformed, kError is returned. Otherwise *extension_offset is set to the
-  // offset of the extension from the beginning of the rtp packet and kOk is
-  // returned.
-  enum class ExtensionStatus {
-    kNotRegistered,
-    kOk,
-    kError,
-  };
-  ExtensionStatus VerifyExtension(RTPExtensionType extension_type,
-                                  uint8_t* rtp_packet,
-                                  size_t rtp_packet_length,
-                                  const RTPHeader& rtp_header,
-                                  size_t extension_length_bytes,
-                                  size_t* extension_offset) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-
-  bool UpdateAudioLevel(uint8_t* rtp_packet,
-                        size_t rtp_packet_length,
-                        const RTPHeader& rtp_header,
-                        bool is_voiced,
-                        uint8_t dBov) const;
-
-  bool UpdateVideoRotation(uint8_t* rtp_packet,
-                           size_t rtp_packet_length,
-                           const RTPHeader& rtp_header,
-                           VideoRotation rotation) const;
-
   bool TimeToSendPacket(uint16_t sequence_number,
                         int64_t capture_time_ms,
                         bool retransmission,
                         int probe_cluster_id);
   size_t TimeToSendPadding(size_t bytes, int probe_cluster_id);
 
   // NACK.
   int SelectiveRetransmissions() const;
   int SetSelectiveRetransmissions(uint8_t settings);
   void OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers,
@@ skipping 10 matching lines @@
 
   // RTX.
   void SetRtxStatus(int mode);
   int RtxStatus() const;
 
   uint32_t RtxSsrc() const;
   void SetRtxSsrc(uint32_t ssrc);
 
   void SetRtxPayloadType(int payload_type, int associated_payload_type);
 
-  // Functions wrapping RTPSenderInterface.
-  int32_t BuildRTPheader(uint8_t* data_buffer,
-                         int8_t payload_type,
-                         bool marker_bit,
-                         uint32_t capture_timestamp,
-                         int64_t capture_time_ms,
-                         bool timestamp_provided = true,
-                         bool inc_sequence_number = true);
-  int32_t BuildRtpHeader(uint8_t* data_buffer,
-                         int8_t payload_type,
-                         bool marker_bit,
-                         uint32_t capture_timestamp,
-                         int64_t capture_time_ms);
+  // Create empty packet, fills ssrc. Unless |minimalistic| flag is set
+  // also set csrcs and reserve place for registered header extensions
+  // RtpSender updates before sending.
+  std::unique_ptr<RtpPacketToSend> AllocatePacket(bool minimalistic) const;
+  // Allocates sequence_number, update packet->Timstamp() with start_timestamp_
+  // offset, updates RtpSender last_send fields with values from |packet|.
+  // Return false of RtpSender not ready to send any more (i.e. destructing).
+  bool PrepareToSend(RtpPacketToSend* packet);
+
+  uint32_t TimestampOffset(uint32_t capture_rtp_timestamp) const;
 
   size_t RtpHeaderLength() const;
   uint16_t AllocateSequenceNumber(uint16_t packets_to_send);
   size_t MaxPayloadLength() const;
 
   // Current timestamp.
   uint32_t Timestamp() const;
   uint32_t SSRC() const;
 
-  // Deprecated. Create RtpPacketToSend instead and use next function.
-  bool SendToNetwork(uint8_t* data_buffer,
-                     size_t payload_length,
-                     size_t rtp_header_length,
-                     int64_t capture_time_ms,
-                     StorageType storage,
-                     RtpPacketSender::Priority priority);
   bool SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
                      StorageType storage,
                      RtpPacketSender::Priority priority);
 
   // Audio.
 
   // Send a DTMF tone using RFC 2833 (4733).
   int32_t SendTelephoneEvent(uint8_t key, uint16_t time_ms, uint8_t level);
 
   // Set audio packet size, used to determine when it's time to send a DTMF
@@ skipping 39 matching lines @@
   // Called on update of RTP statistics.
   void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback);
   StreamDataCountersCallback* GetRtpStatisticsCallback() const;
 
   uint32_t BitrateSent() const;
 
   void SetRtpState(const RtpState& rtp_state);
   RtpState GetRtpState() const;
   void SetRtxRtpState(const RtpState& rtp_state);
   RtpState GetRtxRtpState() const;
-  bool ActivateCVORtpHeaderExtension();
 
  protected:
   int32_t CheckPayloadType(int8_t payload_type, RtpVideoCodecTypes* video_type);
 
  private:
   // Maps capture time in milliseconds to send-side delay in milliseconds.
   // Send-side delay is the difference between transmission time and capture
   // time.
   typedef std::map<int64_t, int> SendDelayMap;
 
@@ skipping 21 matching lines @@
   bool SendPacketToNetwork(const RtpPacketToSend& packet,
                            const PacketOptions& options);
 
   void UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms);
   void UpdateOnSendPacket(int packet_id,
                           int64_t capture_time_ms,
                           uint32_t ssrc);
 
   // Find the byte position of the RTP extension as indicated by |type| in
   // |rtp_packet|. Return false if such extension doesn't exist.
-  bool FindHeaderExtensionPosition(RTPExtensionType type,
-                                   const uint8_t* rtp_packet,
-                                   size_t rtp_packet_length,
-                                   const RTPHeader& rtp_header,
-                                   size_t* position) const
-      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
-
   bool UpdateTransportSequenceNumber(RtpPacketToSend* packet,
                                      int* packet_id) const;
 
   void UpdatePlayoutDelayLimits(uint8_t* rtp_packet,
                                 size_t rtp_packet_length,
                                 const RTPHeader& rtp_header,
                                 uint16_t min_playout_delay,
                                 uint16_t max_playout_delay) const;
 
   void UpdateRtpStats(const RtpPacketToSend& packet,
@@ skipping 17 matching lines @@
 
   Transport *transport_;
   bool sending_media_ GUARDED_BY(send_critsect_);
 
   size_t max_payload_length_;
 
   int8_t payload_type_ GUARDED_BY(send_critsect_);
   std::map<int8_t, RtpUtility::Payload*> payload_type_map_;
 
   RtpHeaderExtensionMap rtp_header_extension_map_ GUARDED_BY(send_critsect_);
-  int32_t transmission_time_offset_;
-  uint32_t absolute_send_time_;
-  VideoRotation rotation_;
-  bool video_rotation_active_;
-  uint16_t transport_sequence_number_;
 
   // Tracks the current request for playout delay limits from application
   // and decides whether the current RTP frame should include the playout
   // delay extension on header.
   PlayoutDelayOracle playout_delay_oracle_;
   bool playout_delay_active_ GUARDED_BY(send_critsect_);
 
   RtpPacketHistory packet_history_;
 
   // Statistics
@@ skipping 33 matching lines @@
   std::map<int8_t, int8_t> rtx_payload_type_map_ GUARDED_BY(send_critsect_);
 
   RateLimiter* const retransmission_rate_limiter_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_