Cast: Move retransmission to the transport

media/cast/net/cast_transport_sender_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/net/cast_transport_sender_impl.h"
 
 #include "base/single_thread_task_runner.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/udp_transport.h"
@@ skipping 93 matching lines @@
     pacer_.RegisterAudioSsrc(config.ssrc);
     pacer_.RegisterPrioritySsrc(config.ssrc);
     status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
   } else {
     audio_sender_.reset();
     status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
   audio_rtcp_session_.reset(
-      new Rtcp(cast_message_cb,
-               rtt_cb,
+      new Rtcp(base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,
+                          weak_factory_.GetWeakPtr(), config.ssrc,
+                          cast_message_cb),
+               base::Bind(&CastTransportSenderImpl::OnReceivedRtt,
+                          weak_factory_.GetWeakPtr(), rtt_cb),
                base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
                           weak_factory_.GetWeakPtr(), AUDIO_EVENT),
                clock_,
                &pacer_,
                config.ssrc,
                config.feedback_ssrc));
   pacer_.RegisterAudioSsrc(config.ssrc);
   status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
 }
 
 void CastTransportSenderImpl::InitializeVideo(
     const CastTransportRtpConfig& config,
     const RtcpCastMessageCallback& cast_message_cb,
     const RtcpRttCallback& rtt_cb) {
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send video with encryption DISABLED.";
   if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
     status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
   video_sender_.reset(new RtpSender(clock_, transport_task_runner_, &pacer_));
   if (!video_sender_->Initialize(config)) {
     video_sender_.reset();
     status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
   video_rtcp_session_.reset(
-      new Rtcp(cast_message_cb,
-               rtt_cb,
+      new Rtcp(base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,

[hubbe, 2014/08/11 19:11:49]

Do we really want one rtcp object for audio and one for video?
Or should we have one rtcp object for all channels?

[Alpha Left Google, 2014/08/11 21:03:17]

Yes we do. RTCP object maintain some states internally. We could eventually
merge them but that's no the scope of this change.

+                          weak_factory_.GetWeakPtr(), config.ssrc,
+                          cast_message_cb),
+               base::Bind(&CastTransportSenderImpl::OnReceivedRtt,
+                          weak_factory_.GetWeakPtr(), rtt_cb),
                base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
                           weak_factory_.GetWeakPtr(), VIDEO_EVENT),
                clock_,
                &pacer_,
                config.ssrc,
                config.feedback_ssrc));
   pacer_.RegisterVideoSsrc(config.ssrc);
   status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED);
 }
 
@@ skipping 38 matching lines @@
         audio_sender_->send_packet_count(), audio_sender_->send_octet_count());
   } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
     video_rtcp_session_->SendRtcpFromRtpSender(
         current_time, current_time_as_rtp_timestamp,
         video_sender_->send_packet_count(), video_sender_->send_octet_count());
   } else {
     NOTREACHED() << "Invalid request for sending RTCP packet.";
   }
 }
 
+void CastTransportSenderImpl::CancelSendingFrames(
+    uint32 ssrc,
+    const std::set<uint32>& frame_ids) {
+  // Cancel resends of acked frames.
+  MissingFramesAndPacketsMap missing_frames_and_packets;
+  PacketIdSet missing;
+  for (std::set<uint32>::const_iterator it = frame_ids.begin();
+       it != frame_ids.end(); ++it) {
+    missing_frames_and_packets[*it] = missing;
+  }
+  ResendPackets(ssrc, missing_frames_and_packets, true, base::TimeDelta());

[hubbe, 2014/08/11 19:11:50]

Why not call audio/video_sender->CancelSendingFrames() instead?

[Alpha Left Google, 2014/08/11 21:03:18]

Done.

+}
+
+void CastTransportSenderImpl::ResendFrameForKickstart(uint32 ssrc,
+                                                      uint32 frame_id) {
+  // Send the last packet of the encoded frame to kick start
+  // retransmission. This gives enough information to the receiver what
+  // packets and frames are missing.
+  MissingFramesAndPacketsMap missing_frames_and_packets;
+  PacketIdSet missing;
+  missing.insert(kRtcpCastLastPacket);
+  missing_frames_and_packets.insert(std::make_pair(frame_id, missing));
+
+  // Sending this extra packet is to kick-start the session. There is
+  // no need to optimize re-transmission for this case.
+  ResendPackets(ssrc, missing_frames_and_packets, false, most_recent_rtt_);

[hubbe, 2014/08/11 19:11:49]

Why not call audio/video_sender_->ResendFrameForKickStart() instead?

[Alpha Left Google, 2014/08/11 21:03:17]

Done.

+}
+
 void CastTransportSenderImpl::ResendPackets(
-    bool is_audio,
+    uint32 ssrc,
     const MissingFramesAndPacketsMap& missing_packets,
     bool cancel_rtx_if_not_in_list,
     base::TimeDelta dedupe_window) {
-  if (is_audio) {
-    DCHECK(audio_sender_) << "Audio sender uninitialized";
+  if (audio_sender_ && ssrc == audio_sender_->ssrc()) {
     audio_sender_->ResendPackets(missing_packets,
                                  cancel_rtx_if_not_in_list,
                                  dedupe_window);
-  } else {
-    DCHECK(video_sender_) << "Video sender uninitialized";
+  } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
     video_sender_->ResendPackets(missing_packets,
                                  cancel_rtx_if_not_in_list,
                                  dedupe_window);
+  } else {
+    NOTREACHED() << "Invalid request for retransmission.";
   }
 }
 
 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() {
   return base::Bind(&CastTransportSenderImpl::OnReceivedPacket,
                     weak_factory_.GetWeakPtr());
 }
 
 void CastTransportSenderImpl::SendRawEvents() {
   DCHECK(event_subscriber_.get());
@@ skipping 56 matching lines @@
           break;
         default:
           VLOG(2) << "Received log message via RTCP that we did not expect: "
                   << static_cast<int>(event_it->type);
           break;
       }
     }
   }
 }
 
+void CastTransportSenderImpl::OnReceivedRtt(const RtcpRttCallback& rtt_cb,
+                                            base::TimeDelta rtt,
+                                            base::TimeDelta avg_rtt,
+                                            base::TimeDelta min_rtt,
+                                            base::TimeDelta max_rtt) {
+  if (!rtt_cb.is_null())
+    rtt_cb.Run(rtt, avg_rtt, min_rtt, max_rtt);
+
+  most_recent_rtt_ = rtt;

[hubbe, 2014/08/11 19:11:49]

Seems like it would be cleaner to just have the rtcp object store this.

[Alpha Left Google, 2014/08/11 21:03:18]

Done.

+}
+
+void CastTransportSenderImpl::OnReceivedCastMessage(
+    uint32 ssrc,
+    const RtcpCastMessageCallback& cast_message_cb,
+    const RtcpCastMessage& cast_message) {
+  if (!cast_message_cb.is_null())
+    cast_message_cb.Run(cast_message);
+
+  if (cast_message.missing_frames_and_packets.empty())
+    return;
+
+  const bool is_audio = audio_sender_ && audio_sender_->ssrc() == ssrc;
+
+  // This call does two things.
+  // 1. Specifies that retransmissions for packets not listed in the set are
+  //    cancelled.
+  // 2. Specifies a deduplication window. For video this would be the most
+  //    recent RTT. For audio there is no deduplication.
+  ResendPackets(ssrc,
+                cast_message.missing_frames_and_packets,
+                true,
+                is_audio ? base::TimeDelta() : most_recent_rtt_);
+}
+
 }  // namespace cast
 }  // namespace media