Cast: end2end bug fixes

media/cast/transport/rtp_sender/rtp_sender.cc

 // 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.
 
 #include "media/cast/transport/rtp_sender/rtp_sender.h"
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/transport/pacing/paced_sender.h"
 #include "net/base/big_endian.h"
 
 namespace media {
 namespace cast {
 namespace transport {
 
-// Schedule the RTP statistics callback every 100mS.
-static const int kStatsCallbackIntervalMs = 100;
+// Schedule the RTP statistics callback every 33mS. As this interval affects the
+// time offset of the render and playout times, we want it in the same ball park
+// as the frame rate.
+static const int kStatsCallbackIntervalMs = 33;
 
 RtpSender::RtpSender(
     base::TickClock* clock,
     const CastTransportConfig& config,
     bool is_audio,
     const scoped_refptr<base::TaskRunner>& transport_task_runner,
     PacedSender* const transport)
-    : clock_(clock),
-      config_(),
+    : config_(),
       transport_(transport),
       stats_callback_(),
       transport_task_runner_(transport_task_runner) {
   // Store generic cast config and create packetizer config.
   if (is_audio) {
     storage_.reset(
         new PacketStorage(clock, config.audio_rtp_config.history_ms));
     config_.audio = true;
     config_.ssrc = config.audio_ssrc;
     config_.payload_type = config.audio_rtp_config.payload_type;
     config_.frequency = config.audio_frequency;
     config_.audio_codec = config.audio_codec;
   } else {
     storage_.reset(
         new PacketStorage(clock, config.audio_rtp_config.history_ms));
     config_.audio = false;
     config_.ssrc = config.video_ssrc;
     config_.payload_type = config.video_rtp_config.payload_type;
     config_.frequency = kVideoFrequency;
     config_.video_codec = config.video_codec;
   }
   // Randomly set start values.
   config_.sequence_number = base::RandInt(0, 65535);
-  packetizer_.reset(new RtpPacketizer(transport, storage_.get(), config_));
+  packetizer_.reset(
+      new RtpPacketizer(transport, storage_.get(), config_));
 }
 
 RtpSender::~RtpSender() {}
 
 void RtpSender::IncomingEncodedVideoFrame(const EncodedVideoFrame* video_frame,
                                           const base::TimeTicks& capture_time) {
   packetizer_->IncomingEncodedVideoFrame(video_frame, capture_time);
 }
 
 void RtpSender::IncomingEncodedAudioFrame(
@@ skipping 69 matching lines @@
 
 void RtpSender::ScheduleNextStatsReport() {
   transport_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&RtpSender::RtpStatistics, base::Unretained(this)),
       base::TimeDelta::FromMilliseconds(kStatsCallbackIntervalMs));
 }
 
 void RtpSender::RtpStatistics() {
   RtcpSenderInfo sender_info;
-  uint32 ntp_seconds = 0;
-  uint32 ntp_fraction = 0;
-  ConvertTimeTicksToNtp(clock_->NowTicks(), &ntp_seconds, &ntp_fraction);
-  sender_info.ntp_seconds = ntp_seconds;
-  sender_info.ntp_fraction = ntp_fraction;
-
   base::TimeTicks time_sent;
   uint32 rtp_timestamp = 0;
   packetizer_->LastSentTimestamp(&time_sent, &rtp_timestamp);
   sender_info.send_packet_count = packetizer_->send_packets_count();
   sender_info.send_octet_count = packetizer_->send_octet_count();
   stats_callback_.Run(sender_info, time_sent, rtp_timestamp);
   ScheduleNextStatsReport();
 }
 
 }  // namespace transport
 }  //  namespace cast
 }  // namespace media