[Cast] Repair receiver playout time calculations and frame skip logic.

media/cast/rtcp/rtcp.h

 // Copyright 2013 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.
 
 #ifndef MEDIA_CAST_RTCP_RTCP_H_
 #define MEDIA_CAST_RTCP_RTCP_H_
 
-#include <list>
 #include <map>
 #include <queue>
-#include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/rtcp/receiver_rtcp_event_subscriber.h"
@@ skipping 72 matching lines @@
   // will append the log messages.
   void SendRtcpFromRtpReceiver(
       const RtcpCastMessage* cast_message,
       const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events);
 
   void IncomingRtcpPacket(const uint8* rtcp_buffer, size_t length);
   bool Rtt(base::TimeDelta* rtt,
            base::TimeDelta* avg_rtt,
            base::TimeDelta* min_rtt,
            base::TimeDelta* max_rtt) const;
-  bool RtpTimestampInSenderTime(int frequency,
-                                uint32 rtp_timestamp,
-                                base::TimeTicks* rtp_timestamp_in_ticks) const;
+
+  // Maps a frame's |rtp_timestamp| to its approximate capture time, based on
+  // the latest "lip sync" info gleaned from the sender reports.  The returned
+  // TimeTicks value is relative to the local CastEnvironment clock.  Returns a
+  // null TimeTicks value to indicate no lip sync info was available.
+  // |rtp_timebase| is the number of units of |rtp_timestamp| that elapse per
+  // one second (e.g., for audio, this is usually the sampling frequency).
+  //
+  // Note: The values returned are not guaranteed to be monotonically increasing
+  // for monotonically increasing rtp_timestamps.  In fact, it's possible that
+  // calling this method more than once with the same arguments will return
+  // different results.
+  base::TimeTicks ToApproximateCaptureTime(uint32 rtp_timestamp,

[hubbe, 2014/05/19 17:52:20]

I'm not sure "Capture Time" is the terminology we want to use in the cast
library, since technically the frame might not have been "captured" at all.

Perhaps "SenderPlayoutTimeInLocalTime" ?

[miu, 2014/05/23 03:09:01]

Done.  After fixing the logic, I moved the code around a little.  The concept of
"capture time" is no longer found anywhere in rtcp.*.

+                                           int rtp_timebase) const;
 
   // Set the history size to record Cast receiver events. The event history is
   // used to remove duplicates. The history will store at most |size| events.
   void SetCastReceiverEventHistorySize(size_t size);
 
-  // Update the target delay. Will be added to every sender report.
+  // Update the target delay. Will be added to every report sent back to the
+  // sender.
+  // TODO(miu): Remove this deprecated functionality. The sender ignores this.
   void SetTargetDelay(base::TimeDelta target_delay);
 
   void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log);
 
  protected:
-  int CheckForWrapAround(uint32 new_timestamp, uint32 old_timestamp) const;
-
+  void OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction);
   void OnReceivedLipSyncInfo(uint32 rtp_timestamp,
                              uint32 ntp_seconds,
                              uint32 ntp_fraction);
 
  private:
   friend class LocalRtcpRttFeedback;
   friend class LocalRtcpReceiverFeedback;
 
-  void SendRtcp(const base::TimeTicks& now,
-                uint32 packet_type_flags,
-                uint32 media_ssrc,
-                const RtcpCastMessage* cast_message);
-
-  void OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction);
+  // Uses recent reports from the remote to translate remote-provided NTP
+  // timestamps into TimeTicks values relative to the local clock.  Returns a
+  // null TimeTicks value to indicate a usable report has not yet been received.
+  base::TimeTicks ToApproximateLocalTime(uint32 remote_ntp_seconds,
+                                         uint32 remote_ntp_fraction) const;
 
   void OnReceivedDelaySinceLastReport(uint32 receivers_ssrc,
                                       uint32 last_report,
                                       uint32 delay_since_last_report);
 
   void OnReceivedSendReportRequest();
 
   void UpdateRtt(const base::TimeDelta& sender_delay,
                  const base::TimeDelta& receiver_delay);
 
   void UpdateNextTimeToSendRtcp();
 
   void SaveLastSentNtpTime(const base::TimeTicks& now,
                            uint32 last_ntp_seconds,
                            uint32 last_ntp_fraction);
 
+  // Returns a truncated 16+16-bit NTP timestamp, computed from the full
+  // 32+32-bit NTP timestamp in |last_report_ntp_time_|.
+  uint32 GetTruncatedLastNtpReportTime() const;
+
   scoped_refptr<CastEnvironment> cast_environment_;
   transport::CastTransportSender* const transport_sender_;
   const base::TimeDelta rtcp_interval_;
   const RtcpMode rtcp_mode_;
   const uint32 local_ssrc_;
   const uint32 remote_ssrc_;
   const std::string c_name_;
 
   // Not owned by this class.
   RtpReceiverStatistics* const rtp_receiver_statistics_;
 
   scoped_ptr<LocalRtcpRttFeedback> rtt_feedback_;
   scoped_ptr<LocalRtcpReceiverFeedback> receiver_feedback_;
   scoped_ptr<RtcpSender> rtcp_sender_;
   scoped_ptr<RtcpReceiver> rtcp_receiver_;
 
   base::TimeTicks next_time_to_send_rtcp_;
   RtcpSendTimeMap last_reports_sent_map_;
   RtcpSendTimeQueue last_reports_sent_queue_;
+
+  // The NTP timestamp provided in the last report from the remote peer, along
+  // with the local time at which the report was received.  These two values are
+  // used both for: 1) ping-pong'ing NTP timestamps between the peers; and 2)
+  // computing the local clock's offset from the remote clock.
+  uint64 last_report_ntp_time_;
   base::TimeTicks time_last_report_received_;
-  uint32 last_report_received_;
 
-  uint32 last_received_rtp_timestamp_;
-  uint32 last_received_ntp_seconds_;
-  uint32 last_received_ntp_fraction_;
+  // Latest "lip sync" info from the sender.  The sender provides the RTP
+  // timestamp of some frame of its choosing and also the frame's capture time.
+  // This allows the receiver to approximate the capture times of other frames
+  // based on their RTP timestamp.  It is expected that the sender will update
+  // this data regularly and in a timely manner (e.g., about once per second).
+  uint32 lip_sync_rtp_timestamp_;
+  base::TimeTicks lip_sync_capture_time_;
 
   base::TimeDelta rtt_;
   base::TimeDelta min_rtt_;
   base::TimeDelta max_rtt_;
   int number_of_rtt_in_avg_;
-  float avg_rtt_ms_;
+  double avg_rtt_ms_;
   uint16 target_delay_ms_;
   bool is_audio_;
 
   DISALLOW_COPY_AND_ASSIGN(Rtcp);
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_RTCP_RTCP_H_