API to control target delay in NetEq jitter buffer. NetEq maintains the given delay unless channel conditions require a higher delay.

TEST=unit-test, manual, trybots.
R=henrik.lundin@webrtc.org, henrika@webrtc.org, mflodman@webrtc.org, mikhal@webrtc.org, stefan@webrtc.org, tina.legrand@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/1384005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4087 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/audio_coding/main/test/target_delay_unittest.cc

@@ -0,0 +1,172 @@
+/*
+ *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "gtest/gtest.h"
+#include "testsupport/fileutils.h"
+#include "webrtc/common_types.h"
+#include "webrtc/modules/audio_coding/main/interface/audio_coding_module.h"
+#include "webrtc/modules/interface/module_common_types.h"
+#include "webrtc/system_wrappers/interface/sleep.h"
+
+namespace webrtc {
+class TargetDelayTest : public ::testing::Test {
+ protected:
+  static const int kSampleRateHz = 16000;
+  static const int kNum10msPerFrame = 2;
+  static const int kFrameSizeSamples = 320;  // 20 ms @ 16 kHz.
+  // payload-len = frame-samples * 2 bytes/sample.
+  static const int kPayloadLenBytes = 320 * 2;
+  // Inter-arrival time in number of packets in a jittery channel. One is no
+  // jitter.
+  static const int kInterarrivalJitterPacket = 2;
+
+  TargetDelayTest()
+      : acm_(AudioCodingModule::Create(0)) {}
+
+  ~TargetDelayTest() {
+    AudioCodingModule::Destroy(acm_);
+  }
+
+  void SetUp() {
+    EXPECT_TRUE(acm_ != NULL);
+
+    CodecInst codec;
+    ASSERT_EQ(0, AudioCodingModule::Codec("L16", &codec, kSampleRateHz, 1));
+    ASSERT_EQ(0, acm_->InitializeReceiver());
+    ASSERT_EQ(0, acm_->RegisterReceiveCodec(codec));
+
+    rtp_info_.header.payloadType = codec.pltype;
+    rtp_info_.header.timestamp = 0;
+    rtp_info_.header.ssrc = 0x12345678;
+    rtp_info_.header.markerBit = false;
+    rtp_info_.header.sequenceNumber = 0;
+    rtp_info_.type.Audio.channel = 1;
+    rtp_info_.type.Audio.isCNG = false;
+    rtp_info_.frameType = kAudioFrameSpeech;
+  }
+
+  void Push() {
+    rtp_info_.header.timestamp += kFrameSizeSamples;
+    rtp_info_.header.sequenceNumber++;
+    uint8_t payload[kPayloadLenBytes];  // Doesn't need to be initialized.
+    ASSERT_EQ(0, acm_->IncomingPacket(payload, kFrameSizeSamples * 2,
+                                      rtp_info_));
+  }
+
+  // Pull audio equivalent to the amount of audio in one RTP packet.
+  void Pull() {
+    AudioFrame frame;
+    for (int k = 0; k < kNum10msPerFrame; ++k) {  // Pull one frame.
+      ASSERT_EQ(0, acm_->PlayoutData10Ms(-1, &frame));
+      // Had to use ASSERT_TRUE, ASSERT_EQ generated error.
+      ASSERT_TRUE(kSampleRateHz == frame.sample_rate_hz_);
+      ASSERT_EQ(1, frame.num_channels_);
+      ASSERT_TRUE(kSampleRateHz / 100 == frame.samples_per_channel_);
+    }
+  }
+
+  void Run(bool clean) {
+    for (int n = 0; n < 10; ++n) {
+      for (int m = 0; m < 5; ++m) {
+        Push();
+        Pull();
+      }
+
+      if (!clean) {
+        for (int m = 0; m < 10; ++m) {  // Long enough to trigger delay change.
+          Push();
+          for (int n = 0; n < kInterarrivalJitterPacket; ++n)
+            Pull();
+        }
+      }
+    }
+  }
+
+  int SetMinimumDelay(int delay_ms) {
+    return acm_->SetMinimumPlayoutDelay(delay_ms);
+  }
+
+  int GetCurrentOptimalDelayMs() {
+    ACMNetworkStatistics stats;
+    acm_->NetworkStatistics(&stats);
+    return stats.preferredBufferSize;
+  }
+
+  int RequiredDelay() {
+    return acm_->LeastRequiredDelayMs();
+  }
+
+  AudioCodingModule* acm_;
+  WebRtcRTPHeader rtp_info_;
+};
+
+TEST_F(TargetDelayTest, OutOfRangeInput) {
+  EXPECT_EQ(-1, SetMinimumDelay(-1));
+  EXPECT_EQ(-1, SetMinimumDelay(10001));
+}
+
+TEST_F(TargetDelayTest, NoTargetDelayBufferSizeChanges) {
+  for (int n = 0; n < 30; ++n)  // Run enough iterations.
+    Run(true);
+  int clean_optimal_delay = GetCurrentOptimalDelayMs();
+  Run(false);  // Run with jitter.
+  int jittery_optimal_delay = GetCurrentOptimalDelayMs();
+  EXPECT_GT(jittery_optimal_delay, clean_optimal_delay);
+  int required_delay = RequiredDelay();
+  EXPECT_GT(required_delay, 0);
+  EXPECT_NEAR(required_delay, jittery_optimal_delay, 1);
+}
+
+TEST_F(TargetDelayTest, WithTargetDelayBufferNotChanging) {
+  // A target delay that is one packet larger than jitter.
+  const int kTargetDelayMs = (kInterarrivalJitterPacket + 1) *
+      kNum10msPerFrame * 10;
+  ASSERT_EQ(0, SetMinimumDelay(kTargetDelayMs));
+  for (int n = 0; n < 30; ++n)  // Run enough iterations to fill up the buffer.
+    Run(true);
+  int clean_optimal_delay = GetCurrentOptimalDelayMs();
+  EXPECT_EQ(kTargetDelayMs, clean_optimal_delay);
+  Run(false);  // Run with jitter.
+  int jittery_optimal_delay = GetCurrentOptimalDelayMs();
+  EXPECT_EQ(jittery_optimal_delay, clean_optimal_delay);
+}
+
+TEST_F(TargetDelayTest, RequiredDelayAtCorrectRange) {
+  for (int n = 0; n < 30; ++n)  // Run clean and store delay.
+    Run(true);
+  int clean_optimal_delay = GetCurrentOptimalDelayMs();
+
+  // A relatively large delay.
+  const int kTargetDelayMs = (kInterarrivalJitterPacket + 10) *
+      kNum10msPerFrame * 10;
+  ASSERT_EQ(0, SetMinimumDelay(kTargetDelayMs));
+  for (int n = 0; n < 300; ++n)  // Run enough iterations to fill up the buffer.
+    Run(true);
+  Run(false);  // Run with jitter.
+
+  int jittery_optimal_delay = GetCurrentOptimalDelayMs();
+  EXPECT_EQ(kTargetDelayMs, jittery_optimal_delay);
+
+  int required_delay = RequiredDelay();
+
+  // Checking |required_delay| is in correct range.
+  EXPECT_GT(required_delay, 0);
+  EXPECT_GT(jittery_optimal_delay, required_delay);
+  EXPECT_GT(required_delay, clean_optimal_delay);
+
+  // A tighter check for the value of |required_delay|.
+  // The jitter forces a delay of
+  // |kInterarrivalJitterPacket * kNum10msPerFrame * 10| milliseconds. So we
+  // expect |required_delay| be close to that.
+  EXPECT_NEAR(kInterarrivalJitterPacket * kNum10msPerFrame * 10,
+              required_delay, 1);
+}
+
+}  // webrtc