Remove ViEChannel calls for VideoReceiveStream.

webrtc/video/vie_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 198 matching lines @@
     } else {
       return false;
     }
   } else {
     receiving_tsn_enabled_ = false;
     return rtp_header_parser_->DeregisterRtpHeaderExtension(
         kRtpExtensionTransportSequenceNumber);
   }
 }
 
-int ViEReceiver::ReceivedRTPPacket(const void* rtp_packet,
-                                   size_t rtp_packet_length,
-                                   const PacketTime& packet_time) {
-  return InsertRTPPacket(static_cast<const uint8_t*>(rtp_packet),
-                         rtp_packet_length, packet_time);
-}
-
-int ViEReceiver::ReceivedRTCPPacket(const void* rtcp_packet,
-                                    size_t rtcp_packet_length) {
-  return InsertRTCPPacket(static_cast<const uint8_t*>(rtcp_packet),
-                          rtcp_packet_length);
-}
-
 int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data,
                                            const size_t payload_size,
                                            const WebRtcRTPHeader* rtp_header) {
   RTC_DCHECK(vcm_);
   WebRtcRTPHeader rtp_header_with_ntp = *rtp_header;
   rtp_header_with_ntp.ntp_time_ms =
       ntp_estimator_->Estimate(rtp_header->header.timestamp);
   if (vcm_->IncomingPacket(payload_data,
                            payload_size,
                            rtp_header_with_ntp) != 0) {
     // Check this...
     return -1;
   }
   return 0;
 }
 
 bool ViEReceiver::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 false;
   }
   header.payload_type_frequency = kVideoPayloadTypeFrequency;
   bool in_order = IsPacketInOrder(header);
   return ReceivePacket(rtp_packet, rtp_packet_length, header, in_order);
 }
 
-int ViEReceiver::InsertRTPPacket(const uint8_t* rtp_packet,
-                                 size_t rtp_packet_length,
-                                 const PacketTime& packet_time) {
+bool ViEReceiver::DeliverRtp(const uint8_t* rtp_packet,
+                             size_t rtp_packet_length,
+                             const PacketTime& packet_time) {
   {
     rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
-      return -1;
+      return false;
     }
   }
 
   RTPHeader header;
   if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length,
                                  &header)) {
-    return -1;
+    return false;
   }
   size_t payload_length = rtp_packet_length - header.headerLength;
   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;
 
   {
@@ skipping 13 matching lines @@
       last_packet_log_ms_ = now_ms;
     }
   }
 
   remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_length,
                                             header, true);
   header.payload_type_frequency = kVideoPayloadTypeFrequency;
 
   bool in_order = IsPacketInOrder(header);
   rtp_payload_registry_->SetIncomingPayloadType(header);
-  int ret = ReceivePacket(rtp_packet, rtp_packet_length, header, in_order)
-      ? 0
-      : -1;
+  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;
 }
 
 bool ViEReceiver::ReceivePacket(const uint8_t* packet,
                                 size_t packet_length,
@@ skipping 81 matching lines @@
   }
   rtp_header.type.Video.codec = payload_specific.Video.videoCodecType;
   rtp_header.type.Video.rotation = kVideoRotation_0;
   if (header.extension.hasVideoRotation) {
     rtp_header.type.Video.rotation =
         ConvertCVOByteToVideoRotation(header.extension.videoRotation);
   }
   OnReceivedPayloadData(NULL, 0, &rtp_header);
 }
 
-int ViEReceiver::InsertRTCPPacket(const uint8_t* rtcp_packet,
-                                  size_t rtcp_packet_length) {
+bool ViEReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
+                              size_t rtcp_packet_length) {
   {
     rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
-      return -1;
+      return false;
     }
 
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_simulcast_)
       rtp_rtcp->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length);
   }
   assert(rtp_rtcp_);  // Should be set by owner at construction time.
   int ret = rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length);
   if (ret != 0) {
-    return ret;
+    return false;
   }
 
   int64_t rtt = 0;
   rtp_rtcp_->RTT(rtp_receiver_->SSRC(), &rtt, NULL, NULL, NULL);
   if (rtt == 0) {
     // Waiting for valid rtt.
-    return 0;
+    return true;
   }
   uint32_t ntp_secs = 0;
   uint32_t ntp_frac = 0;
   uint32_t rtp_timestamp = 0;
   if (0 != rtp_rtcp_->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL,
                                 &rtp_timestamp)) {
     // Waiting for RTCP.
-    return 0;
+    return true;
   }
   ntp_estimator_->UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
 
-  return 0;
+  return true;
 }
 
 void ViEReceiver::StartReceive() {
   rtc::CritScope lock(&receive_cs_);
   receiving_ = true;
 }
 
 void ViEReceiver::StopReceive() {
   rtc::CritScope lock(&receive_cs_);
   receiving_ = false;
@@ skipping 20 matching lines @@
       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(), NULL, NULL, &min_rtt, NULL);
   return !in_order &&
       statistician->IsRetransmitOfOldPacket(header, min_rtt);
 }
 }  // namespace webrtc