[Cast] In Audio/VideoSender, drop frames when too-long a duration is in-flight.

media/cast/sender/rtp_timestamp_helper.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.
 
 #ifndef MEDIA_CAST_SENDER_RTP_TIMESTAMP_HELPER_H_
 #define MEDIA_CAST_SENDER_RTP_TIMESTAMP_HELPER_H_
 
 #include "base/basictypes.h"
 #include "base/time/time.h"
 
 namespace media {
 namespace cast {
 
 // A helper class used to convert current time ticks into RTP timestamp.
 class RtpTimestampHelper {
  public:
   explicit RtpTimestampHelper(int frequency);
   ~RtpTimestampHelper();
 
-  // Compute a RTP timestamp using current time, last encoded time and
-  // last encoded RTP timestamp.
-  // Return true if |rtp_timestamp| is computed.
-  bool GetCurrentTimeAsRtpTimestamp(const base::TimeTicks& now,
-                                    uint32* rtp_timestamp) const;
+  int frequency() const { return frequency_; }
+
+  // Compute a RTP timestamp for |t|, based on the last stored capture time and
+  // its corresponding RTP timestamp.  Return true if |rtp_timestamp| is
+  // computed.
+  bool EstimateRtpTimestamp(const base::TimeTicks& t,

[hubbe, 2014/08/26 17:49:56]

Why is it an estimate?
Does it return "approximately" the right timestamp?

[miu, 2014/08/26 19:57:19]

Yes.  It's an estimate because, ultimately, it's the encoders that decide what
the RTP timestamps for each frame are going to be.  For example, in the case of
audio, the record_time will never be precise to a 10ms boundary; and so the
translation will be to an |rtp_timestamp| value that is near, but never exact to
one emitted downstream by the encoder.  In other words, it's an approximation.

[hubbe, 2014/08/26 20:54:21]

If we do this with timeticks/deltas instead, do we even need this estimate? If
the answer is yes, please update the comment to provide the same information as
your reply above.

[miu, 2014/08/26 23:27:16]

Done.  This method is also used when generating SR's, so I explained the
"estimate" via code comments.

+                            uint32* rtp_timestamp) const;
 
   // Store the capture time and the corresponding RTP timestamp for the
   // last encoded frame.
   void StoreLatestTime(base::TimeTicks capture_time, uint32 rtp_timestamp);
 
  private:
   int frequency_;
   base::TimeTicks last_capture_time_;
   uint32 last_rtp_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(RtpTimestampHelper);
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_SENDER_RTP_TIMESTAMP_HELPER_H_