Cast: Make receiver use cast_transport

media/cast/receiver/frame_receiver.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/receiver/frame_receiver.h"
 
 #include <algorithm>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_environment.h"
 
 namespace {
 const int kMinSchedulingDelayMs = 1;
 }  // namespace
 
 namespace media {
 namespace cast {
 
 FrameReceiver::FrameReceiver(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const FrameReceiverConfig& config,
     EventMediaType event_media_type,
-    PacedPacketSender* const packet_sender)
+    CastTransportSender* const transport)
     : cast_environment_(cast_environment),
+      transport_(transport),
       packet_parser_(config.incoming_ssrc, config.rtp_payload_type),
       stats_(cast_environment->Clock()),
       event_media_type_(event_media_type),
       event_subscriber_(kReceiverRtcpEventHistorySize, event_media_type),
       rtp_timebase_(config.frequency),
       target_playout_delay_(
           base::TimeDelta::FromMilliseconds(config.rtp_max_delay_ms)),
       expected_frame_duration_(
           base::TimeDelta::FromSeconds(1) / config.max_frame_rate),
       reports_are_scheduled_(false),
       framer_(cast_environment->Clock(),
               this,
               config.incoming_ssrc,
               true,
               config.rtp_max_delay_ms * config.max_frame_rate / 1000),
       rtcp_(RtcpCastMessageCallback(),
             RtcpRttCallback(),
             RtcpLogMessageCallback(),
             cast_environment_->Clock(),
-            packet_sender,
+            NULL,
             config.feedback_ssrc,
             config.incoming_ssrc),
       is_waiting_for_consecutive_frame_(false),
       lip_sync_drift_(ClockDriftSmoother::GetDefaultTimeConstant()),
       rtcp_interval_(base::TimeDelta::FromMilliseconds(config.rtcp_interval)),
       weak_factory_(this) {
+  transport_->AddValidSsrc(config.incoming_ssrc);
   DCHECK_GT(config.rtp_max_delay_ms, 0);
   DCHECK_GT(config.max_frame_rate, 0);
   decryptor_.Initialize(config.aes_key, config.aes_iv_mask);
   cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_);
   memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
 }
 
 FrameReceiver::~FrameReceiver() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber_);
@@ skipping 29 matching lines @@
 
   if (!reports_are_scheduled_) {
     ScheduleNextRtcpReport();
     ScheduleNextCastMessage();
     reports_are_scheduled_ = true;
   }
 
   return true;
 }
 
-// static
-bool FrameReceiver::ParseSenderSsrc(const uint8* packet,
-                                    size_t length,
-                                    uint32* ssrc) {
-  base::BigEndianReader big_endian_reader(
-      reinterpret_cast<const char*>(packet), length);
-  return big_endian_reader.Skip(8) && big_endian_reader.ReadU32(ssrc);
-}
-
 void FrameReceiver::ProcessParsedPacket(const RtpCastHeader& rtp_header,
                                         const uint8* payload_data,
                                         size_t payload_size) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] =
       rtp_header.rtp_timestamp;
   cast_environment_->Logging()->InsertPacketEvent(
@@ skipping 48 matching lines @@
 void FrameReceiver::CastFeedback(const RtcpCastMessage& cast_message) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpTimestamp rtp_timestamp =
       frame_id_to_rtp_timestamp_[cast_message.ack_frame_id & 0xff];
   cast_environment_->Logging()->InsertFrameEvent(
       now, FRAME_ACK_SENT, event_media_type_,
       rtp_timestamp, cast_message.ack_frame_id);
 
-  ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
-  event_subscriber_.GetRtcpEventsAndReset(&rtcp_events);
-  rtcp_.SendRtcpFromRtpReceiver(&cast_message, target_playout_delay_,
-                                &rtcp_events, NULL);
+  ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
+  event_subscriber_.GetRtcpEventsWithRedundancy(&rtcp_events);
+  transport_->SendRtcpFromRtpReceiver(rtcp_.GetLocalSsrc(),
+                                      rtcp_.GetRemoteSsrc(),
+                                      rtcp_.ConvertToNTPAndSave(now),
+                                      &cast_message,
+                                      target_playout_delay_,
+                                      &rtcp_events,
+                                      NULL);
 }
 
 void FrameReceiver::EmitAvailableEncodedFrames() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   while (!frame_request_queue_.empty()) {
     // Attempt to peek at the next completed frame from the |framer_|.
     // TODO(miu): We should only be peeking at the metadata, and not copying the
     // payload yet!  Or, at least, peek using a StringPiece instead of a copy.
     scoped_ptr<EncodedFrame> encoded_frame(
@@ skipping 135 matching lines @@
   cast_environment_->PostDelayedTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(&FrameReceiver::SendNextRtcpReport,
                  weak_factory_.GetWeakPtr()),
       time_to_next);
 }
 
 void FrameReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpReceiverStatistics stats = stats_.GetStatistics();
-  rtcp_.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats);
+  transport_->SendRtcpFromRtpReceiver(rtcp_.GetLocalSsrc(),
+                                      rtcp_.GetRemoteSsrc(),
+                                      rtcp_.ConvertToNTPAndSave(now),
+                                      NULL,
+                                      base::TimeDelta(),
+                                      NULL,
+                                      &stats);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media