Initial implementation of RtpTransportControllerReceive and related interfaces.

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 @@
     ProcessThread* process_thread,
     NackSender* nack_sender,
     KeyFrameRequestSender* keyframe_request_sender,
     video_coding::OnCompleteFrameCallback* complete_frame_callback,
     VCMTiming* timing)
     : clock_(Clock::GetRealTimeClock()),
       config_(*config),
       packet_router_(packet_router),
       process_thread_(process_thread),
       ntp_estimator_(clock_),
-      rtp_header_parser_(RtpHeaderParser::Create()),
+      rtp_header_extensions_(config_.rtp.extensions),
       rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_,
                                                      this,
                                                      this,
                                                      &rtp_payload_registry_)),
       rtp_receive_statistics_(ReceiveStatistics::Create(clock_)),
       ulpfec_receiver_(UlpfecReceiver::Create(this)),
       receiving_(false),
       restored_packet_in_use_(false),
       last_packet_log_ms_(-1),
       rtp_rtcp_(CreateRtpRtcpModule(rtp_receive_statistics_.get(),
@@ skipping 13 matching lines @@
          "reserved for internal usage.";
   RTC_DCHECK(config_.rtp.remote_ssrc != 0);
   // TODO(pbos): What's an appropriate local_ssrc for receive-only streams?
   RTC_DCHECK(config_.rtp.local_ssrc != 0);
   RTC_DCHECK(config_.rtp.remote_ssrc != config_.rtp.local_ssrc);
 
   rtp_rtcp_->SetRTCPStatus(config_.rtp.rtcp_mode);
   rtp_rtcp_->SetSSRC(config_.rtp.local_ssrc);
   rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
 
-  for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
-    EnableReceiveRtpHeaderExtension(config_.rtp.extensions[i].uri,
-                                    config_.rtp.extensions[i].id);
-  }
-
   static const int kMaxPacketAgeToNack = 450;
   const int max_reordering_threshold = (config_.rtp.nack.rtp_history_ms > 0)
                                            ? kMaxPacketAgeToNack
                                            : kDefaultMaxReorderingThreshold;
   rtp_receive_statistics_->SetMaxReorderingThreshold(max_reordering_threshold);
 
   if (config_.rtp.rtx_ssrc) {
     rtp_payload_registry_.SetRtxSsrc(config_.rtp.rtx_ssrc);
 
     for (const auto& kv : config_.rtp.rtx_payload_types) {
@@ skipping 124 matching lines @@
     memcpy(data, packet.dataPtr, packet.sizeBytes);
     packet.dataPtr = data;
   }
 
   packet_buffer_->InsertPacket(&packet);
   return 0;
 }
 
 bool RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
                                           size_t rtp_packet_length) {
+  RtpPacketReceived packet;
+  if (!packet.Parse(rtp_packet, rtp_packet_length))
+    return false;
+  packet.IdentifyExtensions(rtp_header_extensions_);
+  packet.set_payload_type_frequency(kVideoPayloadTypeFrequency);
+
   RTPHeader header;
-  if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) {
-    return false;
-  }
-  header.payload_type_frequency = kVideoPayloadTypeFrequency;
+  packet.GetHeader(&header);
   bool in_order = IsPacketInOrder(header);
   return ReceivePacket(rtp_packet, rtp_packet_length, header, in_order);
 }
 
 // TODO(pbos): Remove as soon as audio can handle a changing payload type
 // without this callback.
 int32_t RtpStreamReceiver::OnInitializeDecoder(
     const int8_t payload_type,
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
     const int frequency,
     const size_t channels,
     const uint32_t rate) {
   RTC_NOTREACHED();
   return 0;
 }
 
 void RtpStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) {
   rtp_rtcp_->SetRemoteSSRC(ssrc);
 }
 
-void RtpStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
+bool RtpStreamReceiver::OnRtpPacketReceive(RtpPacketReceived* packet) {
   {
     rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
-      return;
+      return false;
     }
   }
 
   int64_t now_ms = clock_->TimeInMilliseconds();
