Rename class RtpStreamReceiver --> RtpVideoStreamReceiver.

webrtc/video/rtp_video_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.
  */
 
-#include "webrtc/video/rtp_stream_receiver.h"
+#include "webrtc/video/rtp_video_stream_receiver.h"
 
 #include <vector>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/location.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_types.h"
 #include "webrtc/config.h"
 #include "webrtc/media/base/mediaconstants.h"
@@ skipping 49 matching lines @@
   configuration.transport_feedback_callback = nullptr;
 
   std::unique_ptr<RtpRtcp> rtp_rtcp(RtpRtcp::CreateRtpRtcp(configuration));
   rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound);
 
   return rtp_rtcp;
 }
 
 static const int kPacketLogIntervalMs = 10000;
 
-RtpStreamReceiver::RtpStreamReceiver(
+RtpVideoStreamReceiver::RtpVideoStreamReceiver(
     Transport* transport,
     RtcpRttStats* rtt_stats,
     PacketRouter* packet_router,
     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)
@@ skipping 90 matching lines @@
     nack_module_.reset(
         new NackModule(clock_, nack_sender, keyframe_request_sender));
     process_thread_->RegisterModule(nack_module_.get(), RTC_FROM_HERE);
   }
 
   packet_buffer_ = video_coding::PacketBuffer::Create(
       clock_, kPacketBufferStartSize, kPacketBufferMaxSixe, this);
   reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this));
 }
 
-RtpStreamReceiver::~RtpStreamReceiver() {
+RtpVideoStreamReceiver::~RtpVideoStreamReceiver() {
   if (nack_module_) {
     process_thread_->DeRegisterModule(nack_module_.get());
   }
 
   process_thread_->DeRegisterModule(rtp_rtcp_.get());
 
   packet_router_->RemoveReceiveRtpModule(rtp_rtcp_.get());
   UpdateHistograms();
 }
 
-bool RtpStreamReceiver::AddReceiveCodec(
+bool RtpVideoStreamReceiver::AddReceiveCodec(
     const VideoCodec& video_codec,
     const std::map<std::string, std::string>& codec_params) {
   pt_codec_params_.insert(make_pair(video_codec.plType, codec_params));
   return AddReceiveCodec(video_codec);
 }
 
-bool RtpStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) {
+bool RtpVideoStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) {
   int8_t old_pltype = -1;
   if (rtp_payload_registry_.ReceivePayloadType(video_codec, &old_pltype) !=
       -1) {
     rtp_payload_registry_.DeRegisterReceivePayload(old_pltype);
   }
   return rtp_payload_registry_.RegisterReceivePayload(video_codec) == 0;
 }
 
-uint32_t RtpStreamReceiver::GetRemoteSsrc() const {
+uint32_t RtpVideoStreamReceiver::GetRemoteSsrc() const {
   return rtp_receiver_->SSRC();
 }
 
-int RtpStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
+int RtpVideoStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
   return rtp_receiver_->CSRCs(csrcs);
 }
 
-RtpReceiver* RtpStreamReceiver::GetRtpReceiver() const {
+RtpReceiver* RtpVideoStreamReceiver::GetRtpReceiver() const {
   return rtp_receiver_.get();
 }
 
-int32_t RtpStreamReceiver::OnReceivedPayloadData(
+int32_t RtpVideoStreamReceiver::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);
   VCMPacket packet(payload_data, payload_size, rtp_header_with_ntp);
   packet.timesNacked =
       nack_module_ ? nack_module_->OnReceivedPacket(packet) : -1;
 
@@ skipping 30 matching lines @@
     packet.dataPtr = data;
   }
 
   packet_buffer_->InsertPacket(&packet);
   return 0;
 }
 
 // TODO(nisse): Try to delete this method. Obstacles: It is used by
 // ParseAndHandleEncapsulatingHeader, for handling Rtx packets, and
 // for callbacks from |ulpfec_receiver_|.
