Home | History | Annotate | Download | only in neteq 
      1 /*
      2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 // Unit tests for DelayManager class.
     12 
     13 #include "webrtc/modules/audio_coding/neteq/delay_manager.h"
     14 
     15 #include <math.h>
     16 
     17 #include "testing/gmock/include/gmock/gmock.h"
     18 #include "testing/gtest/include/gtest/gtest.h"
     19 #include "webrtc/modules/audio_coding/neteq/mock/mock_delay_peak_detector.h"
     20 
     21 namespace webrtc {
     22 
     23 using ::testing::Return;
     24 using ::testing::_;
     25 
     26 class DelayManagerTest : public ::testing::Test {
     27  protected:
     28   static const int kMaxNumberOfPackets = 240;
     29   static const int kTimeStepMs = 10;
     30   static const int kFs = 8000;
     31   static const int kFrameSizeMs = 20;
     32   static const int kTsIncrement = kFrameSizeMs * kFs / 1000;
     33 
     34   DelayManagerTest();
     35   virtual void SetUp();
     36   virtual void TearDown();
     37   void SetPacketAudioLength(int lengt_ms);
     38   void InsertNextPacket();
     39   void IncreaseTime(int inc_ms);
     40 
     41   DelayManager* dm_;
     42   MockDelayPeakDetector detector_;
     43   uint16_t seq_no_;
     44   uint32_t ts_;
     45 };
     46 
     47 DelayManagerTest::DelayManagerTest()
     48     : dm_(NULL),
     49       seq_no_(0x1234),
     50       ts_(0x12345678) {
     51 }
     52 
     53 void DelayManagerTest::SetUp() {
     54   EXPECT_CALL(detector_, Reset())
     55             .Times(1);
     56   dm_ = new DelayManager(kMaxNumberOfPackets, &detector_);
     57 }
     58 
     59 void DelayManagerTest::SetPacketAudioLength(int lengt_ms) {
     60   EXPECT_CALL(detector_, SetPacketAudioLength(lengt_ms));
     61   dm_->SetPacketAudioLength(lengt_ms);
     62 }
     63 
     64 void DelayManagerTest::InsertNextPacket() {
     65   EXPECT_EQ(0, dm_->Update(seq_no_, ts_, kFs));
     66   seq_no_ += 1;
     67   ts_ += kTsIncrement;
     68 }
     69 
     70 void DelayManagerTest::IncreaseTime(int inc_ms) {
     71   for (int t = 0; t < inc_ms; t += kTimeStepMs) {
     72     EXPECT_CALL(detector_, IncrementCounter(kTimeStepMs))
     73         .Times(1);
     74     dm_->UpdateCounters(kTimeStepMs);
     75   }
     76 }
     77 void DelayManagerTest::TearDown() {
     78   EXPECT_CALL(detector_, Die());
     79   delete dm_;
     80 }
     81 
     82 TEST_F(DelayManagerTest, CreateAndDestroy) {
     83   // Nothing to do here. The test fixture creates and destroys the DelayManager
     84   // object.
     85 }
     86 
     87 TEST_F(DelayManagerTest, VectorInitialization) {
     88   const DelayManager::IATVector& vec = dm_->iat_vector();
     89   double sum = 0.0;
     90   for (size_t i = 0; i < vec.size(); i++) {
     91     EXPECT_NEAR(ldexp(pow(0.5, static_cast<int>(i + 1)), 30), vec[i], 65537);
     92     // Tolerance 65537 in Q30 corresponds to a delta of approximately 0.00006.
     93     sum += vec[i];
     94   }
     95   EXPECT_EQ(1 << 30, static_cast<int>(sum));  // Should be 1 in Q30.
     96 }
     97 
     98 TEST_F(DelayManagerTest, SetPacketAudioLength) {
     99   const int kLengthMs = 30;
    100   // Expect DelayManager to pass on the new length to the detector object.
    101   EXPECT_CALL(detector_, SetPacketAudioLength(kLengthMs))
    102       .Times(1);
    103   EXPECT_EQ(0, dm_->SetPacketAudioLength(kLengthMs));
    104   EXPECT_EQ(-1, dm_->SetPacketAudioLength(-1));  // Illegal parameter value.
    105 }
    106 
    107 TEST_F(DelayManagerTest, PeakFound) {
    108   // Expect DelayManager to pass on the question to the detector.
    109   // Call twice, and let the detector return true the first time and false the
    110   // second time.
    111   EXPECT_CALL(detector_, peak_found())
    112       .WillOnce(Return(true))
    113       .WillOnce(Return(false));
    114   EXPECT_TRUE(dm_->PeakFound());
    115   EXPECT_FALSE(dm_->PeakFound());
    116 }
    117 
    118 TEST_F(DelayManagerTest, UpdateCounters) {
    119   // Expect DelayManager to pass on the counter update to the detector.
    120   EXPECT_CALL(detector_, IncrementCounter(kTimeStepMs))
    121       .Times(1);
    122   dm_->UpdateCounters(kTimeStepMs);
    123 }
    124 
    125 TEST_F(DelayManagerTest, UpdateNormal) {
    126   SetPacketAudioLength(kFrameSizeMs);
    127   // First packet arrival.
    128   InsertNextPacket();
    129   // Advance time by one frame size.
    130   IncreaseTime(kFrameSizeMs);
    131   // Second packet arrival.
    132   // Expect detector update method to be called once with inter-arrival time
    133   // equal to 1 packet, and (base) target level equal to 1 as well.
    134   // Return false to indicate no peaks found.
    135   EXPECT_CALL(detector_, Update(1, 1))
    136       .WillOnce(Return(false));
    137   InsertNextPacket();
    138   EXPECT_EQ(1 << 8, dm_->TargetLevel());  // In Q8.
    139   EXPECT_EQ(1, dm_->base_target_level());
    140   int lower, higher;
    141   dm_->BufferLimits(&lower, &higher);
    142   // Expect |lower| to be 75% of target level, and |higher| to be target level,
    143   // but also at least 20 ms higher than |lower|, which is the limiting case
    144   // here.
    145   EXPECT_EQ((1 << 8) * 3 / 4, lower);
    146   EXPECT_EQ(lower + (20 << 8) / kFrameSizeMs, higher);
    147 }
    148 
    149 TEST_F(DelayManagerTest, UpdateLongInterArrivalTime) {
    150   SetPacketAudioLength(kFrameSizeMs);
    151   // First packet arrival.
    152   InsertNextPacket();
    153   // Advance time by two frame size.
    154   IncreaseTime(2 * kFrameSizeMs);
    155   // Second packet arrival.
    156   // Expect detector update method to be called once with inter-arrival time
    157   // equal to 1 packet, and (base) target level equal to 1 as well.
    158   // Return false to indicate no peaks found.
    159   EXPECT_CALL(detector_, Update(2, 2))
    160       .WillOnce(Return(false));
    161   InsertNextPacket();
    162   EXPECT_EQ(2 << 8, dm_->TargetLevel());  // In Q8.
    163   EXPECT_EQ(2, dm_->base_target_level());
    164   int lower, higher;
    165   dm_->BufferLimits(&lower, &higher);
    166   // Expect |lower| to be 75% of target level, and |higher| to be target level,
    167   // but also at least 20 ms higher than |lower|, which is the limiting case
    168   // here.
    169   EXPECT_EQ((2 << 8) * 3 / 4, lower);
    170   EXPECT_EQ(lower + (20 << 8) / kFrameSizeMs, higher);
    171 }
    172 
    173 TEST_F(DelayManagerTest, UpdatePeakFound) {
    174   SetPacketAudioLength(kFrameSizeMs);
    175   // First packet arrival.
    176   InsertNextPacket();
    177   // Advance time by one frame size.
    178   IncreaseTime(kFrameSizeMs);
    179   // Second packet arrival.
    180   // Expect detector update method to be called once with inter-arrival time
    181   // equal to 1 packet, and (base) target level equal to 1 as well.
    182   // Return true to indicate that peaks are found. Let the peak height be 5.
    183   EXPECT_CALL(detector_, Update(1, 1))
    184       .WillOnce(Return(true));
    185   EXPECT_CALL(detector_, MaxPeakHeight())
    186       .WillOnce(Return(5));
    187   InsertNextPacket();
    188   EXPECT_EQ(5 << 8, dm_->TargetLevel());
    189   EXPECT_EQ(1, dm_->base_target_level());  // Base target level is w/o peaks.
    190   int lower, higher;
    191   dm_->BufferLimits(&lower, &higher);
    192   // Expect |lower| to be 75% of target level, and |higher| to be target level.
    193   EXPECT_EQ((5 << 8) * 3 / 4, lower);
    194   EXPECT_EQ(5 << 8, higher);
    195 }
    196 
    197 TEST_F(DelayManagerTest, TargetDelay) {
    198   SetPacketAudioLength(kFrameSizeMs);
    199   // First packet arrival.
    200   InsertNextPacket();
    201   // Advance time by one frame size.
    202   IncreaseTime(kFrameSizeMs);
    203   // Second packet arrival.
    204   // Expect detector update method to be called once with inter-arrival time
    205   // equal to 1 packet, and (base) target level equal to 1 as well.
    206   // Return false to indicate no peaks found.
    207   EXPECT_CALL(detector_, Update(1, 1))
    208       .WillOnce(Return(false));
    209   InsertNextPacket();
    210   const int kExpectedTarget = 1;
    211   EXPECT_EQ(kExpectedTarget << 8, dm_->TargetLevel());  // In Q8.
    212   EXPECT_EQ(1, dm_->base_target_level());
    213   int lower, higher;
    214   dm_->BufferLimits(&lower, &higher);
    215   // Expect |lower| to be 75% of base target level, and |higher| to be
    216   // lower + 20 ms headroom.
    217   EXPECT_EQ((1 << 8) * 3 / 4, lower);
    218   EXPECT_EQ(lower + (20 << 8) / kFrameSizeMs, higher);
    219 }
    220 
    221 TEST_F(DelayManagerTest, MaxAndRequiredDelay) {
    222   const int kExpectedTarget = 5;
    223   const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
    224   SetPacketAudioLength(kFrameSizeMs);
    225   // First packet arrival.
    226   InsertNextPacket();
    227   // Second packet arrival.
    228   // Expect detector update method to be called once with inter-arrival time
    229   // equal to |kExpectedTarget| packet. Return true to indicate peaks found.
    230   EXPECT_CALL(detector_, Update(kExpectedTarget, _))
    231       .WillRepeatedly(Return(true));
    232   EXPECT_CALL(detector_, MaxPeakHeight())
    233       .WillRepeatedly(Return(kExpectedTarget));
    234   IncreaseTime(kTimeIncrement);
    235   InsertNextPacket();
    236 
    237   // No limit is set.
    238   EXPECT_EQ(kExpectedTarget << 8, dm_->TargetLevel());
    239 
    240   int kMaxDelayPackets = kExpectedTarget - 2;
    241   int kMaxDelayMs = kMaxDelayPackets * kFrameSizeMs;
    242   EXPECT_TRUE(dm_->SetMaximumDelay(kMaxDelayMs));
    243   IncreaseTime(kTimeIncrement);
    244   InsertNextPacket();
    245   EXPECT_EQ(kExpectedTarget * kFrameSizeMs, dm_->least_required_delay_ms());
    246   EXPECT_EQ(kMaxDelayPackets << 8, dm_->TargetLevel());
    247 
    248   // Target level at least should be one packet.
    249   EXPECT_FALSE(dm_->SetMaximumDelay(kFrameSizeMs - 1));
    250 }
    251 
    252 TEST_F(DelayManagerTest, MinAndRequiredDelay) {
    253   const int kExpectedTarget = 5;
    254   const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
    255   SetPacketAudioLength(kFrameSizeMs);
    256   // First packet arrival.
    257   InsertNextPacket();
    258   // Second packet arrival.
    259   // Expect detector update method to be called once with inter-arrival time
    260   // equal to |kExpectedTarget| packet. Return true to indicate peaks found.
    261   EXPECT_CALL(detector_, Update(kExpectedTarget, _))
    262       .WillRepeatedly(Return(true));
    263   EXPECT_CALL(detector_, MaxPeakHeight())
    264       .WillRepeatedly(Return(kExpectedTarget));
    265   IncreaseTime(kTimeIncrement);
    266   InsertNextPacket();
    267 
    268   // No limit is applied.
    269   EXPECT_EQ(kExpectedTarget << 8, dm_->TargetLevel());
    270 
    271   int kMinDelayPackets = kExpectedTarget + 2;
    272   int kMinDelayMs = kMinDelayPackets * kFrameSizeMs;
    273   dm_->SetMinimumDelay(kMinDelayMs);
    274   IncreaseTime(kTimeIncrement);
    275   InsertNextPacket();
    276   EXPECT_EQ(kExpectedTarget * kFrameSizeMs, dm_->least_required_delay_ms());
    277   EXPECT_EQ(kMinDelayPackets << 8, dm_->TargetLevel());
    278 }
    279 
    280 TEST_F(DelayManagerTest, Failures) {
    281   // Wrong sample rate.
    282   EXPECT_EQ(-1, dm_->Update(0, 0, -1));
    283   // Wrong packet size.
    284   EXPECT_EQ(-1, dm_->SetPacketAudioLength(0));
    285   EXPECT_EQ(-1, dm_->SetPacketAudioLength(-1));
    286 
    287   // Minimum delay higher than a maximum delay is not accepted.
    288   EXPECT_TRUE(dm_->SetMaximumDelay(10));
    289   EXPECT_FALSE(dm_->SetMinimumDelay(20));
    290 
    291   // Maximum delay less than minimum delay is not accepted.
    292   EXPECT_TRUE(dm_->SetMaximumDelay(100));
    293   EXPECT_TRUE(dm_->SetMinimumDelay(80));
    294   EXPECT_FALSE(dm_->SetMaximumDelay(60));
    295 }
    296 
    297 }  // namespace webrtc
    298