| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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 <stdint.h> | |
| 6 | |
| 7 #include <sstream> | |
| 8 #include <string> | |
| 9 | |
| 10 #include "base/bind.h" | |
| 11 #include "base/bind_helpers.h" | |
| 12 #include "base/memory/scoped_ptr.h" | |
| 13 #include "media/base/audio_bus.h" | |
| 14 #include "media/base/media.h" | |
| 15 #include "media/cast/audio_sender/audio_encoder.h" | |
| 16 #include "media/cast/cast_environment.h" | |
| 17 #include "media/cast/test/fake_single_thread_task_runner.h" | |
| 18 #include "media/cast/test/utility/audio_utility.h" | |
| 19 #include "testing/gtest/include/gtest/gtest.h" | |
| 20 | |
| 21 namespace media { | |
| 22 namespace cast { | |
| 23 | |
| 24 static const int kNumChannels = 2; | |
| 25 | |
| 26 namespace { | |
| 27 | |
| 28 class TestEncodedAudioFrameReceiver { | |
| 29 public: | |
| 30 explicit TestEncodedAudioFrameReceiver(transport::Codec codec) | |
| 31 : codec_(codec), frames_received_(0), rtp_lower_bound_(0) {} | |
| 32 virtual ~TestEncodedAudioFrameReceiver() {} | |
| 33 | |
| 34 int frames_received() const { return frames_received_; } | |
| 35 | |
| 36 void SetCaptureTimeBounds(const base::TimeTicks& lower_bound, | |
| 37 const base::TimeTicks& upper_bound) { | |
| 38 lower_bound_ = lower_bound; | |
| 39 upper_bound_ = upper_bound; | |
| 40 } | |
| 41 | |
| 42 void FrameEncoded(scoped_ptr<transport::EncodedFrame> encoded_frame) { | |
| 43 EXPECT_EQ(encoded_frame->dependency, transport::EncodedFrame::KEY); | |
| 44 EXPECT_EQ(static_cast<uint8>(frames_received_ & 0xff), | |
| 45 encoded_frame->frame_id); | |
| 46 EXPECT_EQ(encoded_frame->frame_id, encoded_frame->referenced_frame_id); | |
| 47 // RTP timestamps should be monotonically increasing and integer multiples | |
| 48 // of the fixed frame size. | |
| 49 EXPECT_LE(rtp_lower_bound_, encoded_frame->rtp_timestamp); | |
| 50 rtp_lower_bound_ = encoded_frame->rtp_timestamp; | |
| 51 // Note: In audio_encoder.cc, 100 is the fixed audio frame rate. | |
| 52 const int kSamplesPerFrame = kDefaultAudioSamplingRate / 100; | |
| 53 EXPECT_EQ(0u, encoded_frame->rtp_timestamp % kSamplesPerFrame); | |
| 54 EXPECT_TRUE(!encoded_frame->data.empty()); | |
| 55 | |
| 56 EXPECT_LE(lower_bound_, encoded_frame->reference_time); | |
| 57 lower_bound_ = encoded_frame->reference_time; | |
| 58 EXPECT_GT(upper_bound_, encoded_frame->reference_time); | |
| 59 | |
| 60 ++frames_received_; | |
| 61 } | |
| 62 | |
| 63 private: | |
| 64 const transport::Codec codec_; | |
| 65 int frames_received_; | |
| 66 uint32 rtp_lower_bound_; | |
| 67 base::TimeTicks lower_bound_; | |
| 68 base::TimeTicks upper_bound_; | |
| 69 | |
| 70 DISALLOW_COPY_AND_ASSIGN(TestEncodedAudioFrameReceiver); | |
| 71 }; | |
| 72 | |
| 73 struct TestScenario { | |
| 74 const int64* durations_in_ms; | |
| 75 size_t num_durations; | |
| 76 | |
| 77 TestScenario(const int64* d, size_t n) | |
| 78 : durations_in_ms(d), num_durations(n) {} | |
| 79 | |
| 80 std::string ToString() const { | |
| 81 std::ostringstream out; | |
| 82 for (size_t i = 0; i < num_durations; ++i) { | |
| 83 if (i > 0) | |
| 84 out << ", "; | |
| 85 out << durations_in_ms[i]; | |
| 86 } | |
| 87 return out.str(); | |
| 88 } | |
| 89 }; | |
| 90 | |
| 91 } // namespace | |
| 92 | |
| 93 class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> { | |
| 94 public: | |
| 95 AudioEncoderTest() { | |
| 96 InitializeMediaLibraryForTesting(); | |
| 97 testing_clock_ = new base::SimpleTestTickClock(); | |
| 98 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); | |
| 99 } | |
| 100 | |
| 101 virtual void SetUp() { | |
| 102 task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_); | |
| 103 cast_environment_ = | |
| 104 new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(), | |
| 105 task_runner_, | |
| 106 task_runner_, | |
| 107 task_runner_); | |
| 108 } | |
| 109 | |
| 110 virtual ~AudioEncoderTest() {} | |
| 111 | |
| 112 void RunTestForCodec(transport::Codec codec) { | |
| 113 const TestScenario& scenario = GetParam(); | |
| 114 SCOPED_TRACE(::testing::Message() << "Durations: " << scenario.ToString()); | |
| 115 | |
| 116 CreateObjectsForCodec(codec); | |
| 117 | |
| 118 // Note: In audio_encoder.cc, 10 ms is the fixed frame duration. | |
| 119 const base::TimeDelta frame_duration = | |
| 120 base::TimeDelta::FromMilliseconds(10); | |
| 121 | |
| 122 for (size_t i = 0; i < scenario.num_durations; ++i) { | |
| 123 const bool simulate_missing_data = scenario.durations_in_ms[i] < 0; | |
| 124 const base::TimeDelta duration = base::TimeDelta::FromMilliseconds( | |
| 125 std::abs(scenario.durations_in_ms[i])); | |
| 126 receiver_->SetCaptureTimeBounds( | |
| 127 testing_clock_->NowTicks() - frame_duration, | |
| 128 testing_clock_->NowTicks() + duration); | |
| 129 if (simulate_missing_data) { | |
| 130 task_runner_->RunTasks(); | |
| 131 testing_clock_->Advance(duration); | |
| 132 } else { | |
| 133 audio_encoder_->InsertAudio(audio_bus_factory_->NextAudioBus(duration), | |
| 134 testing_clock_->NowTicks()); | |
| 135 task_runner_->RunTasks(); | |
| 136 testing_clock_->Advance(duration); | |
| 137 } | |
| 138 } | |
| 139 | |
| 140 DVLOG(1) << "Received " << receiver_->frames_received() | |
| 141 << " frames for this test run: " << scenario.ToString(); | |
| 142 } | |
| 143 | |
| 144 private: | |
| 145 void CreateObjectsForCodec(transport::Codec codec) { | |
| 146 audio_bus_factory_.reset( | |
| 147 new TestAudioBusFactory(kNumChannels, | |
| 148 kDefaultAudioSamplingRate, | |
| 149 TestAudioBusFactory::kMiddleANoteFreq, | |
| 150 0.5f)); | |
| 151 | |
| 152 receiver_.reset(new TestEncodedAudioFrameReceiver(codec)); | |
| 153 | |
| 154 audio_encoder_.reset(new AudioEncoder( | |
| 155 cast_environment_, | |
| 156 kNumChannels, | |
| 157 kDefaultAudioSamplingRate, | |
| 158 kDefaultAudioEncoderBitrate, | |
| 159 codec, | |
| 160 base::Bind(&TestEncodedAudioFrameReceiver::FrameEncoded, | |
| 161 base::Unretained(receiver_.get())))); | |
| 162 } | |
| 163 | |
| 164 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. | |
| 165 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | |
| 166 scoped_ptr<TestAudioBusFactory> audio_bus_factory_; | |
| 167 scoped_ptr<TestEncodedAudioFrameReceiver> receiver_; | |
| 168 scoped_ptr<AudioEncoder> audio_encoder_; | |
| 169 scoped_refptr<CastEnvironment> cast_environment_; | |
| 170 | |
| 171 DISALLOW_COPY_AND_ASSIGN(AudioEncoderTest); | |
| 172 }; | |
| 173 | |
| 174 TEST_P(AudioEncoderTest, EncodeOpus) { | |
| 175 RunTestForCodec(transport::CODEC_AUDIO_OPUS); | |
| 176 } | |
| 177 | |
| 178 TEST_P(AudioEncoderTest, EncodePcm16) { | |
| 179 RunTestForCodec(transport::CODEC_AUDIO_PCM16); | |
| 180 } | |
| 181 | |
| 182 static const int64 kOneCall_3Millis[] = {3}; | |
| 183 static const int64 kOneCall_10Millis[] = {10}; | |
| 184 static const int64 kOneCall_13Millis[] = {13}; | |
| 185 static const int64 kOneCall_20Millis[] = {20}; | |
| 186 | |
| 187 static const int64 kTwoCalls_3Millis[] = {3, 3}; | |
| 188 static const int64 kTwoCalls_10Millis[] = {10, 10}; | |
| 189 static const int64 kTwoCalls_Mixed1[] = {3, 10}; | |
| 190 static const int64 kTwoCalls_Mixed2[] = {10, 3}; | |
| 191 static const int64 kTwoCalls_Mixed3[] = {3, 17}; | |
| 192 static const int64 kTwoCalls_Mixed4[] = {17, 3}; | |
| 193 | |
| 194 static const int64 kManyCalls_3Millis[] = {3, 3, 3, 3, 3, 3, 3, 3, | |
| 195 3, 3, 3, 3, 3, 3, 3}; | |
| 196 static const int64 kManyCalls_10Millis[] = {10, 10, 10, 10, 10, 10, 10, 10, | |
| 197 10, 10, 10, 10, 10, 10, 10}; | |
| 198 static const int64 kManyCalls_Mixed1[] = {3, 10, 3, 10, 3, 10, 3, 10, 3, | |
| 199 10, 3, 10, 3, 10, 3, 10, 3, 10}; | |
| 200 static const int64 kManyCalls_Mixed2[] = {10, 3, 10, 3, 10, 3, 10, 3, 10, 3, | |
| 201 10, 3, 10, 3, 10, 3, 10, 3, 10, 3}; | |
| 202 static const int64 kManyCalls_Mixed3[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, | |
| 203 9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6, 4}; | |
| 204 static const int64 kManyCalls_Mixed4[] = {31, 4, 15, 9, 26, 53, 5, 8, 9, | |
| 205 7, 9, 32, 38, 4, 62, 64, 3}; | |
| 206 static const int64 kManyCalls_Mixed5[] = {3, 14, 15, 9, 26, 53, 58, 9, 7, | |
| 207 9, 3, 23, 8, 4, 6, 2, 6, 43}; | |
| 208 | |
| 209 static const int64 kOneBigUnderrun[] = {10, 10, 10, 10, -1000, 10, 10, 10}; | |
| 210 static const int64 kTwoBigUnderruns[] = {10, 10, 10, 10, -712, 10, 10, 10, | |
| 211 -1311, 10, 10, 10}; | |
| 212 static const int64 kMixedUnderruns[] = {31, -64, 4, 15, 9, 26, -53, 5, 8, -9, | |
| 213 7, 9, 32, 38, -4, 62, -64, 3}; | |
| 214 | |
| 215 INSTANTIATE_TEST_CASE_P( | |
| 216 AudioEncoderTestScenarios, | |
| 217 AudioEncoderTest, | |
| 218 ::testing::Values( | |
| 219 TestScenario(kOneCall_3Millis, arraysize(kOneCall_3Millis)), | |
| 220 TestScenario(kOneCall_10Millis, arraysize(kOneCall_10Millis)), | |
| 221 TestScenario(kOneCall_13Millis, arraysize(kOneCall_13Millis)), | |
| 222 TestScenario(kOneCall_20Millis, arraysize(kOneCall_20Millis)), | |
| 223 TestScenario(kTwoCalls_3Millis, arraysize(kTwoCalls_3Millis)), | |
| 224 TestScenario(kTwoCalls_10Millis, arraysize(kTwoCalls_10Millis)), | |
| 225 TestScenario(kTwoCalls_Mixed1, arraysize(kTwoCalls_Mixed1)), | |
| 226 TestScenario(kTwoCalls_Mixed2, arraysize(kTwoCalls_Mixed2)), | |
| 227 TestScenario(kTwoCalls_Mixed3, arraysize(kTwoCalls_Mixed3)), | |
| 228 TestScenario(kTwoCalls_Mixed4, arraysize(kTwoCalls_Mixed4)), | |
| 229 TestScenario(kManyCalls_3Millis, arraysize(kManyCalls_3Millis)), | |
| 230 TestScenario(kManyCalls_10Millis, arraysize(kManyCalls_10Millis)), | |
| 231 TestScenario(kManyCalls_Mixed1, arraysize(kManyCalls_Mixed1)), | |
| 232 TestScenario(kManyCalls_Mixed2, arraysize(kManyCalls_Mixed2)), | |
| 233 TestScenario(kManyCalls_Mixed3, arraysize(kManyCalls_Mixed3)), | |
| 234 TestScenario(kManyCalls_Mixed4, arraysize(kManyCalls_Mixed4)), | |
| 235 TestScenario(kManyCalls_Mixed5, arraysize(kManyCalls_Mixed5)), | |
| 236 TestScenario(kOneBigUnderrun, arraysize(kOneBigUnderrun)), | |
| 237 TestScenario(kTwoBigUnderruns, arraysize(kTwoBigUnderruns)), | |
| 238 TestScenario(kMixedUnderruns, arraysize(kMixedUnderruns)))); | |
| 239 | |
| 240 } // namespace cast | |
| 241 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 388663003:
Cast: Reshuffle files under media/cast (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src