+  packet->IdentifyExtensions(rtp_header_extensions_);
+  packet->set_payload_type_frequency(kVideoPayloadTypeFrequency);
 
   {
     // 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: " << packet.Ssrc()
-         << " with payload type: " << static_cast<int>(packet.PayloadType())
-         << ", timestamp: " << packet.Timestamp()
-         << ", sequence number: " << packet.SequenceNumber()
-         << ", arrival time: " << packet.arrival_time_ms();
+      ss << "Packet received on SSRC: " << packet->Ssrc()
+         << " with payload type: " << static_cast<int>(packet->PayloadType())
+         << ", timestamp: " << packet->Timestamp()
+         << ", sequence number: " << packet->SequenceNumber()
+         << ", arrival time: " << packet->arrival_time_ms();
       int32_t time_offset;
-      if (packet.GetExtension<TransmissionOffset>(&time_offset)) {
+      if (packet->GetExtension<TransmissionOffset>(&time_offset)) {
         ss << ", toffset: " << time_offset;
       }
       uint32_t send_time;
-      if (packet.GetExtension<AbsoluteSendTime>(&send_time)) {
+      if (packet->GetExtension<AbsoluteSendTime>(&send_time)) {
         ss << ", abs send time: " << send_time;
       }
       LOG(LS_INFO) << ss.str();
       last_packet_log_ms_ = now_ms;
     }
   }
 
   // TODO(nisse): Delete use of GetHeader, but needs refactoring of
   // ReceivePacket and IncomingPacket methods below.
   RTPHeader header;
-  packet.GetHeader(&header);
-
-  header.payload_type_frequency = kVideoPayloadTypeFrequency;
+  packet->GetHeader(&header);
 
   bool in_order = IsPacketInOrder(header);
   rtp_payload_registry_.SetIncomingPayloadType(header);
-  ReceivePacket(packet.data(), packet.size(), header, in_order);
+  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));
+      header, packet->size(), IsPacketRetransmitted(header, in_order));
+
+  return true;
 }
 
 int32_t RtpStreamReceiver::RequestKeyFrame() {
   return rtp_rtcp_->RequestKeyFrame();
 }
 
 bool RtpStreamReceiver::IsUlpfecEnabled() const {
   return config_.rtp.ulpfec.ulpfec_payload_type != -1;
 }
 
@@ skipping 253 matching lines @@
         "WebRTC.Video.ReceivedFecPacketsInPercent",
         static_cast<int>(counter.num_fec_packets * 100 / counter.num_packets));
   }
   if (counter.num_fec_packets > 0) {
     RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.RecoveredMediaPacketsInPercentOfFec",
                              static_cast<int>(counter.num_recovered_packets *
                                               100 / counter.num_fec_packets));
   }
 }
 
-void RtpStreamReceiver::EnableReceiveRtpHeaderExtension(
-    const std::string& extension, int id) {
-  // One-byte-extension local identifiers are in the range 1-14 inclusive.
-  RTC_DCHECK_GE(id, 1);
-  RTC_DCHECK_LE(id, 14);
-  RTC_DCHECK(RtpExtension::IsSupportedForVideo(extension));
-  RTC_CHECK(rtp_header_parser_->RegisterRtpHeaderExtension(
-      StringToRtpExtensionType(extension), id));
-}
-
 void RtpStreamReceiver::InsertSpsPpsIntoTracker(uint8_t payload_type) {
   auto codec_params_it = pt_codec_params_.find(payload_type);
   if (codec_params_it == pt_codec_params_.end())
     return;
 
   LOG(LS_INFO) << "Found out of band supplied codec parameters for"
                << " payload type: " << static_cast<int>(payload_type);
 
   H264SpropParameterSets sprop_decoder;
   auto sprop_base64_it =
       codec_params_it->second.find(cricket::kH264FmtpSpropParameterSets);
 
   if (sprop_base64_it == codec_params_it->second.end())
     return;
 
   if (!sprop_decoder.DecodeSprop(sprop_base64_it->second.c_str()))
     return;
 
   tracker_.InsertSpsPpsNalus(sprop_decoder.sps_nalu(),
                              sprop_decoder.pps_nalu());
 }
 
 }  // namespace webrtc