RtpPacketReceiver base class and OnRtpPacket, with a pre-parsed RTP packet.

webrtc/video/rtp_stream_receiver.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 76 matching lines @@
     VieRemb* remb,
     const VideoReceiveStream::Config* config,
     ReceiveStatisticsProxy* receive_stats_proxy,
     ProcessThread* process_thread,
     NackSender* nack_sender,
     KeyFrameRequestSender* keyframe_request_sender,
     video_coding::OnCompleteFrameCallback* complete_frame_callback,
     VCMTiming* timing)
     : clock_(Clock::GetRealTimeClock()),
       config_(*config),
+      rtp_config_(config->rtp.extensions, config->rtp.transport_cc),
       video_receiver_(video_receiver),
       packet_router_(packet_router),
       remb_(remb),
       process_thread_(process_thread),
       ntp_estimator_(clock_),
       rtp_header_parser_(RtpHeaderParser::Create()),
       rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_,
                                                      this,
                                                      this,
                                                      &rtp_payload_registry_)),
@@ skipping 128 matching lines @@
 }
 
 int RtpStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
   return rtp_receiver_->CSRCs(csrcs);
 }
 
 RtpReceiver* RtpStreamReceiver::GetRtpReceiver() const {
   return rtp_receiver_.get();
 }
 
+bool RtpStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
+  {
+    rtc::CritScope lock(&receive_cs_);
+    if (!receiving_) {
+      return false;
+    }
+  }
+
+  RTPHeader header;
+  packet.GetHeader(&header);
+
+  int64_t now_ms = clock_->TimeInMilliseconds();
+
+  {
+    // Periodically log the RTP header of incoming packets.
+    rtc::CritScope lock(&receive_cs_);
+    if (now_ms - last_packet_log_ms_ > kPacketLogIntervalMs) {
+      std::stringstream ss;
+      ss << "Packet received on SSRC: " << header.ssrc << " with payload type: "
+         << static_cast<int>(header.payloadType) << ", timestamp: "
+         << header.timestamp << ", sequence number: " << header.sequenceNumber
+         << ", arrival time: " << packet.arrival_time_ms();
+      if (header.extension.hasTransmissionTimeOffset)
+        ss << ", toffset: " << header.extension.transmissionTimeOffset;
+      if (header.extension.hasAbsoluteSendTime)
+        ss << ", abs send time: " << header.extension.absoluteSendTime;
+      LOG(LS_INFO) << ss.str();
+      last_packet_log_ms_ = now_ms;
+    }
+  }
+
+  header.payload_type_frequency = kVideoPayloadTypeFrequency;
+
+  bool in_order = IsPacketInOrder(header);
+  rtp_payload_registry_.SetIncomingPayloadType(header);
+  // TODO(nisse): Is .data() and .size() right? Strip headers or not?

[stefan-webrtc, 2017/02/09 13:40:06]

Yes, this looks correct, as the full packet is needed for FEC recovery etc in
ParseAndHandleEncapsulatingHeader. If not for that we could strip the header
here already.

+  bool ret = ReceivePacket(packet.data(), packet.size(), header, in_order);
+  // Update receive statistics after ReceivePacket.
+  // Receive statistics will be reset if the payload type changes (make sure
+  // that the first packet is included in the stats).
+  rtp_receive_statistics_->IncomingPacket(
+      header, packet.size(), IsPacketRetransmitted(header, in_order));
+  return ret;
+}
+
+const RtpPacketReceiver::RtpConfig& RtpStreamReceiver::rtp_config() const {
+  return rtp_config_;
+}
+
+
 int32_t RtpStreamReceiver::OnReceivedPayloadData(
     const uint8_t* payload_data,
     size_t payload_size,
     const WebRtcRTPHeader* rtp_header) {
   WebRtcRTPHeader rtp_header_with_ntp = *rtp_header;
   rtp_header_with_ntp.ntp_time_ms =
       ntp_estimator_.Estimate(rtp_header->header.timestamp);
   if (jitter_buffer_experiment_) {
     VCMPacket packet(payload_data, payload_size, rtp_header_with_ntp);
     packet.timesNacked = nack_module_->OnReceivedPacket(packet);
@@ skipping 54 matching lines @@
     const size_t channels,
     const uint32_t rate) {
   RTC_NOTREACHED();
   return 0;
 }
 
 void RtpStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) {
   rtp_rtcp_->SetRemoteSSRC(ssrc);
 }
 
-bool RtpStreamReceiver::DeliverRtp(const uint8_t* rtp_packet,
-                                   size_t rtp_packet_length,
-                                   const PacketTime& packet_time) {
-  {
-    rtc::CritScope lock(&receive_cs_);
-    if (!receiving_) {
-      return false;
-    }
-  }
-
-  RTPHeader header;
-  if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length,
-                                 &header)) {
-    return false;
-  }
-  int64_t arrival_time_ms;
-  int64_t now_ms = clock_->TimeInMilliseconds();
-  if (packet_time.timestamp != -1)
-    arrival_time_ms = (packet_time.timestamp + 500) / 1000;
-  else
-    arrival_time_ms = now_ms;
-
-  {
-    // Periodically log the RTP header of incoming packets.
-    rtc::CritScope lock(&receive_cs_);
-    if (now_ms - last_packet_log_ms_ > kPacketLogIntervalMs) {
-      std::stringstream ss;
-      ss << "Packet received on SSRC: " << header.ssrc << " with payload type: "
-         << static_cast<int>(header.payloadType) << ", timestamp: "
-         << header.timestamp << ", sequence number: " << header.sequenceNumber
-         << ", arrival time: " << arrival_time_ms;
-      if (header.extension.hasTransmissionTimeOffset)
-        ss << ", toffset: " << header.extension.transmissionTimeOffset;
-      if (header.extension.hasAbsoluteSendTime)
-        ss << ", abs send time: " << header.extension.absoluteSendTime;
-      LOG(LS_INFO) << ss.str();
-      last_packet_log_ms_ = now_ms;
-    }
-  }
-
-  header.payload_type_frequency = kVideoPayloadTypeFrequency;
-
-  bool in_order = IsPacketInOrder(header);
-  rtp_payload_registry_.SetIncomingPayloadType(header);
-  bool ret = ReceivePacket(rtp_packet, rtp_packet_length, header, in_order);
-  // Update receive statistics after ReceivePacket.
-  // Receive statistics will be reset if the payload type changes (make sure
-  // that the first packet is included in the stats).
-  rtp_receive_statistics_->IncomingPacket(
-      header, rtp_packet_length, IsPacketRetransmitted(header, in_order));
-  return ret;
-}
-
 int32_t RtpStreamReceiver::RequestKeyFrame() {
   return rtp_rtcp_->RequestKeyFrame();
 }
 
 int32_t RtpStreamReceiver::SliceLossIndicationRequest(
     const uint64_t picture_id) {
   return rtp_rtcp_->SendRTCPSliceLossIndication(
       static_cast<uint8_t>(picture_id));
 }
 
@@ skipping 286 matching lines @@
     return;
 
   if (!sprop_decoder.DecodeSprop(sprop_base64_it->second.c_str()))
     return;
 
   tracker_.InsertSpsPpsNalus(sprop_decoder.sps_nalu(),
                              sprop_decoder.pps_nalu());
 }
 
 }  // namespace webrtc