media/cast/sender/audio_sender.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/cast/sender/audio_sender.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "media/cast/cast_defines.h"
  11 #include "media/cast/net/cast_transport_config.h"
  12 #include "media/cast/sender/audio_encoder.h"
  13
  14 namespace media {
  15 namespace cast {
  16 namespace {
  17
  18 // TODO(miu): This should be specified in AudioSenderConfig, but currently it is
  19 // fixed to 100 FPS (i.e., 10 ms per frame), and AudioEncoder assumes this as
  20 // well.
  21 const int kAudioFrameRate = 100;
  22
  23 }  // namespace
  24
  25 AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
  26                          const AudioSenderConfig& audio_config,
  27                          CastTransportSender* const transport_sender)
  28     : FrameSender(
  29         cast_environment,
  30         true,
  31         transport_sender,
  32         base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
  33         audio_config.frequency,
  34         audio_config.ssrc,
  35         kAudioFrameRate * 2.0, // We lie to increase max outstanding frames.
  36         audio_config.min_playout_delay,
  37         audio_config.max_playout_delay,
  38         NewFixedCongestionControl(audio_config.bitrate)),
  39       samples_in_encoder_(0),
  40       weak_factory_(this) {
  41   cast_initialization_status_ = STATUS_AUDIO_UNINITIALIZED;
  42   VLOG(1) << "max_unacked_frames " << max_unacked_frames_;
  43   DCHECK_GT(max_unacked_frames_, 0);
  44
  45   if (!audio_config.use_external_encoder) {
  46     audio_encoder_.reset(
  47         new AudioEncoder(cast_environment,
  48                          audio_config.channels,
  49                          audio_config.frequency,
  50                          audio_config.bitrate,
  51                          audio_config.codec,
  52                          base::Bind(&AudioSender::OnEncodedAudioFrame,
  53                                     weak_factory_.GetWeakPtr(),
  54                                     audio_config.bitrate)));
  55     cast_initialization_status_ = audio_encoder_->InitializationResult();
  56   } else {
  57     NOTREACHED();  // No support for external audio encoding.
  58     cast_initialization_status_ = STATUS_AUDIO_UNINITIALIZED;
  59   }
  60
  61   media::cast::CastTransportRtpConfig transport_config;
  62   transport_config.ssrc = audio_config.ssrc;
  63   transport_config.feedback_ssrc = audio_config.incoming_feedback_ssrc;
  64   transport_config.rtp_payload_type = audio_config.rtp_payload_type;
  65   transport_config.stored_frames =
  66       std::min(kMaxUnackedFrames,
  67                1 + static_cast<int>(max_playout_delay_ *
  68                                     max_frame_rate_ /
  69                                     base::TimeDelta::FromSeconds(1)));
  70   transport_config.aes_key = audio_config.aes_key;
  71   transport_config.aes_iv_mask = audio_config.aes_iv_mask;
  72
  73   transport_sender->InitializeAudio(
  74       transport_config,
  75       base::Bind(&AudioSender::OnReceivedCastFeedback,
  76                  weak_factory_.GetWeakPtr()),
  77       base::Bind(&AudioSender::OnMeasuredRoundTripTime,
  78                  weak_factory_.GetWeakPtr()));
  79 }
  80
  81 AudioSender::~AudioSender() {}
  82
  83 void AudioSender::InsertAudio(scoped_ptr<AudioBus> audio_bus,
  84                               const base::TimeTicks& recorded_time) {
  85   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
  86   if (cast_initialization_status_ != STATUS_AUDIO_INITIALIZED) {
  87     NOTREACHED();
  88     return;
  89   }
  90   DCHECK(audio_encoder_.get()) << "Invalid internal state";
  91
  92   // TODO(miu): An |audio_bus| that represents more duration than a single
  93   // frame's duration can defeat our logic here, causing too much data to become
  94   // enqueued.  This will be addressed in a soon-upcoming change.
  95   if (ShouldDropNextFrame(recorded_time)) {
  96     VLOG(1) << "Dropping frame due to too many frames currently in-flight.";
  97     return;
  98   }
  99
 100   samples_in_encoder_ += audio_bus->frames();
 101
 102   audio_encoder_->InsertAudio(audio_bus.Pass(), recorded_time);
 103 }
 104
 105 int AudioSender::GetNumberOfFramesInEncoder() const {
 106   // Note: It's possible for a partial frame to be in the encoder, but returning
 107   // the floor() is good enough for the "design limit" check in FrameSender.
 108   return samples_in_encoder_ / audio_encoder_->GetSamplesPerFrame();
 109 }
 110
 111 void AudioSender::OnAck(uint32 frame_id) {
 112 }
 113
 114 void AudioSender::OnEncodedAudioFrame(
 115     int encoder_bitrate,
 116     scoped_ptr<EncodedFrame> encoded_frame,
 117     int samples_skipped) {
 118   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 119
 120   samples_in_encoder_ -= audio_encoder_->GetSamplesPerFrame() + samples_skipped;
 121   DCHECK_GE(samples_in_encoder_, 0);
 122
 123   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 124 }
 125
 126 }  // namespace cast
 127 }  // namespace media