src/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,
  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.aes_key = audio_config.aes_key;
  66   transport_config.aes_iv_mask = audio_config.aes_iv_mask;
  67
  68   transport_sender->InitializeAudio(
  69       transport_config,
  70       base::Bind(&AudioSender::OnReceivedCastFeedback,
  71                  weak_factory_.GetWeakPtr()),
  72       base::Bind(&AudioSender::OnMeasuredRoundTripTime,
  73                  weak_factory_.GetWeakPtr()));
  74 }
  75
  76 AudioSender::~AudioSender() {}
  77
  78 void AudioSender::InsertAudio(scoped_ptr<AudioBus> audio_bus,
  79                               const base::TimeTicks& recorded_time) {
  80   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
  81   if (cast_initialization_status_ != STATUS_AUDIO_INITIALIZED) {
  82     NOTREACHED();
  83     return;
  84   }
  85   DCHECK(audio_encoder_.get()) << "Invalid internal state";
  86
  87   const base::TimeDelta next_frame_duration =
  88       RtpDeltaToTimeDelta(audio_bus->frames(), rtp_timebase());
  89   if (ShouldDropNextFrame(next_frame_duration))
  90     return;
  91
  92   samples_in_encoder_ += audio_bus->frames();
  93
  94   audio_encoder_->InsertAudio(audio_bus.Pass(), recorded_time);
  95 }
  96
  97 int AudioSender::GetNumberOfFramesInEncoder() const {
  98   // Note: It's possible for a partial frame to be in the encoder, but returning
  99   // the floor() is good enough for the "design limit" check in FrameSender.
 100   return samples_in_encoder_ / audio_encoder_->GetSamplesPerFrame();
 101 }
 102
 103 base::TimeDelta AudioSender::GetInFlightMediaDuration() const {
 104   const int samples_in_flight = samples_in_encoder_ +
 105       GetUnacknowledgedFrameCount() * audio_encoder_->GetSamplesPerFrame();
 106   return RtpDeltaToTimeDelta(samples_in_flight, rtp_timebase());
 107 }
 108
 109 void AudioSender::OnAck(uint32 frame_id) {
 110 }
 111
 112 void AudioSender::OnEncodedAudioFrame(
 113     int encoder_bitrate,
 114     scoped_ptr<EncodedFrame> encoded_frame,
 115     int samples_skipped) {
 116   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 117
 118   samples_in_encoder_ -= audio_encoder_->GetSamplesPerFrame() + samples_skipped;
 119   DCHECK_GE(samples_in_encoder_, 0);
 120
 121   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 122 }
 123
 124 }  // namespace cast
 125 }  // namespace media