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
Show 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, ...@@ -25,8 +25,11 @@ void LogAudioEncodedEvent(CastEnvironment* const cast_environment,
// TODO(mikhal): Resolve timestamp calculation for audio. // TODO(mikhal): Resolve timestamp calculation for audio.
base::TimeTicks now = cast_environment->Clock()->NowTicks(); base::TimeTicks now = cast_environment->Clock()->NowTicks();
cast_environment->Logging()->InsertFrameEvent(now, kAudioFrameEncoded, cast_environment->Logging()->InsertFrameEvent(
GetVideoRtpTimestamp(recorded_time), kFrameIdUnknown); now,
kAudioFrameEncoded,
GetVideoRtpTimestamp(recorded_time),
kFrameIdUnknown);
} }
// Base class that handles the common problem of feeding one or more AudioBus' // Base class that handles the common problem of feeding one or more AudioBus'
...@@ -38,10 +41,13 @@ void LogAudioEncodedEvent(CastEnvironment* const cast_environment, ...@@ -38,10 +41,13 @@ void LogAudioEncodedEvent(CastEnvironment* const cast_environment,
class AudioEncoder::ImplBase { class AudioEncoder::ImplBase {
public: public:
ImplBase(CastEnvironment* cast_environment, 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) const FrameEncodedCallback& callback)
: cast_environment_(cast_environment), : cast_environment_(cast_environment),
codec_(codec), num_channels_(num_channels), codec_(codec),
num_channels_(num_channels),
samples_per_10ms_(sampling_rate / 100), samples_per_10ms_(sampling_rate / 100),
callback_(callback), callback_(callback),
buffer_fill_end_(0), buffer_fill_end_(0),
...@@ -52,8 +58,7 @@ class AudioEncoder::ImplBase { ...@@ -52,8 +58,7 @@ class AudioEncoder::ImplBase {
DCHECK_LE(samples_per_10ms_ * num_channels_, DCHECK_LE(samples_per_10ms_ * num_channels_,
transport::EncodedAudioFrame::kMaxNumberOfSamples); transport::EncodedAudioFrame::kMaxNumberOfSamples);
if (num_channels_ <= 0 || if (num_channels_ <= 0 || samples_per_10ms_ <= 0 ||
samples_per_10ms_ <= 0 ||
sampling_rate % 100 != 0 || sampling_rate % 100 != 0 ||
samples_per_10ms_ * num_channels_ > samples_per_10ms_ * num_channels_ >
transport::EncodedAudioFrame::kMaxNumberOfSamples) { transport::EncodedAudioFrame::kMaxNumberOfSamples) {
...@@ -74,9 +79,8 @@ class AudioEncoder::ImplBase { ...@@ -74,9 +79,8 @@ class AudioEncoder::ImplBase {
const base::Closure& done_callback) { const base::Closure& done_callback) {
int src_pos = 0; int src_pos = 0;
while (audio_bus && src_pos < audio_bus->frames()) { while (audio_bus && src_pos < audio_bus->frames()) {
const int num_samples_to_xfer = const int num_samples_to_xfer = std::min(
std::min(samples_per_10ms_ - buffer_fill_end_, samples_per_10ms_ - buffer_fill_end_, audio_bus->frames() - src_pos);
audio_bus->frames() - src_pos);
DCHECK_EQ(audio_bus->channels(), num_channels_); DCHECK_EQ(audio_bus->channels(), num_channels_);
TransferSamplesIntoBuffer( TransferSamplesIntoBuffer(
audio_bus, src_pos, buffer_fill_end_, num_samples_to_xfer); audio_bus, src_pos, buffer_fill_end_, num_samples_to_xfer);
...@@ -84,8 +88,8 @@ class AudioEncoder::ImplBase { ...@@ -84,8 +88,8 @@ class AudioEncoder::ImplBase {
buffer_fill_end_ += num_samples_to_xfer; buffer_fill_end_ += num_samples_to_xfer;
if (src_pos == audio_bus->frames()) { if (src_pos == audio_bus->frames()) {
cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, cast_environment_->PostTask(
done_callback); CastEnvironment::MAIN, FROM_HERE, done_callback);
// Note: |audio_bus| is invalid once done_callback is invoked. // Note: |audio_bus| is invalid once done_callback is invoked.
audio_bus = NULL; audio_bus = NULL;
} }
...@@ -105,8 +109,10 @@ class AudioEncoder::ImplBase { ...@@ -105,8 +109,10 @@ class AudioEncoder::ImplBase {
// TODO(miu): Consider batching EncodedAudioFrames so we only post a // TODO(miu): Consider batching EncodedAudioFrames so we only post a
// at most one task for each call to this method. // at most one task for each call to this method.
cast_environment_->PostTask( cast_environment_->PostTask(
CastEnvironment::MAIN, FROM_HERE, CastEnvironment::MAIN,
base::Bind(callback_, base::Passed(&audio_frame), FROM_HERE,
base::Bind(callback_,
base::Passed(&audio_frame),
recorded_time - buffer_time_offset)); recorded_time - buffer_time_offset));
} }
buffer_fill_end_ = 0; buffer_fill_end_ = 0;
...@@ -144,10 +150,15 @@ class AudioEncoder::ImplBase { ...@@ -144,10 +150,15 @@ class AudioEncoder::ImplBase {
class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase { class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
public: public:
OpusImpl(CastEnvironment* cast_environment, OpusImpl(CastEnvironment* cast_environment,
int num_channels, int sampling_rate, int bitrate, int num_channels,
int sampling_rate,
int bitrate,
const FrameEncodedCallback& callback) const FrameEncodedCallback& callback)
: ImplBase(cast_environment, transport::kOpus, num_channels, : ImplBase(cast_environment,
sampling_rate, callback), transport::kOpus,
num_channels,
sampling_rate,
callback),
encoder_memory_(new uint8[opus_encoder_get_size(num_channels)]), encoder_memory_(new uint8[opus_encoder_get_size(num_channels)]),
opus_encoder_(reinterpret_cast<OpusEncoder*>(encoder_memory_.get())), opus_encoder_(reinterpret_cast<OpusEncoder*>(encoder_memory_.get())),
buffer_(new float[num_channels * samples_per_10ms_]) { buffer_(new float[num_channels * samples_per_10ms_]) {
...@@ -155,8 +166,9 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase { ...@@ -155,8 +166,9 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
return; return;
} }
CHECK_EQ(opus_encoder_init(opus_encoder_, sampling_rate, num_channels, CHECK_EQ(
OPUS_APPLICATION_AUDIO), opus_encoder_init(
opus_encoder_, sampling_rate, num_channels, OPUS_APPLICATION_AUDIO),
OPUS_OK); OPUS_OK);
if (bitrate <= 0) { if (bitrate <= 0) {
// Note: As of 2013-10-31, the encoder in "auto bitrate" mode would use a // Note: As of 2013-10-31, the encoder in "auto bitrate" mode would use a
...@@ -188,9 +200,12 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase { ...@@ -188,9 +200,12 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
virtual bool EncodeFromFilledBuffer(std::string* out) OVERRIDE { virtual bool EncodeFromFilledBuffer(std::string* out) OVERRIDE {
out->resize(kOpusMaxPayloadSize); out->resize(kOpusMaxPayloadSize);
const opus_int32 result = opus_encode_float( const opus_int32 result =
opus_encoder_, buffer_.get(), samples_per_10ms_, opus_encode_float(opus_encoder_,
reinterpret_cast<uint8*>(&out->at(0)), kOpusMaxPayloadSize); buffer_.get(),
samples_per_10ms_,
reinterpret_cast<uint8*>(&out->at(0)),
kOpusMaxPayloadSize);
if (result > 1) { if (result > 1) {
out->resize(result); out->resize(result);
return true; return true;
...@@ -222,10 +237,14 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase { ...@@ -222,10 +237,14 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase { class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase {
public: public:
Pcm16Impl(CastEnvironment* cast_environment, Pcm16Impl(CastEnvironment* cast_environment,
int num_channels, int sampling_rate, int num_channels,
int sampling_rate,
const FrameEncodedCallback& callback) const FrameEncodedCallback& callback)
: ImplBase(cast_environment, transport::kPcm16, num_channels, : ImplBase(cast_environment,
sampling_rate, callback), transport::kPcm16,
num_channels,
sampling_rate,
callback),
buffer_(new int16[num_channels * samples_per_10ms_]) {} buffer_(new int16[num_channels * samples_per_10ms_]) {}
virtual ~Pcm16Impl() {} virtual ~Pcm16Impl() {}
...@@ -236,7 +255,9 @@ class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase { ...@@ -236,7 +255,9 @@ class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase {
int buffer_fill_offset, int buffer_fill_offset,
int num_samples) OVERRIDE { int num_samples) OVERRIDE {
audio_bus->ToInterleavedPartial( audio_bus->ToInterleavedPartial(
source_offset, num_samples, sizeof(int16), source_offset,
num_samples,
sizeof(int16),
buffer_.get() + buffer_fill_offset * num_channels_); buffer_.get() + buffer_fill_offset * num_channels_);
} }
...@@ -268,13 +289,16 @@ AudioEncoder::AudioEncoder( ...@@ -268,13 +289,16 @@ AudioEncoder::AudioEncoder(
switch (audio_config.codec) { switch (audio_config.codec) {
case transport::kOpus: case transport::kOpus:
impl_.reset(new OpusImpl( impl_.reset(new OpusImpl(cast_environment,
cast_environment, audio_config.channels, audio_config.frequency, audio_config.channels,
audio_config.bitrate, frame_encoded_callback)); audio_config.frequency,
audio_config.bitrate,
frame_encoded_callback));
break; break;
case transport::kPcm16: case transport::kPcm16:
impl_.reset(new Pcm16Impl( impl_.reset(new Pcm16Impl(cast_environment,
cast_environment, audio_config.channels, audio_config.frequency, audio_config.channels,
audio_config.frequency,
frame_encoded_callback)); frame_encoded_callback));
break; break;
default: default:
...@@ -292,29 +316,33 @@ CastInitializationStatus AudioEncoder::InitializationResult() const { ...@@ -292,29 +316,33 @@ CastInitializationStatus AudioEncoder::InitializationResult() const {
return STATUS_UNSUPPORTED_AUDIO_CODEC; return STATUS_UNSUPPORTED_AUDIO_CODEC;
} }
void AudioEncoder::InsertAudio( void AudioEncoder::InsertAudio(const AudioBus* audio_bus,
const AudioBus* audio_bus,
const base::TimeTicks& recorded_time, const base::TimeTicks& recorded_time,
const base::Closure& done_callback) { const base::Closure& done_callback) {
DCHECK(insert_thread_checker_.CalledOnValidThread()); DCHECK(insert_thread_checker_.CalledOnValidThread());
if (!impl_) { if (!impl_) {
NOTREACHED(); NOTREACHED();
cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, cast_environment_->PostTask(
done_callback); CastEnvironment::MAIN, FROM_HERE, done_callback);
return; return;
} }
cast_environment_->PostTask(CastEnvironment::AUDIO_ENCODER, FROM_HERE, cast_environment_->PostTask(CastEnvironment::AUDIO_ENCODER,
base::Bind(&AudioEncoder::EncodeAudio, this, audio_bus, recorded_time, FROM_HERE,
base::Bind(&AudioEncoder::EncodeAudio,
this,
audio_bus,
recorded_time,
done_callback)); done_callback));
} }
void AudioEncoder::EncodeAudio( void AudioEncoder::EncodeAudio(const AudioBus* audio_bus,
const AudioBus* audio_bus,
const base::TimeTicks& recorded_time, const base::TimeTicks& recorded_time,
const base::Closure& done_callback) { const base::Closure& done_callback) {
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::AUDIO_ENCODER)); DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::AUDIO_ENCODER));
impl_->EncodeAudio(audio_bus, recorded_time, done_callback); 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)); base::Bind(LogAudioEncodedEvent, cast_environment_, recorded_time));
} }
......
media/cast/audio_sender/audio_encoder_unittest.cc
View file @ 82439ec2
...@@ -26,21 +26,15 @@ namespace { ...@@ -26,21 +26,15 @@ namespace {
class TestEncodedAudioFrameReceiver { class TestEncodedAudioFrameReceiver {
public: public:
explicit TestEncodedAudioFrameReceiver(transport::AudioCodec codec) : explicit TestEncodedAudioFrameReceiver(transport::AudioCodec codec)
codec_(codec), frames_received_(0) {} : codec_(codec), frames_received_(0) {}
virtual ~TestEncodedAudioFrameReceiver() {} virtual ~TestEncodedAudioFrameReceiver() {}
int frames_received() const { int frames_received() const { return frames_received_; }
return frames_received_;
}
void SetRecordedTimeLowerBound(const base::TimeTicks& t) { void SetRecordedTimeLowerBound(const base::TimeTicks& t) { lower_bound_ = t; }
lower_bound_ = t;
}
void SetRecordedTimeUpperBound(const base::TimeTicks& t) { void SetRecordedTimeUpperBound(const base::TimeTicks& t) { upper_bound_ = t; }
upper_bound_ = t;
}
void FrameEncoded(scoped_ptr<transport::EncodedAudioFrame> encoded_frame, void FrameEncoded(scoped_ptr<transport::EncodedAudioFrame> encoded_frame,
const base::TimeTicks& recorded_time) { const base::TimeTicks& recorded_time) {
...@@ -97,9 +91,14 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> { ...@@ -97,9 +91,14 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
virtual void SetUp() { virtual void SetUp() {
task_runner_ = new test::FakeTaskRunner(testing_clock_); task_runner_ = new test::FakeTaskRunner(testing_clock_);
cast_environment_ = new CastEnvironment( cast_environment_ =
scoped_ptr<base::TickClock>(testing_clock_).Pass(), task_runner_, new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(),
task_runner_, task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
task_runner_,
task_runner_,
task_runner_,
task_runner_,
task_runner_,
GetDefaultCastSenderLoggingConfig()); GetDefaultCastSenderLoggingConfig());
} }
...@@ -107,8 +106,7 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> { ...@@ -107,8 +106,7 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
void RunTestForCodec(transport::AudioCodec codec) { void RunTestForCodec(transport::AudioCodec codec) {
const TestScenario& scenario = GetParam(); const TestScenario& scenario = GetParam();
SCOPED_TRACE(::testing::Message() SCOPED_TRACE(::testing::Message() << "Durations: " << scenario.ToString());
<< "Durations: " << scenario.ToString());
CreateObjectsForCodec(codec); CreateObjectsForCodec(codec);
...@@ -116,15 +114,16 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> { ...@@ -116,15 +114,16 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
for (size_t i = 0; i < scenario.num_durations; ++i) { for (size_t i = 0; i < scenario.num_durations; ++i) {
const base::TimeDelta duration = const base::TimeDelta duration =
base::TimeDelta::FromMilliseconds(scenario.durations_in_ms[i]); base::TimeDelta::FromMilliseconds(scenario.durations_in_ms[i]);
receiver_->SetRecordedTimeUpperBound( receiver_->SetRecordedTimeUpperBound(testing_clock_->NowTicks() +
testing_clock_->NowTicks() + duration); duration);
const scoped_ptr<AudioBus> bus( const scoped_ptr<AudioBus> bus(
audio_bus_factory_->NextAudioBus(duration)); audio_bus_factory_->NextAudioBus(duration));
const int last_count = release_callback_count_; const int last_count = release_callback_count_;
audio_encoder_->InsertAudio( audio_encoder_->InsertAudio(
bus.get(), testing_clock_->NowTicks(), bus.get(),
testing_clock_->NowTicks(),
base::Bind(&AudioEncoderTest::IncrementReleaseCallbackCounter, base::Bind(&AudioEncoderTest::IncrementReleaseCallbackCounter,
base::Unretained(this))); base::Unretained(this)));
task_runner_->RunTasks(); task_runner_->RunTasks();
...@@ -148,22 +147,23 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> { ...@@ -148,22 +147,23 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
audio_config.bitrate = kDefaultAudioEncoderBitrate; audio_config.bitrate = kDefaultAudioEncoderBitrate;
audio_config.rtp_payload_type = 127; audio_config.rtp_payload_type = 127;
audio_bus_factory_.reset(new TestAudioBusFactory( audio_bus_factory_.reset(
audio_config.channels, audio_config.frequency, new TestAudioBusFactory(audio_config.channels,
TestAudioBusFactory::kMiddleANoteFreq, 0.5f)); audio_config.frequency,
TestAudioBusFactory::kMiddleANoteFreq,
0.5f));
receiver_.reset(new TestEncodedAudioFrameReceiver(codec)); receiver_.reset(new TestEncodedAudioFrameReceiver(codec));
audio_encoder_ = new AudioEncoder( audio_encoder_ = new AudioEncoder(
cast_environment_, audio_config, cast_environment_,
audio_config,
base::Bind(&TestEncodedAudioFrameReceiver::FrameEncoded, base::Bind(&TestEncodedAudioFrameReceiver::FrameEncoded,
base::Unretained(receiver_.get()))); base::Unretained(receiver_.get())));
release_callback_count_ = 0; release_callback_count_ = 0;
} }
void IncrementReleaseCallbackCounter() { void IncrementReleaseCallbackCounter() { ++release_callback_count_; }
++release_callback_count_;
}
base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment.
scoped_refptr<test::FakeTaskRunner> task_runner_; scoped_refptr<test::FakeTaskRunner> task_runner_;
...@@ -176,43 +176,40 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> { ...@@ -176,43 +176,40 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
DISALLOW_COPY_AND_ASSIGN(AudioEncoderTest); DISALLOW_COPY_AND_ASSIGN(AudioEncoderTest);
}; };
TEST_P(AudioEncoderTest, EncodeOpus) { TEST_P(AudioEncoderTest, EncodeOpus) { RunTestForCodec(transport::kOpus); }
RunTestForCodec(transport::kOpus);
} TEST_P(AudioEncoderTest, EncodePcm16) { RunTestForCodec(transport::kPcm16); }
TEST_P(AudioEncoderTest, EncodePcm16) { static const int64 kOneCall_3Millis[] = {3};
RunTestForCodec(transport::kPcm16); static const int64 kOneCall_10Millis[] = {10};
} static const int64 kOneCall_13Millis[] = {13};
static const int64 kOneCall_20Millis[] = {20};
static const int64 kOneCall_3Millis[] = { 3 };
static const int64 kOneCall_10Millis[] = { 10 }; static const int64 kTwoCalls_3Millis[] = {3, 3};
static const int64 kOneCall_13Millis[] = { 13 }; static const int64 kTwoCalls_10Millis[] = {10, 10};
static const int64 kOneCall_20Millis[] = { 20 }; static const int64 kTwoCalls_Mixed1[] = {3, 10};
static const int64 kTwoCalls_Mixed2[] = {10, 3};
static const int64 kTwoCalls_3Millis[] = { 3, 3 }; static const int64 kTwoCalls_Mixed3[] = {3, 17};
static const int64 kTwoCalls_10Millis[] = { 10, 10 }; static const int64 kTwoCalls_Mixed4[] = {17, 3};
static const int64 kTwoCalls_Mixed1[] = { 3, 10 };
static const int64 kTwoCalls_Mixed2[] = { 10, 3 }; static const int64 kManyCalls_3Millis[] = {3, 3, 3, 3, 3, 3, 3, 3,
static const int64 kTwoCalls_Mixed3[] = { 3, 17 }; 3, 3, 3, 3, 3, 3, 3};
static const int64 kTwoCalls_Mixed4[] = { 17, 3 }; static const int64 kManyCalls_10Millis[] = {10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10};
static const int64 kManyCalls_3Millis[] = static const int64 kManyCalls_Mixed1[] = {3, 10, 3, 10, 3, 10, 3, 10, 3,
{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; 10, 3, 10, 3, 10, 3, 10, 3, 10};
static const int64 kManyCalls_10Millis[] = static const int64 kManyCalls_Mixed2[] = {10, 3, 10, 3, 10, 3, 10, 3, 10, 3,
{ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 }; 10, 3, 10, 3, 10, 3, 10, 3, 10, 3};
static const int64 kManyCalls_Mixed1[] = static const int64 kManyCalls_Mixed3[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8,
{ 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10 }; 9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6, 4};
static const int64 kManyCalls_Mixed2[] = static const int64 kManyCalls_Mixed4[] = {31, 4, 15, 9, 26, 53, 5, 8, 9,
{ 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3 }; 7, 9, 32, 38, 4, 62, 64, 3};
static const int64 kManyCalls_Mixed3[] = static const int64 kManyCalls_Mixed5[] = {3, 14, 15, 9, 26, 53, 58, 9, 7,
{ 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6, 4 }; 9, 3, 23, 8, 4, 6, 2, 6, 43};
static const int64 kManyCalls_Mixed4[] =
{ 31, 4, 15, 9, 26, 53, 5, 8, 9, 7, 9, 32, 38, 4, 62, 64, 3 };
static const int64 kManyCalls_Mixed5[] =
{ 3, 14, 15, 9, 26, 53, 58, 9, 7, 9, 3, 23, 8, 4, 6, 2, 6, 43 };
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
AudioEncoderTestScenarios, AudioEncoderTest, AudioEncoderTestScenarios,
AudioEncoderTest,
::testing::Values( ::testing::Values(
TestScenario(kOneCall_3Millis, arraysize(kOneCall_3Millis)), TestScenario(kOneCall_3Millis, arraysize(kOneCall_3Millis)),
TestScenario(kOneCall_10Millis, arraysize(kOneCall_10Millis)), TestScenario(kOneCall_10Millis, arraysize(kOneCall_10Millis)),
......
media/cast/audio_sender/audio_sender.cc
View file @ 82439ec2
...@@ -18,11 +18,10 @@ const int64 kMinSchedulingDelayMs = 1; ...@@ -18,11 +18,10 @@ const int64 kMinSchedulingDelayMs = 1;
class LocalRtcpAudioSenderFeedback : public RtcpSenderFeedback { class LocalRtcpAudioSenderFeedback : public RtcpSenderFeedback {
public: public:
explicit LocalRtcpAudioSenderFeedback(AudioSender* audio_sender) explicit LocalRtcpAudioSenderFeedback(AudioSender* audio_sender)
: audio_sender_(audio_sender) { : audio_sender_(audio_sender) {}
}
virtual void OnReceivedCastFeedback( virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback)
const RtcpCastMessage& cast_feedback) OVERRIDE { OVERRIDE {
if (!cast_feedback.missing_frames_and_packets_.empty()) { if (!cast_feedback.missing_frames_and_packets_.empty()) {
audio_sender_->ResendPackets(cast_feedback.missing_frames_and_packets_); audio_sender_->ResendPackets(cast_feedback.missing_frames_and_packets_);
} }
...@@ -38,8 +37,7 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics { ...@@ -38,8 +37,7 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics {
public: public:
explicit LocalRtpSenderStatistics( explicit LocalRtpSenderStatistics(
transport::CastTransportSender* const transport_sender) transport::CastTransportSender* const transport_sender)
: transport_sender_(transport_sender) { : transport_sender_(transport_sender) {}
}
virtual void GetStatistics(const base::TimeTicks& now, virtual void GetStatistics(const base::TimeTicks& now,
transport::RtcpSenderInfo* sender_info) OVERRIDE { transport::RtcpSenderInfo* sender_info) OVERRIDE {
...@@ -53,8 +51,7 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics { ...@@ -53,8 +51,7 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics {
}; };
// TODO(mikhal): Reduce heap allocation when not needed. // TODO(mikhal): Reduce heap allocation when not needed.
AudioSender::AudioSender( AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
scoped_refptr<CastEnvironment> cast_environment,
const AudioSenderConfig& audio_config, const AudioSenderConfig& audio_config,
transport::CastTransportSender* const transport_sender) transport::CastTransportSender* const transport_sender)
: cast_environment_(cast_environment), : cast_environment_(cast_environment),
...@@ -77,8 +74,9 @@ AudioSender::AudioSender( ...@@ -77,8 +74,9 @@ AudioSender::AudioSender(
initialization_status_(STATUS_INITIALIZED), initialization_status_(STATUS_INITIALIZED),
weak_factory_(this) { weak_factory_(this) {
if (!audio_config.use_external_encoder) { if (!audio_config.use_external_encoder) {
audio_encoder_ = new AudioEncoder( audio_encoder_ =
cast_environment, audio_config, new AudioEncoder(cast_environment,
audio_config,
base::Bind(&AudioSender::SendEncodedAudioFrame, base::Bind(&AudioSender::SendEncodedAudioFrame,
weak_factory_.GetWeakPtr())); weak_factory_.GetWeakPtr()));
initialization_status_ = audio_encoder_->InitializationResult(); initialization_status_ = audio_encoder_->InitializationResult();
...@@ -103,8 +101,11 @@ void AudioSender::InsertAudio(const AudioBus* audio_bus, ...@@ -103,8 +101,11 @@ void AudioSender::InsertAudio(const AudioBus* audio_bus,
// TODO(mikhal): Resolve calculation of the audio rtp_timestamp for logging. // TODO(mikhal): Resolve calculation of the audio rtp_timestamp for logging.
// This is a tmp solution to allow the code to build. // This is a tmp solution to allow the code to build.
base::TimeTicks now = cast_environment_->Clock()->NowTicks(); base::TimeTicks now = cast_environment_->Clock()->NowTicks();
cast_environment_->Logging()->InsertFrameEvent(now, kAudioFrameReceived, cast_environment_->Logging()->InsertFrameEvent(
GetVideoRtpTimestamp(recorded_time), kFrameIdUnknown); now,
kAudioFrameReceived,
GetVideoRtpTimestamp(recorded_time),
kFrameIdUnknown);
audio_encoder_->InsertAudio(audio_bus, recorded_time, done_callback); audio_encoder_->InsertAudio(audio_bus, recorded_time, done_callback);
} }
...@@ -114,9 +115,11 @@ void AudioSender::SendEncodedAudioFrame( ...@@ -114,9 +115,11 @@ void AudioSender::SendEncodedAudioFrame(
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN)); DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
InitializeTimers(); InitializeTimers();
cast_environment_->PostTask( cast_environment_->PostTask(
CastEnvironment::TRANSPORT, FROM_HERE, CastEnvironment::TRANSPORT,
FROM_HERE,
base::Bind(&AudioSender::SendEncodedAudioFrameToTransport, base::Bind(&AudioSender::SendEncodedAudioFrameToTransport,
base::Unretained(this), base::Passed(&audio_frame), base::Unretained(this),
base::Passed(&audio_frame),
recorded_time)); recorded_time));
} }
...@@ -131,9 +134,11 @@ void AudioSender::ResendPackets( ...@@ -131,9 +134,11 @@ void AudioSender::ResendPackets(
const MissingFramesAndPacketsMap& missing_frames_and_packets) { const MissingFramesAndPacketsMap& missing_frames_and_packets) {
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN)); DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
cast_environment_->PostTask( cast_environment_->PostTask(
CastEnvironment::TRANSPORT, FROM_HERE, CastEnvironment::TRANSPORT,
FROM_HERE,
base::Bind(&AudioSender::ResendPacketsOnTransportThread, 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) { void AudioSender::IncomingRtcpPacket(scoped_ptr<Packet> packet) {
...@@ -146,11 +151,12 @@ void AudioSender::ScheduleNextRtcpReport() { ...@@ -146,11 +151,12 @@ void AudioSender::ScheduleNextRtcpReport() {
base::TimeDelta time_to_next = base::TimeDelta time_to_next =
rtcp_.TimeToSendNextRtcpReport() - cast_environment_->Clock()->NowTicks(); rtcp_.TimeToSendNextRtcpReport() - cast_environment_->Clock()->NowTicks();
time_to_next = std::max(time_to_next, time_to_next = std::max(
base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs)); time_to_next, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
cast_environment_->PostDelayedTask( cast_environment_->PostDelayedTask(
CastEnvironment::MAIN, FROM_HERE, CastEnvironment::MAIN,
FROM_HERE,
base::Bind(&AudioSender::SendRtcpReport, weak_factory_.GetWeakPtr()), base::Bind(&AudioSender::SendRtcpReport, weak_factory_.GetWeakPtr()),
time_to_next); time_to_next);
} }
......
media/cast/audio_sender/audio_sender_unittest.cc
View file @ 82439ec2
...@@ -28,9 +28,7 @@ using testing::Exactly; ...@@ -28,9 +28,7 @@ using testing::Exactly;
class TestPacketSender : public transport::PacketSender { class TestPacketSender : public transport::PacketSender {
public: public:
TestPacketSender() TestPacketSender() : number_of_rtp_packets_(0), number_of_rtcp_packets_(0) {}
: number_of_rtp_packets_(0),
number_of_rtcp_packets_(0) {}
virtual bool SendPacket(const Packet& packet) OVERRIDE { virtual bool SendPacket(const Packet& packet) OVERRIDE {
if (Rtcp::IsRtcpPacket(&packet[0], packet.size())) { if (Rtcp::IsRtcpPacket(&packet[0], packet.size())) {
...@@ -41,13 +39,9 @@ class TestPacketSender : public transport::PacketSender { ...@@ -41,13 +39,9 @@ class TestPacketSender : public transport::PacketSender {
return true; return true;
} }
int number_of_rtp_packets() const { int number_of_rtp_packets() const { return number_of_rtp_packets_; }
return number_of_rtp_packets_;
}
int number_of_rtcp_packets() const { int number_of_rtcp_packets() const { return number_of_rtcp_packets_; }
return number_of_rtcp_packets_;
}
private: private:
int number_of_rtp_packets_; int number_of_rtp_packets_;
...@@ -67,10 +61,15 @@ class AudioSenderTest : public ::testing::Test { ...@@ -67,10 +61,15 @@ class AudioSenderTest : public ::testing::Test {
testing_clock_->Advance( testing_clock_->Advance(
base::TimeDelta::FromMilliseconds(kStartMillisecond)); base::TimeDelta::FromMilliseconds(kStartMillisecond));
task_runner_ = new test::FakeTaskRunner(testing_clock_); task_runner_ = new test::FakeTaskRunner(testing_clock_);
cast_environment_ = new CastEnvironment( cast_environment_ =
scoped_ptr<base::TickClock>(testing_clock_).Pass(), new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(),
task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
task_runner_, task_runner_, GetDefaultCastSenderLoggingConfig()); task_runner_,
task_runner_,
task_runner_,
task_runner_,
task_runner_,
GetDefaultCastSenderLoggingConfig());
audio_config_.codec = transport::kOpus; audio_config_.codec = transport::kOpus;
audio_config_.use_external_encoder = false; audio_config_.use_external_encoder = false;
audio_config_.frequency = kDefaultAudioSamplingRate; audio_config_.frequency = kDefaultAudioSamplingRate;
...@@ -84,7 +83,8 @@ class AudioSenderTest : public ::testing::Test { ...@@ -84,7 +83,8 @@ class AudioSenderTest : public ::testing::Test {
transport_sender_.reset(new transport::CastTransportSenderImpl( transport_sender_.reset(new transport::CastTransportSenderImpl(
testing_clock_, testing_clock_,
transport_config, transport_config,
base::Bind(&UpdateCastTransportStatus), task_runner_)); base::Bind(&UpdateCastTransportStatus),
task_runner_));
transport_sender_->InsertFakeTransportForTesting(&transport_); transport_sender_->InsertFakeTransportForTesting(&transport_);
audio_sender_.reset(new AudioSender( audio_sender_.reset(new AudioSender(
cast_environment_, audio_config_, transport_sender_.get())); cast_environment_, audio_config_, transport_sender_.get()));
...@@ -110,35 +110,37 @@ TEST_F(AudioSenderTest, Encode20ms) { ...@@ -110,35 +110,37 @@ TEST_F(AudioSenderTest, Encode20ms) {
EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1)); EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1));
const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20); const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
scoped_ptr<AudioBus> bus(TestAudioBusFactory( scoped_ptr<AudioBus> bus(
audio_config_.channels, audio_config_.frequency, TestAudioBusFactory(audio_config_.channels,
TestAudioBusFactory::kMiddleANoteFreq, 0.5f).NextAudioBus(kDuration)); audio_config_.frequency,
TestAudioBusFactory::kMiddleANoteFreq,
0.5f).NextAudioBus(kDuration));
base::TimeTicks recorded_time = base::TimeTicks::Now(); base::TimeTicks recorded_time = base::TimeTicks::Now();
audio_sender_->InsertAudio( audio_sender_->InsertAudio(bus.get(),
bus.get(),
recorded_time, recorded_time,
base::Bind( base::Bind(&AudioSenderTest::InsertAudioCallback,
&AudioSenderTest::InsertAudioCallback,
base::Unretained(this))); base::Unretained(this)));
task_runner_->RunTasks(); task_runner_->RunTasks();
EXPECT_GE(transport_.number_of_rtp_packets() + EXPECT_GE(
transport_.number_of_rtcp_packets(), 1); transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets(),
1);
} }
TEST_F(AudioSenderTest, RtcpTimer) { TEST_F(AudioSenderTest, RtcpTimer) {
EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1)); EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1));
const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20); const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
scoped_ptr<AudioBus> bus(TestAudioBusFactory( scoped_ptr<AudioBus> bus(
audio_config_.channels, audio_config_.frequency, TestAudioBusFactory(audio_config_.channels,
TestAudioBusFactory::kMiddleANoteFreq, 0.5f).NextAudioBus(kDuration)); audio_config_.frequency,
TestAudioBusFactory::kMiddleANoteFreq,
0.5f).NextAudioBus(kDuration));
base::TimeTicks recorded_time = base::TimeTicks::Now(); base::TimeTicks recorded_time = base::TimeTicks::Now();
audio_sender_->InsertAudio( audio_sender_->InsertAudio(bus.get(),
bus.get(), recorded_time, recorded_time,
base::Bind( base::Bind(&AudioSenderTest::InsertAudioCallback,
&AudioSenderTest::InsertAudioCallback,
base::Unretained(this))); base::Unretained(this)));
task_runner_->RunTasks(); task_runner_->RunTasks();
......
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