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