[Cast] Refactor/clean-up VideoReceiver to match AudioReceiver as closely as possible.

media/cast/audio_receiver/audio_receiver.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/audio_receiver/audio_receiver.h"
 
+#include <algorithm>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/audio_receiver/audio_decoder.h"
 #include "media/cast/transport/cast_transport_defines.h"
 
 namespace {
+const int kMinSchedulingDelayMs = 1;
+// TODO(miu): These should go in AudioReceiverConfig.
 const int kTypicalAudioFrameDurationMs = 10;
-const int kMinSchedulingDelayMs = 1;
+const int kTypicalFramesPerSecond = 1000 / kTypicalAudioFrameDurationMs;
 }  // namespace
 
 namespace media {
 namespace cast {
 
 AudioReceiver::AudioReceiver(scoped_refptr<CastEnvironment> cast_environment,
                              const AudioReceiverConfig& audio_config,
                              transport::PacedPacketSender* const packet_sender)
     : RtpReceiver(cast_environment->Clock(), &audio_config, NULL),
       cast_environment_(cast_environment),
       event_subscriber_(kReceiverRtcpEventHistorySize,
                         ReceiverRtcpEventSubscriber::kAudioEventSubscriber),
       codec_(audio_config.codec),
       frequency_(audio_config.frequency),
+      target_delay_delta_(
+          base::TimeDelta::FromMilliseconds(audio_config.rtp_max_delay_ms)),
       framer_(cast_environment->Clock(),
-             this,
-             audio_config.incoming_ssrc,
-             true,
-             0),
+              this,
+              audio_config.incoming_ssrc,
+              true,
+              audio_config.rtp_max_delay_ms * kTypicalFramesPerSecond / 1000),

[hubbe, 2014/04/07 18:40:17]

Seems simpler to just divide by kTypicalAudioFrameDurationMs

[miu, 2014/04/08 00:59:41]

Oh, duh.  Yes, agreed.  Done.

       rtcp_(cast_environment,
             NULL,
             NULL,
             packet_sender,
             GetStatistics(),
             audio_config.rtcp_mode,
             base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
             audio_config.feedback_ssrc,
             audio_config.incoming_ssrc,
             audio_config.rtcp_c_name),
       is_waiting_for_consecutive_frame_(false),
       weak_factory_(this) {
-  target_delay_delta_ =
-      base::TimeDelta::FromMilliseconds(audio_config.rtp_max_delay_ms);
   if (!audio_config.use_external_decoder)
     audio_decoder_.reset(new AudioDecoder(cast_environment, audio_config));
   decryptor_.Initialize(audio_config.aes_key, audio_config.aes_iv_mask);
   rtcp_.SetTargetDelay(target_delay_delta_);
   cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_);
   memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
 }
 
 AudioReceiver::~AudioReceiver() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
@@ skipping 15 matching lines @@
   ScheduleNextRtcpReport();
   ScheduleNextCastMessage();
 }
 
 void AudioReceiver::OnReceivedPayloadData(const uint8* payload_data,
                                           size_t payload_size,
                                           const RtpCastHeader& rtp_header) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
-  frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] =
-      rtp_header.webrtc.header.timestamp;
-  cast_environment_->Logging()->InsertPacketEvent(
-      now, kAudioPacketReceived, rtp_header.webrtc.header.timestamp,
-      rtp_header.frame_id, rtp_header.packet_id, rtp_header.max_packet_id,
-      payload_size);
-
   // TODO(pwestin): update this as video to refresh over time.
   if (time_first_incoming_packet_.is_null()) {
     InitializeTimers();
     first_incoming_rtp_timestamp_ = rtp_header.webrtc.header.timestamp;
     time_first_incoming_packet_ = now;
   }
 
+  frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] =
+      rtp_header.webrtc.header.timestamp;
+  cast_environment_->Logging()->InsertPacketEvent(
+      now, kAudioPacketReceived, rtp_header.webrtc.header.timestamp,
+      rtp_header.frame_id, rtp_header.packet_id, rtp_header.max_packet_id,
+      payload_size);
+
   bool duplicate = false;
   const bool complete =
       framer_.InsertPacket(payload_data, payload_size, rtp_header, &duplicate);
   if (duplicate) {
     cast_environment_->Logging()->InsertPacketEvent(
-        now, kDuplicateAudioPacketReceived, rtp_header.webrtc.header.timestamp,
-        rtp_header.frame_id, rtp_header.packet_id, rtp_header.max_packet_id,
+        now,
+        kDuplicateAudioPacketReceived,
+        rtp_header.webrtc.header.timestamp,
+        rtp_header.frame_id,
+        rtp_header.packet_id,
+        rtp_header.max_packet_id,
         payload_size);
     // Duplicate packets are ignored.
     return;
   }
   if (!complete)
     return;
 
   EmitAvailableEncodedFrames();
 }
 