-void RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
-                                          size_t rtp_packet_length) {
+void RtpVideoStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
+                                               size_t rtp_packet_length) {
   RTPHeader header;
   if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) {
     return;
   }
   header.payload_type_frequency = kVideoPayloadTypeFrequency;
   bool in_order = IsPacketInOrder(header);
   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(
+int32_t RtpVideoStreamReceiver::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) {
+void RtpVideoStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) {
   rtp_rtcp_->SetRemoteSSRC(ssrc);
 }
 
 // This method handles both regular RTP packets and packets recovered
 // via FlexFEC.
-void RtpStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
+void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
   {
     rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
       return;
     }
 
     if (!packet.recovered()) {
       int64_t now_ms = clock_->TimeInMilliseconds();
 
       // Periodically log the RTP header of incoming packets.
@@ skipping 35 matching lines @@
   // Receive statistics will be reset if the payload type changes (make sure
   // that the first packet is included in the stats).
   if (!packet.recovered()) {
     // TODO(nisse): We should pass a recovered flag to stats, to aid
     // fixing bug bugs.webrtc.org/6339.
     rtp_receive_statistics_->IncomingPacket(
         header, packet.size(), IsPacketRetransmitted(header, in_order));
   }
 }
 
-int32_t RtpStreamReceiver::RequestKeyFrame() {
+int32_t RtpVideoStreamReceiver::RequestKeyFrame() {
   return rtp_rtcp_->RequestKeyFrame();
 }
 
-bool RtpStreamReceiver::IsUlpfecEnabled() const {
+bool RtpVideoStreamReceiver::IsUlpfecEnabled() const {
   return config_.rtp.ulpfec.ulpfec_payload_type != -1;
 }
 
-bool RtpStreamReceiver::IsRedEnabled() const {
+bool RtpVideoStreamReceiver::IsRedEnabled() const {
   return config_.rtp.ulpfec.red_payload_type != -1;
 }
 
-bool RtpStreamReceiver::IsRetransmissionsEnabled() const {
+bool RtpVideoStreamReceiver::IsRetransmissionsEnabled() const {
   return config_.rtp.nack.rtp_history_ms > 0;
 }
 
-void RtpStreamReceiver::RequestPacketRetransmit(
+void RtpVideoStreamReceiver::RequestPacketRetransmit(
     const std::vector<uint16_t>& sequence_numbers) {
   rtp_rtcp_->SendNack(sequence_numbers);
 }
 
-int32_t RtpStreamReceiver::ResendPackets(const uint16_t* sequence_numbers,
-                                         uint16_t length) {
+int32_t RtpVideoStreamReceiver::ResendPackets(const uint16_t* sequence_numbers,
+                                              uint16_t length) {
   return rtp_rtcp_->SendNACK(sequence_numbers, length);
 }
 
-void RtpStreamReceiver::OnReceivedFrame(
+void RtpVideoStreamReceiver::OnReceivedFrame(
     std::unique_ptr<video_coding::RtpFrameObject> frame) {
-
   if (!has_received_frame_) {
     has_received_frame_ = true;
     if (frame->FrameType() != kVideoFrameKey)
       keyframe_request_sender_->RequestKeyFrame();
   }
 
   if (!frame->delayed_by_retransmission())
     timing_->IncomingTimestamp(frame->timestamp, clock_->TimeInMilliseconds());
   reference_finder_->ManageFrame(std::move(frame));
 }
 
-void RtpStreamReceiver::OnCompleteFrame(
+void RtpVideoStreamReceiver::OnCompleteFrame(
     std::unique_ptr<video_coding::FrameObject> frame) {
   {
     rtc::CritScope lock(&last_seq_num_cs_);
     video_coding::RtpFrameObject* rtp_frame =
         static_cast<video_coding::RtpFrameObject*>(frame.get());
     last_seq_num_for_pic_id_[rtp_frame->picture_id] = rtp_frame->last_seq_num();
   }
   complete_frame_callback_->OnCompleteFrame(std::move(frame));
 }
 
-void RtpStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
+void RtpVideoStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms,
+                                         int64_t max_rtt_ms) {
   if (nack_module_)
     nack_module_->UpdateRtt(max_rtt_ms);
 }
 
-rtc::Optional<int64_t> RtpStreamReceiver::LastReceivedPacketMs() const {
+rtc::Optional<int64_t> RtpVideoStreamReceiver::LastReceivedPacketMs() const {
   return packet_buffer_->LastReceivedPacketMs();
 }
 
-rtc::Optional<int64_t> RtpStreamReceiver::LastReceivedKeyframePacketMs() const {
+rtc::Optional<int64_t> RtpVideoStreamReceiver::LastReceivedKeyframePacketMs()
+    const {
   return packet_buffer_->LastReceivedKeyframePacketMs();
 }
 
-void RtpStreamReceiver::ReceivePacket(const uint8_t* packet,
-                                      size_t packet_length,
-                                      const RTPHeader& header,
-                                      bool in_order) {
+void RtpVideoStreamReceiver::ReceivePacket(const uint8_t* packet,
+                                           size_t packet_length,
+                                           const RTPHeader& header,
+                                           bool in_order) {
   if (rtp_payload_registry_.IsEncapsulated(header)) {
     ParseAndHandleEncapsulatingHeader(packet, packet_length, header);
     return;
   }
   const uint8_t* payload = packet + header.headerLength;
   assert(packet_length >= header.headerLength);
   size_t payload_length = packet_length - header.headerLength;
   PayloadUnion payload_specific;
   if (!rtp_payload_registry_.GetPayloadSpecifics(header.payloadType,
                                                  &payload_specific)) {
     return;
   }
   rtp_receiver_->IncomingRtpPacket(header, payload, payload_length,
                                    payload_specific, in_order);
 }
 
-void RtpStreamReceiver::ParseAndHandleEncapsulatingHeader(
+void RtpVideoStreamReceiver::ParseAndHandleEncapsulatingHeader(
     const uint8_t* packet, size_t packet_length, const RTPHeader& header) {
   if (rtp_payload_registry_.IsRed(header)) {
     int8_t ulpfec_pt = rtp_payload_registry_.ulpfec_payload_type();
     if (packet[header.headerLength] == ulpfec_pt) {
       rtp_receive_statistics_->FecPacketReceived(header, packet_length);
       // Notify video_receiver about received FEC packets to avoid NACKing these
       // packets.
       NotifyReceiverOfFecPacket(header);
     }
     if (ulpfec_receiver_->AddReceivedRedPacket(header, packet, packet_length,
@@ skipping 24 matching lines @@
                       << header.ssrc << " payload type: "
                       << static_cast<int>(header.payloadType);
       return;
     }
     restored_packet_in_use_ = true;
     OnRecoveredPacket(restored_packet_, packet_length);
     restored_packet_in_use_ = false;
   }
 }
 
-void RtpStreamReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) {
+void RtpVideoStreamReceiver::NotifyReceiverOfFecPacket(
+    const RTPHeader& header) {
   int8_t last_media_payload_type =
       rtp_payload_registry_.last_received_media_payload_type();
   if (last_media_payload_type < 0) {
     LOG(LS_WARNING) << "Failed to get last media payload type.";
     return;
   }
   // Fake an empty media packet.
   WebRtcRTPHeader rtp_header = {};
   rtp_header.header = header;
   rtp_header.header.payloadType = last_media_payload_type;
@@ skipping 11 matching lines @@
   }
   rtp_header.type.Video.content_type = VideoContentType::UNSPECIFIED;
   if (header.extension.hasVideoContentType) {
     rtp_header.type.Video.content_type = header.extension.videoContentType;
   }
   rtp_header.type.Video.playout_delay = header.extension.playout_delay;
 
   OnReceivedPayloadData(nullptr, 0, &rtp_header);
 }
 
-bool RtpStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
-                                    size_t rtcp_packet_length) {
+bool RtpVideoStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
+                                         size_t rtcp_packet_length) {
   {
     rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
       return false;
     }
   }
 
   rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length);
 
   int64_t rtt = 0;
   rtp_rtcp_->RTT(rtp_receiver_->SSRC(), &rtt, nullptr, nullptr, nullptr);
   if (rtt == 0) {
     // Waiting for valid rtt.
     return true;
   }
   uint32_t ntp_secs = 0;
   uint32_t ntp_frac = 0;
   uint32_t rtp_timestamp = 0;
   if (rtp_rtcp_->RemoteNTP(&ntp_secs, &ntp_frac, nullptr, nullptr,
                            &rtp_timestamp) != 0) {
     // Waiting for RTCP.
     return true;
   }
   ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
 
   return true;
 }
 
-void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) {
+void RtpVideoStreamReceiver::FrameContinuous(uint16_t picture_id) {
   if (!nack_module_)
     return;
 
   int seq_num = -1;
   {
     rtc::CritScope lock(&last_seq_num_cs_);
     auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
     if (seq_num_it != last_seq_num_for_pic_id_.end())
       seq_num = seq_num_it->second;
   }
   if (seq_num != -1)
     nack_module_->ClearUpTo(seq_num);
 }
 
-void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) {
+void RtpVideoStreamReceiver::FrameDecoded(uint16_t picture_id) {
   int seq_num = -1;
   {
     rtc::CritScope lock(&last_seq_num_cs_);
     auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
     if (seq_num_it != last_seq_num_for_pic_id_.end()) {
       seq_num = seq_num_it->second;
       last_seq_num_for_pic_id_.erase(last_seq_num_for_pic_id_.begin(),
                                      ++seq_num_it);
     }
   }
   if (seq_num != -1) {
     packet_buffer_->ClearTo(seq_num);
     reference_finder_->ClearTo(seq_num);
   }
 }
 
-void RtpStreamReceiver::SignalNetworkState(NetworkState state) {
+void RtpVideoStreamReceiver::SignalNetworkState(NetworkState state) {
   rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode
                                                : RtcpMode::kOff);
 }
 
-void RtpStreamReceiver::StartReceive() {
+void RtpVideoStreamReceiver::StartReceive() {
   rtc::CritScope lock(&receive_cs_);
   receiving_ = true;
 }
 
-void RtpStreamReceiver::StopReceive() {
+void RtpVideoStreamReceiver::StopReceive() {
   rtc::CritScope lock(&receive_cs_);
   receiving_ = false;
 }
 
-bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const {
+bool RtpVideoStreamReceiver::IsPacketInOrder(const RTPHeader& header) const {
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   return statistician->IsPacketInOrder(header.sequenceNumber);
 }
 
-bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header,
-                                              bool in_order) const {
+bool RtpVideoStreamReceiver::IsPacketRetransmitted(const RTPHeader& header,
+                                                   bool in_order) const {
   // Retransmissions are handled separately if RTX is enabled.
   if (rtp_payload_registry_.RtxEnabled())
     return false;
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   // Check if this is a retransmission.
   int64_t min_rtt = 0;
   rtp_rtcp_->RTT(rtp_receiver_->SSRC(), nullptr, nullptr, &min_rtt, nullptr);
   return !in_order &&
       statistician->IsRetransmitOfOldPacket(header, min_rtt);
 }
 
-void RtpStreamReceiver::UpdateHistograms() {
+void RtpVideoStreamReceiver::UpdateHistograms() {
   FecPacketCounter counter = ulpfec_receiver_->GetPacketCounter();
   if (counter.first_packet_time_ms == -1)
     return;
 
   int64_t elapsed_sec =
       (clock_->TimeInMilliseconds() - counter.first_packet_time_ms) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds)
     return;
 
   if (counter.num_packets > 0) {
     RTC_HISTOGRAM_PERCENTAGE(
         "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(
+void RtpVideoStreamReceiver::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) {
+void RtpVideoStreamReceiver::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