Skip to content

GitLab

T
tangled
Commit 82439ec2 authored by mikhal@chromium.org's avatar mikhal@chromium.org
Browse files
Options

Cast: Refactor AudioSender to Clang format 

This cl is pure style-targeted refactoring. 
No functional changes were made. 

BUG=339176

Review URL: https://codereview.chromium.org/149253008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@247907 0039d316-1c4b-4281-b951-d872f2087c98
parent 46482700
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 235 additions and 202 deletions
media/cast/audio_sender/audio_encoder.cc
View file @ 82439ec2
......@@ -25,8 +25,11 @@ void LogAudioEncodedEvent(CastEnvironment* const cast_environment,
// TODO(mikhal): Resolve timestamp calculation for audio.
base::TimeTicks now = cast_environment->Clock()->NowTicks();
cast_environment->Logging()->InsertFrameEvent(now, kAudioFrameEncoded,
GetVideoRtpTimestamp(recorded_time), kFrameIdUnknown);
cast_environment->Logging()->InsertFrameEvent(
now,
kAudioFrameEncoded,
GetVideoRtpTimestamp(recorded_time),
kFrameIdUnknown);
}
// Base class that handles the common problem of feeding one or more AudioBus'
......@@ -38,10 +41,13 @@ void LogAudioEncodedEvent(CastEnvironment* const cast_environment,
class AudioEncoder::ImplBase {
public:
ImplBase(CastEnvironment* cast_environment,
transport::AudioCodec codec, int num_channels, int sampling_rate,
transport::AudioCodec codec,
int num_channels,
int sampling_rate,
const FrameEncodedCallback& callback)
: cast_environment_(cast_environment),
codec_(codec), num_channels_(num_channels),
codec_(codec),
num_channels_(num_channels),
samples_per_10ms_(sampling_rate / 100),
callback_(callback),
buffer_fill_end_(0),
......@@ -52,8 +58,7 @@ class AudioEncoder::ImplBase {
DCHECK_LE(samples_per_10ms_ * num_channels_,
transport::EncodedAudioFrame::kMaxNumberOfSamples);
if (num_channels_ <= 0 ||
samples_per_10ms_ <= 0 ||
if (num_channels_ <= 0 || samples_per_10ms_ <= 0 ||
sampling_rate % 100 != 0 ||
samples_per_10ms_ * num_channels_ >
transport::EncodedAudioFrame::kMaxNumberOfSamples) {
......@@ -74,9 +79,8 @@ class AudioEncoder::ImplBase {
const base::Closure& done_callback) {
int src_pos = 0;
while (audio_bus && src_pos < audio_bus->frames()) {
const int num_samples_to_xfer =
std::min(samples_per_10ms_ - buffer_fill_end_,
audio_bus->frames() - src_pos);
const int num_samples_to_xfer = std::min(
samples_per_10ms_ - buffer_fill_end_, audio_bus->frames() - src_pos);
DCHECK_EQ(audio_bus->channels(), num_channels_);
TransferSamplesIntoBuffer(
audio_bus, src_pos, buffer_fill_end_, num_samples_to_xfer);
......@@ -84,8 +88,8 @@ class AudioEncoder::ImplBase {
buffer_fill_end_ += num_samples_to_xfer;
if (src_pos == audio_bus->frames()) {
cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
done_callback);
cast_environment_->PostTask(
CastEnvironment::MAIN, FROM_HERE, done_callback);
// Note: |audio_bus| is invalid once done_callback is invoked.
audio_bus = NULL;
}
......@@ -105,8 +109,10 @@ class AudioEncoder::ImplBase {
// TODO(miu): Consider batching EncodedAudioFrames so we only post a
// at most one task for each call to this method.
cast_environment_->PostTask(
CastEnvironment::MAIN, FROM_HERE,
base::Bind(callback_, base::Passed(&audio_frame),
CastEnvironment::MAIN,
FROM_HERE,
base::Bind(callback_,
base::Passed(&audio_frame),
recorded_time - buffer_time_offset));
}
buffer_fill_end_ = 0;
......@@ -144,10 +150,15 @@ class AudioEncoder::ImplBase {
class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
public:
OpusImpl(CastEnvironment* cast_environment,
int num_channels, int sampling_rate, int bitrate,
int num_channels,
int sampling_rate,
int bitrate,
const FrameEncodedCallback& callback)
: ImplBase(cast_environment, transport::kOpus, num_channels,
sampling_rate, callback),
: ImplBase(cast_environment,
transport::kOpus,
num_channels,
sampling_rate,
callback),
encoder_memory_(new uint8[opus_encoder_get_size(num_channels)]),
opus_encoder_(reinterpret_cast<OpusEncoder*>(encoder_memory_.get())),
buffer_(new float[num_channels * samples_per_10ms_]) {
......@@ -155,9 +166,10 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
return;
}
CHECK_EQ(opus_encoder_init(opus_encoder_, sampling_rate, num_channels,
OPUS_APPLICATION_AUDIO),
OPUS_OK);
CHECK_EQ(
opus_encoder_init(
opus_encoder_, sampling_rate, num_channels, OPUS_APPLICATION_AUDIO),
OPUS_OK);
if (bitrate <= 0) {
// Note: As of 2013-10-31, the encoder in "auto bitrate" mode would use a
// variable bitrate up to 102kbps for 2-channel, 48 kHz audio and a 10 ms
......@@ -188,9 +200,12 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
virtual bool EncodeFromFilledBuffer(std::string* out) OVERRIDE {
out->resize(kOpusMaxPayloadSize);
const opus_int32 result = opus_encode_float(
opus_encoder_, buffer_.get(), samples_per_10ms_,
reinterpret_cast<uint8*>(&out->at(0)), kOpusMaxPayloadSize);
const opus_int32 result =
opus_encode_float(opus_encoder_,
buffer_.get(),
samples_per_10ms_,
reinterpret_cast<uint8*>(&out->at(0)),
kOpusMaxPayloadSize);
if (result > 1) {
out->resize(result);
return true;
......@@ -222,10 +237,14 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase {
public:
Pcm16Impl(CastEnvironment* cast_environment,
int num_channels, int sampling_rate,
int num_channels,
int sampling_rate,
const FrameEncodedCallback& callback)
: ImplBase(cast_environment, transport::kPcm16, num_channels,
sampling_rate, callback),
: ImplBase(cast_environment,
transport::kPcm16,
num_channels,
sampling_rate,
callback),
buffer_(new int16[num_channels * samples_per_10ms_]) {}
virtual ~Pcm16Impl() {}
......@@ -236,7 +255,9 @@ class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase {
int buffer_fill_offset,
int num_samples) OVERRIDE {
audio_bus->ToInterleavedPartial(
source_offset, num_samples, sizeof(int16),
source_offset,
num_samples,
sizeof(int16),
buffer_.get() + buffer_fill_offset * num_channels_);
}
......@@ -268,14 +289,17 @@ AudioEncoder::AudioEncoder(
switch (audio_config.codec) {
case transport::kOpus:
impl_.reset(new OpusImpl(
cast_environment, audio_config.channels, audio_config.frequency,
audio_config.bitrate, frame_encoded_callback));
impl_.reset(new OpusImpl(cast_environment,
audio_config.channels,
audio_config.frequency,
audio_config.bitrate,
frame_encoded_callback));
break;
case transport::kPcm16:
impl_.reset(new Pcm16Impl(
cast_environment, audio_config.channels, audio_config.frequency,
frame_encoded_callback));
impl_.reset(new Pcm16Impl(cast_environment,
audio_config.channels,
audio_config.frequency,
frame_encoded_callback));
break;
default:
NOTREACHED() << "Unsupported or unspecified codec for audio encoder";
......@@ -292,29 +316,33 @@ CastInitializationStatus AudioEncoder::InitializationResult() const {
return STATUS_UNSUPPORTED_AUDIO_CODEC;
}
void AudioEncoder::InsertAudio(
const AudioBus* audio_bus,
const base::TimeTicks& recorded_time,
const base::Closure& done_callback) {
void AudioEncoder::InsertAudio(const AudioBus* audio_bus,
const base::TimeTicks& recorded_time,
const base::Closure& done_callback) {
DCHECK(insert_thread_checker_.CalledOnValidThread());
if (!impl_) {
NOTREACHED();
cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
done_callback);
cast_environment_->PostTask(
CastEnvironment::MAIN, FROM_HERE, done_callback);
return;
}
cast_environment_->PostTask(CastEnvironment::AUDIO_ENCODER, FROM_HERE,
base::Bind(&AudioEncoder::EncodeAudio, this, audio_bus, recorded_time,
done_callback));
cast_environment_->PostTask(CastEnvironment::AUDIO_ENCODER,
FROM_HERE,
base::Bind(&AudioEncoder::EncodeAudio,
this,
audio_bus,
recorded_time,
done_callback));
}
void AudioEncoder::EncodeAudio(
const AudioBus* audio_bus,
const base::TimeTicks& recorded_time,
const base::Closure& done_callback) {
void AudioEncoder::EncodeAudio(const AudioBus* audio_bus,
const base::TimeTicks& recorded_time,
const base::Closure& done_callback) {
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::AUDIO_ENCODER));
impl_->EncodeAudio(audio_bus, recorded_time, done_callback);
cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
cast_environment_->PostTask(
CastEnvironment::MAIN,
FROM_HERE,
base::Bind(LogAudioEncodedEvent, cast_environment_, recorded_time));
}
......
media/cast/audio_sender/audio_sender.cc
View file @ 82439ec2
......@@ -18,11 +18,10 @@ const int64 kMinSchedulingDelayMs = 1;
class LocalRtcpAudioSenderFeedback : public RtcpSenderFeedback {
public:
explicit LocalRtcpAudioSenderFeedback(AudioSender* audio_sender)
: audio_sender_(audio_sender) {
}
: audio_sender_(audio_sender) {}
virtual void OnReceivedCastFeedback(
const RtcpCastMessage& cast_feedback) OVERRIDE {
virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback)
OVERRIDE {
if (!cast_feedback.missing_frames_and_packets_.empty()) {
audio_sender_->ResendPackets(cast_feedback.missing_frames_and_packets_);
}
......@@ -38,8 +37,7 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics {
public:
explicit LocalRtpSenderStatistics(
transport::CastTransportSender* const transport_sender)
: transport_sender_(transport_sender) {
}
: transport_sender_(transport_sender) {}
virtual void GetStatistics(const base::TimeTicks& now,
transport::RtcpSenderInfo* sender_info) OVERRIDE {
......@@ -53,34 +51,34 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics {
};
// TODO(mikhal): Reduce heap allocation when not needed.
AudioSender::AudioSender(
scoped_refptr<CastEnvironment> cast_environment,
const AudioSenderConfig& audio_config,
transport::CastTransportSender* const transport_sender)
: cast_environment_(cast_environment),
transport_sender_(transport_sender),
rtcp_feedback_(new LocalRtcpAudioSenderFeedback(this)),
rtp_audio_sender_statistics_(
new LocalRtpSenderStatistics(transport_sender_)),
rtcp_(cast_environment,
rtcp_feedback_.get(),
transport_sender_,
NULL, // paced sender.
rtp_audio_sender_statistics_.get(),
NULL,
audio_config.rtcp_mode,
base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
audio_config.sender_ssrc,
audio_config.incoming_feedback_ssrc,
audio_config.rtcp_c_name),
timers_initialized_(false),
initialization_status_(STATUS_INITIALIZED),
weak_factory_(this) {
AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
const AudioSenderConfig& audio_config,
transport::CastTransportSender* const transport_sender)
: cast_environment_(cast_environment),
transport_sender_(transport_sender),
rtcp_feedback_(new LocalRtcpAudioSenderFeedback(this)),
rtp_audio_sender_statistics_(
new LocalRtpSenderStatistics(transport_sender_)),
rtcp_(cast_environment,
rtcp_feedback_.get(),
transport_sender_,
NULL, // paced sender.
rtp_audio_sender_statistics_.get(),
NULL,
audio_config.rtcp_mode,
base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
audio_config.sender_ssrc,
audio_config.incoming_feedback_ssrc,
audio_config.rtcp_c_name),
timers_initialized_(false),
initialization_status_(STATUS_INITIALIZED),
weak_factory_(this) {
if (!audio_config.use_external_encoder) {
audio_encoder_ = new AudioEncoder(
cast_environment, audio_config,
base::Bind(&AudioSender::SendEncodedAudioFrame,
weak_factory_.GetWeakPtr()));
audio_encoder_ =
new AudioEncoder(cast_environment,
audio_config,
base::Bind(&AudioSender::SendEncodedAudioFrame,
weak_factory_.GetWeakPtr()));
initialization_status_ = audio_encoder_->InitializationResult();
}
}
......@@ -103,8 +101,11 @@ void AudioSender::InsertAudio(const AudioBus* audio_bus,
// TODO(mikhal): Resolve calculation of the audio rtp_timestamp for logging.
// This is a tmp solution to allow the code to build.
base::TimeTicks now = cast_environment_->Clock()->NowTicks();
cast_environment_->Logging()->InsertFrameEvent(now, kAudioFrameReceived,
GetVideoRtpTimestamp(recorded_time), kFrameIdUnknown);
cast_environment_->Logging()->InsertFrameEvent(
now,
kAudioFrameReceived,
GetVideoRtpTimestamp(recorded_time),
kFrameIdUnknown);
audio_encoder_->InsertAudio(audio_bus, recorded_time, done_callback);
}
......@@ -114,9 +115,11 @@ void AudioSender::SendEncodedAudioFrame(
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
InitializeTimers();
cast_environment_->PostTask(
CastEnvironment::TRANSPORT, FROM_HERE,
CastEnvironment::TRANSPORT,
FROM_HERE,
base::Bind(&AudioSender::SendEncodedAudioFrameToTransport,
base::Unretained(this), base::Passed(&audio_frame),
base::Unretained(this),
base::Passed(&audio_frame),
recorded_time));
}
......@@ -131,9 +134,11 @@ void AudioSender::ResendPackets(
const MissingFramesAndPacketsMap& missing_frames_and_packets) {
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
cast_environment_->PostTask(
CastEnvironment::TRANSPORT, FROM_HERE,
CastEnvironment::TRANSPORT,
FROM_HERE,
base::Bind(&AudioSender::ResendPacketsOnTransportThread,
base::Unretained(this), missing_frames_and_packets));
base::Unretained(this),
missing_frames_and_packets));
}
void AudioSender::IncomingRtcpPacket(scoped_ptr<Packet> packet) {
......@@ -146,13 +151,14 @@ void AudioSender::ScheduleNextRtcpReport() {
base::TimeDelta time_to_next =
rtcp_.TimeToSendNextRtcpReport() - cast_environment_->Clock()->NowTicks();
time_to_next = std::max(time_to_next,
base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
time_to_next = std::max(
time_to_next, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
cast_environment_->PostDelayedTask(
CastEnvironment::MAIN, FROM_HERE,
CastEnvironment::MAIN,
FROM_HERE,
base::Bind(&AudioSender::SendRtcpReport, weak_factory_.GetWeakPtr()),
time_to_next);
time_to_next);
}
void AudioSender::SendRtcpReport() {
......
media/cast/audio_sender/audio_sender_unittest.cc
View file @ 82439ec2
......@@ -28,9 +28,7 @@ using testing::Exactly;
class TestPacketSender : public transport::PacketSender {
public:
TestPacketSender()
: number_of_rtp_packets_(0),
number_of_rtcp_packets_(0) {}
TestPacketSender() : number_of_rtp_packets_(0), number_of_rtcp_packets_(0) {}
virtual bool SendPacket(const Packet& packet) OVERRIDE {
if (Rtcp::IsRtcpPacket(&packet[0], packet.size())) {
......@@ -41,13 +39,9 @@ class TestPacketSender : public transport::PacketSender {
return true;
}
int number_of_rtp_packets() const {
return number_of_rtp_packets_;
}
int number_of_rtp_packets() const { return number_of_rtp_packets_; }
int number_of_rtcp_packets() const {
return number_of_rtcp_packets_;
}
int number_of_rtcp_packets() const { return number_of_rtcp_packets_; }
private:
int number_of_rtp_packets_;
......@@ -67,10 +61,15 @@ class AudioSenderTest : public ::testing::Test {
testing_clock_->Advance(
base::TimeDelta::FromMilliseconds(kStartMillisecond));
task_runner_ = new test::FakeTaskRunner(testing_clock_);
cast_environment_ = new CastEnvironment(
scoped_ptr<base::TickClock>(testing_clock_).Pass(),
task_runner_, task_runner_, task_runner_, task_runner_,
task_runner_, task_runner_, GetDefaultCastSenderLoggingConfig());
cast_environment_ =
new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(),
task_runner_,
task_runner_,
task_runner_,
task_runner_,
task_runner_,
task_runner_,
GetDefaultCastSenderLoggingConfig());
audio_config_.codec = transport::kOpus;
audio_config_.use_external_encoder = false;
audio_config_.frequency = kDefaultAudioSamplingRate;
......@@ -84,7 +83,8 @@ class AudioSenderTest : public ::testing::Test {
transport_sender_.reset(new transport::CastTransportSenderImpl(
testing_clock_,
transport_config,
base::Bind(&UpdateCastTransportStatus), task_runner_));
base::Bind(&UpdateCastTransportStatus),
task_runner_));
transport_sender_->InsertFakeTransportForTesting(&transport_);
audio_sender_.reset(new AudioSender(
cast_environment_, audio_config_, transport_sender_.get()));
......@@ -110,36 +110,38 @@ TEST_F(AudioSenderTest, Encode20ms) {
EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1));
const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
scoped_ptr<AudioBus> bus(TestAudioBusFactory(
audio_config_.channels, audio_config_.frequency,
TestAudioBusFactory::kMiddleANoteFreq, 0.5f).NextAudioBus(kDuration));
scoped_ptr<AudioBus> bus(
TestAudioBusFactory(audio_config_.channels,
audio_config_.frequency,
TestAudioBusFactory::kMiddleANoteFreq,
0.5f).NextAudioBus(kDuration));
base::TimeTicks recorded_time = base::TimeTicks::Now();
audio_sender_->InsertAudio(
bus.get(),
recorded_time,
base::Bind(
&AudioSenderTest::InsertAudioCallback,
base::Unretained(this)));
audio_sender_->InsertAudio(bus.get(),
recorded_time,
base::Bind(&AudioSenderTest::InsertAudioCallback,
base::Unretained(this)));
task_runner_->RunTasks();
EXPECT_GE(transport_.number_of_rtp_packets() +
transport_.number_of_rtcp_packets(), 1);
EXPECT_GE(
transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets(),
1);
}
TEST_F(AudioSenderTest, RtcpTimer) {
EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1));
const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
scoped_ptr<AudioBus> bus(TestAudioBusFactory(
audio_config_.channels, audio_config_.frequency,
TestAudioBusFactory::kMiddleANoteFreq, 0.5f).NextAudioBus(kDuration));
scoped_ptr<AudioBus> bus(
TestAudioBusFactory(audio_config_.channels,
audio_config_.frequency,
TestAudioBusFactory::kMiddleANoteFreq,
0.5f).NextAudioBus(kDuration));
base::TimeTicks recorded_time = base::TimeTicks::Now();
audio_sender_->InsertAudio(
bus.get(), recorded_time,
base::Bind(
&AudioSenderTest::InsertAudioCallback,
base::Unretained(this)));
audio_sender_->InsertAudio(bus.get(),
recorded_time,
base::Bind(&AudioSenderTest::InsertAudioCallback,
base::Unretained(this)));
task_runner_->RunTasks();
// Make sure that we send at least one RTCP packet.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment