[Cast] Clean-up: Merge AudioReceiverConfig+VideoReceiverConfig-->FrameReceiverConfig.

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): This should go in AudioReceiverConfig.
-const int kTypicalAudioFrameDurationMs = 10;
 }  // namespace
 
 namespace media {
 namespace cast {
 
 AudioReceiver::AudioReceiver(scoped_refptr<CastEnvironment> cast_environment,
-                             const AudioReceiverConfig& audio_config,
+                             const FrameReceiverConfig& audio_config,
                              transport::PacedPacketSender* const packet_sender)
     : RtpReceiver(cast_environment->Clock(), &audio_config, NULL),
       cast_environment_(cast_environment),
       event_subscriber_(kReceiverRtcpEventHistorySize, AUDIO_EVENT),
-      codec_(audio_config.codec),
+      codec_(audio_config.codec.audio),
       frequency_(audio_config.frequency),
       target_playout_delay_(
           base::TimeDelta::FromMilliseconds(audio_config.rtp_max_delay_ms)),
+      expected_frame_duration_(
+          base::TimeDelta::FromSeconds(1) / audio_config.max_frame_rate),
       reports_are_scheduled_(false),
       framer_(cast_environment->Clock(),
               this,
               audio_config.incoming_ssrc,
               true,
-              audio_config.rtp_max_delay_ms / kTypicalAudioFrameDurationMs),
+              audio_config.rtp_max_delay_ms * audio_config.max_frame_rate /
+                  1000),
       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,
             true),
       is_waiting_for_consecutive_frame_(false),
       lip_sync_drift_(ClockDriftSmoother::GetDefaultTimeConstant()),
       weak_factory_(this) {
-  if (!audio_config.use_external_decoder)
-    audio_decoder_.reset(new AudioDecoder(cast_environment, audio_config));
+  DCHECK_GT(audio_config.rtp_max_delay_ms, 0);
+  DCHECK_GT(audio_config.max_frame_rate, 0);
+  audio_decoder_.reset(new AudioDecoder(cast_environment, audio_config));
   decryptor_.Initialize(audio_config.aes_key, audio_config.aes_iv_mask);
   rtcp_.SetTargetDelay(target_playout_delay_);
   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));
   cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber_);
 }
@@ skipping 146 matching lines @@
       continue;
     }
 
     // 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.
     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);
+          now + expected_frame_duration_;
       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,
                          weak_factory_.GetWeakPtr()),
               playout_time - now);
@@ skipping 113 matching lines @@
 }
 
 void AudioReceiver::SendNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   framer_.SendCastMessage();  // Will only send a message if it is time.
   ScheduleNextCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media