@@ skipping 75 matching lines @@
     }
 
     // If |framer_| has a frame ready that is out of sequence, examine the
     // playout time to determine whether it's acceptable to continue, thereby
     // skipping one or more frames.  Skip if the missing frame wouldn't complete
     // playing before the start of playback of the available frame.
     const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
     const base::TimeTicks playout_time =
         GetPlayoutTime(now, encoded_frame->rtp_timestamp);
     if (!is_consecutively_next_frame) {
+      // TODO(miu): Also account for expected decode time here?
       const base::TimeTicks earliest_possible_end_time_of_missing_frame =
           now + base::TimeDelta::FromMilliseconds(kTypicalAudioFrameDurationMs);
       if (earliest_possible_end_time_of_missing_frame < playout_time) {
         VLOG(1) << "Wait for next consecutive frame instead of skipping.";
         if (!is_waiting_for_consecutive_frame_) {
           is_waiting_for_consecutive_frame_ = true;
           cast_environment_->PostDelayedTask(
               CastEnvironment::MAIN,
               FROM_HERE,
               base::Bind(&AudioReceiver::EmitAvailableEncodedFramesAfterWaiting,
@@ skipping 32 matching lines @@
 
 void AudioReceiver::EmitAvailableEncodedFramesAfterWaiting() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(is_waiting_for_consecutive_frame_);
   is_waiting_for_consecutive_frame_ = false;
   EmitAvailableEncodedFrames();
 }
 
 void AudioReceiver::IncomingPacket(scoped_ptr<Packet> packet) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  bool rtcp_packet = Rtcp::IsRtcpPacket(&packet->front(), packet->size());
-  if (!rtcp_packet) {
+  if (Rtcp::IsRtcpPacket(&packet->front(), packet->size())) {
+    rtcp_.IncomingRtcpPacket(&packet->front(), packet->size());
+  } else {
     ReceivedPacket(&packet->front(), packet->size());
-  } else {
-    rtcp_.IncomingRtcpPacket(&packet->front(), packet->size());
   }
 }
 
 void AudioReceiver::SetTargetDelay(base::TimeDelta target_delay) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   target_delay_delta_ = target_delay;
   rtcp_.SetTargetDelay(target_delay_delta_);
 }
 
 void AudioReceiver::CastFeedback(const RtcpCastMessage& cast_message) {
@@ skipping 67 matching lines @@
 
 void AudioReceiver::ScheduleNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeDelta time_to_send = rtcp_.TimeToSendNextRtcpReport() -
                                  cast_environment_->Clock()->NowTicks();
 
   time_to_send = std::max(
       time_to_send, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
   cast_environment_->PostDelayedTask(
-      CastEnvironment::MAIN, FROM_HERE,
+      CastEnvironment::MAIN,
+      FROM_HERE,
       base::Bind(&AudioReceiver::SendNextRtcpReport,
                  weak_factory_.GetWeakPtr()),
       time_to_send);
 }
 
 void AudioReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // TODO(pwestin): add logging.
   rtcp_.SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 // Cast messages should be sent within a maximum interval. Schedule a call
 // if not triggered elsewhere, e.g. by the cast message_builder.
 void AudioReceiver::ScheduleNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks send_time;
   framer_.TimeToSendNextCastMessage(&send_time);
   base::TimeDelta time_to_send =
       send_time - cast_environment_->Clock()->NowTicks();
   time_to_send = std::max(
       time_to_send, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
   cast_environment_->PostDelayedTask(
-      CastEnvironment::MAIN, FROM_HERE,
+      CastEnvironment::MAIN,
+      FROM_HERE,
       base::Bind(&AudioReceiver::SendNextCastMessage,
                  weak_factory_.GetWeakPtr()),
       time_to_send);
 }
 
 void AudioReceiver::SendNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  // Will only send a message if it is time.
-  framer_.SendCastMessage();
+  framer_.SendCastMessage();  // Will only send a message if it is time.
   ScheduleNextCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media