Cast: Make receiver use cast_transport

media/cast/net/rtcp/rtcp.h

 // 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.
 
 // This class maintains a bi-directional RTCP connection with a remote
 // peer.
 
 #ifndef MEDIA_CAST_RTCP_RTCP_H_
 #define MEDIA_CAST_RTCP_RTCP_H_
 
@@ skipping 20 matching lines @@
 
 class LocalRtcpReceiverFeedback;
 class PacedPacketSender;
 class RtcpReceiver;
 class RtcpBuilder;
 
 typedef std::pair<uint32, base::TimeTicks> RtcpSendTimePair;
 typedef std::map<uint32, base::TimeTicks> RtcpSendTimeMap;
 typedef std::queue<RtcpSendTimePair> RtcpSendTimeQueue;
 
-struct RtpReceiverStatistics {
-  RtpReceiverStatistics();
-  uint8 fraction_lost;
-  uint32 cumulative_lost;  // 24 bits valid.
-  uint32 extended_high_sequence_number;
-  uint32 jitter;
-};
-
 // TODO(hclam): This should be renamed to RtcpSession.
 class Rtcp {
  public:
   Rtcp(const RtcpCastMessageCallback& cast_callback,
        const RtcpRttCallback& rtt_callback,
        const RtcpLogMessageCallback& log_callback,
        base::TickClock* clock,  // Not owned.
        PacedPacketSender* packet_sender,  // Not owned.
        uint32 local_ssrc,
        uint32 remote_ssrc);
 
   virtual ~Rtcp();
 
   // Send a RTCP sender report.
   // |current_time| is the current time reported by a tick clock.
   // |current_time_as_rtp_timestamp| is the corresponding RTP timestamp.
   // |send_packet_count| is the number of packets sent.
   // |send_octet_count| is the number of octets sent.
   void SendRtcpFromRtpSender(
       base::TimeTicks current_time,
       uint32 current_time_as_rtp_timestamp,
       uint32 send_packet_count,
       size_t send_octet_count);
 
-  // |cast_message| and |rtcp_events| is optional; if |cast_message| is
-  // provided the RTCP receiver report will append a Cast message containing
-  // Acks and Nacks; |target_delay| is sent together with |cast_message|.
-  // If |rtcp_events| is provided the RTCP receiver report will append the
-  // log messages.
+  // This function is meant to be used in conjunction with
+  // SendRtcpFromRtpReceiver.
+  // |now| is converted to NTP and saved internally for
+  // future round-trip/lip-sync calculations.
+  // This is done in a separate method so that SendRtcpFromRtpReceiver can
+  // be done on a separate (temporary) RTCP object.
+  RtcpTimeData ConvertToNTPAndSave(base::TimeTicks now);
+
+  // |cast_message|, |rtcp_events| and |rtp_receiver_statistics| are optional;
+  // if |cast_message| is provided the RTCP receiver report will append a Cast
+  // message containing Acks and Nacks; |target_delay| is sent together with
+  // |cast_message|. If |rtcp_events| is provided the RTCP receiver report will
+  // append the log messages.
   void SendRtcpFromRtpReceiver(
+      RtcpTimeData time_data,
       const RtcpCastMessage* cast_message,
       base::TimeDelta target_delay,
-      const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
-      RtpReceiverStatistics* rtp_receiver_statistics);
+      const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
+      const RtpReceiverStatistics* rtp_receiver_statistics) const;
 
   // Submit a received packet to this object. The packet will be parsed
   // and used to maintain a RTCP session.
   // Returns false if this is not a RTCP packet or it is not directed to
   // this session, e.g. SSRC doesn't match.
   bool IncomingRtcpPacket(const uint8* data, size_t length);
 
   // If available, returns true and sets the output arguments to the latest
   // lip-sync timestamps gleaned from the sender reports.  While the sender
   // provides reference NTP times relative to its own wall clock, the
   // |reference_time| returned here has been translated to the local
   // CastEnvironment clock.
   bool GetLatestLipSyncTimes(uint32* rtp_timestamp,
                              base::TimeTicks* reference_time) const;
 
   void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log);
 
   // If greater than zero, this is the last measured network round trip time.
   base::TimeDelta current_round_trip_time() const {
     return current_round_trip_time_;
   }
 
   static bool IsRtcpPacket(const uint8* packet, size_t length);
   static uint32 GetSsrcOfSender(const uint8* rtcp_buffer, size_t length);
 
+  uint32 GetLocalSsrc() const { return local_ssrc_; }
+  uint32 GetRemoteSsrc() const { return remote_ssrc_; }
+
  protected:
   void OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction);
   void OnReceivedLipSyncInfo(uint32 rtp_timestamp,
                              uint32 ntp_seconds,
                              uint32 ntp_fraction);
 
  private:
   void OnReceivedDelaySinceLastReport(uint32 last_report,
                                       uint32 delay_since_last_report);
 
@@ skipping 54 matching lines @@
   base::hash_set<ReceiverEventKey> receiver_event_key_set_;
   std::queue<ReceiverEventKey> receiver_event_key_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(Rtcp);
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_RTCP_RTCP_H_