Revert "Remove legacy delay manger field trial and update default config."

This reverts commit 93849d4b2a976b0a46059d6f74d9efd8f12eab92. Reason for revert: AcmReceiverBitExactnessOldApi tests failing on MacARM64; first failing build https://ci.chromium.org/ui/p/webrtc/builders/ci/MacARM64%20M1%20Release/1038/overview Example faliure [ RUN ] AcmReceiverBitExactnessOldApi.8kHzOutput ... (rtp_file_reader.cc:165): Failed to read ../../modules/audio_coding/acm2/audio_coding_module_unittest.cc:912: Failure Expected equality of these values: checksum_ref Which is: "636efe6d0a148f22c5383f356da3deac" checksum_string Which is: "6a288942d67e82076b38b17777cdaee4" Original change's description: > Remove legacy delay manger field trial and update default config. > > Bug: webrtc:10333 > Change-Id: I20e55d8d111d93657d1afe556fe3a325337c074c > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/232820 > Reviewed-by: Ivo Creusen <ivoc@webrtc.org> > Commit-Queue: Jakob Ivarsson <jakobi@webrtc.org> > Cr-Commit-Position: refs/heads/main@{#35321} TBR=ivoc@webrtc.org,jakobi@webrtc.org,webrtc-scoped@luci-project-accounts.iam.gserviceaccount.com Change-Id: I0bd3832aacba8dcd8e836650786cea20b4c083be No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: webrtc:10333 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/237441 Reviewed-by: Olga Sharonova <olka@webrtc.org> Reviewed-by: Jakob Ivarsson <jakobi@webrtc.org> Commit-Queue: Olga Sharonova <olka@webrtc.org> Cr-Commit-Position: refs/heads/main@{#35324}
2021-11-08 19:09:28 +00:00
parent 42a850d250
commit 46814941f2
11 changed files with 294 additions and 145 deletions
--- a/modules/audio_coding/acm2/audio_coding_module_unittest.cc
+++ b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
@ -920,61 +920,61 @@ class AcmReceiverBitExactnessOldApi : public ::testing::Test {
    defined(WEBRTC_CODEC_ILBC)
 TEST_F(AcmReceiverBitExactnessOldApi, 8kHzOutput) {
  std::string others_checksum_reference =
-      GetCPUInfo(kAVX2) != 0 ? "d8671dd38dab43fc9ca64a45c048c218"
-                             : "4710c99559aec2f9f02a983ba2146f2d";
+      GetCPUInfo(kAVX2) != 0 ? "e0c966d7b8c36ff60167988fa35d33e0"
+                             : "7d8f6b84abd1e57ec010a53bc2130652";
  std::string win64_checksum_reference =
      GetCPUInfo(kAVX2) != 0 ? "405a50f0bcb8827e20aa944299fc59f6"
                             : "0ed5830930f5527a01bbec0ba11f8541";
  Run(8000, PlatformChecksum(
                others_checksum_reference, win64_checksum_reference,
-                /*android_arm32=*/"4a8ffd7fd235c8bea74d0e18c022fac3",
+                /*android_arm32=*/"b892ed69c38b21b16c132ec2ce03aa7b",
                /*android_arm64=*/"4598140b5e4f7ee66c5adad609e65a3e",
-                /*android_arm64_clang=*/"ad2ae6c6e48b714d728a7af0d3c8dc51",
+                /*android_arm64_clang=*/"5fec8d770778ef7969ec98c56d9eb10f",
                /*mac_arm64=*/"636efe6d0a148f22c5383f356da3deac"));
 }

 TEST_F(AcmReceiverBitExactnessOldApi, 16kHzOutput) {
  std::string others_checksum_reference =
-      GetCPUInfo(kAVX2) != 0 ? "abcb31509af46545edb4f6700728a4de"
-                             : "70b3217df49834b7093c631531068bd0";
+      GetCPUInfo(kAVX2) != 0 ? "a63c578e1195c8420f453962c6d8519c"
+                             : "6bac83762c1306b932cd25a560155681";
  std::string win64_checksum_reference =
      GetCPUInfo(kAVX2) != 0 ? "58fd62a5c49ee513f9fa6fe7dbf62c97"
                             : "0509cf0672f543efb4b050e8cffefb1d";
  Run(16000, PlatformChecksum(
                 others_checksum_reference, win64_checksum_reference,
-                 /*android_arm32=*/"00d703da221363804d6fccc309a3f684",
+                 /*android_arm32=*/"3cea9abbeabbdea9a79719941b241af5",
                 /*android_arm64=*/"f2aad418af974a3b1694d5ae5cc2c3c7",
-                 /*android_arm64_clang=*/"2b8525c77a6e10800bb209a83160282a",
+                 /*android_arm64_clang=*/"9d4b92c31c00e321a4cff29ad002d6a2",
                 /*mac_arm64=*/"1e2d1b482fdc924f79a838503ee7ead5"));
 }

 TEST_F(AcmReceiverBitExactnessOldApi, 32kHzOutput) {
  std::string others_checksum_reference =
-      GetCPUInfo(kAVX2) != 0 ? "8489b7743d6cd1903807ac81e5ee493d"
-                             : "2679e4e596e33259228c62df545eb635";
+      GetCPUInfo(kAVX2) != 0 ? "8775ce387f44dc5ff4a26da295d5ee7c"
+                             : "e319222ca47733709f90fdf33c8574db";
  std::string win64_checksum_reference =
      GetCPUInfo(kAVX2) != 0 ? "04ce6a1dac5ffdd8438d804623d0132f"
                             : "39a4a7a1c455b35baeffb9fd193d7858";
  Run(32000, PlatformChecksum(
                 others_checksum_reference, win64_checksum_reference,
-                 /*android_arm32=*/"809446f684b8095a93495ad63ec19891",
+                 /*android_arm32=*/"4df55b3b62bcbf4328786d474ae87f61",
                 /*android_arm64=*/"100869c8dcde51346c2073e52a272d98",
-                 /*android_arm64_clang=*/"dfe6fba596ed68d5a32d9f9eba5a39cb",
+                 /*android_arm64_clang=*/"ff58d3153d2780a3df6bc2068844cb2d",
                 /*mac_arm64=*/"51788e9784a10ae14a030f075a039205"));
 }

 TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutput) {
  std::string others_checksum_reference =
-      GetCPUInfo(kAVX2) != 0 ? "454996a7adb3f62b259a53a09ff624cf"
-                             : "f0148c5ef84e74e019ac7057af839102";
+      GetCPUInfo(kAVX2) != 0 ? "7a55700b7ca9aa60237db58b33e55606"
+                             : "57d1d316c88279f4f3da3511665069a9";
  std::string win64_checksum_reference =
      GetCPUInfo(kAVX2) != 0 ? "f59833d9b0924f4b0704707dd3589f80"
                             : "74cbe7345e2b6b45c1e455a5d1e921ca";
  Run(48000, PlatformChecksum(
                 others_checksum_reference, win64_checksum_reference,
-                 /*android_arm32=*/"f5c1290ce96d675aaf52be0b54362bee",
+                 /*android_arm32=*/"f52bc7bf0f499c9da25932fdf176c4ec",
                 /*android_arm64=*/"bd44bf97e7899186532f91235cef444d",
-                 /*android_arm64_clang=*/"7c2e28b943baf8c8af556be203bea256",
+                 /*android_arm64_clang=*/"364d403dae55d73cd69e6dbd6b723a4d",
                 /*mac_arm64=*/"71bc5c15a151400517c2119d1602ee9f"));
 }

@ -1054,17 +1054,17 @@ TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutputExternalDecoder) {
  rtc::scoped_refptr<rtc::RefCountedObject<ADFactory>> factory(
      new rtc::RefCountedObject<ADFactory>);
  std::string others_checksum_reference =
-      GetCPUInfo(kAVX2) != 0 ? "454996a7adb3f62b259a53a09ff624cf"
-                             : "f0148c5ef84e74e019ac7057af839102";
+      GetCPUInfo(kAVX2) != 0 ? "7a55700b7ca9aa60237db58b33e55606"
+                             : "57d1d316c88279f4f3da3511665069a9";
  std::string win64_checksum_reference =
      GetCPUInfo(kAVX2) != 0 ? "f59833d9b0924f4b0704707dd3589f80"
                             : "74cbe7345e2b6b45c1e455a5d1e921ca";
  Run(48000,
      PlatformChecksum(
          others_checksum_reference, win64_checksum_reference,
-          /*android_arm32=*/"f5c1290ce96d675aaf52be0b54362bee",
+          /*android_arm32=*/"f52bc7bf0f499c9da25932fdf176c4ec",
          /*android_arm64=*/"bd44bf97e7899186532f91235cef444d",
-          /*android_arm64_clang=*/"7c2e28b943baf8c8af556be203bea256",
+          /*android_arm64_clang=*/"364d403dae55d73cd69e6dbd6b723a4d",
          /*mac_arm64=*/"71bc5c15a151400517c2119d1602ee9f"),
      factory, [](AudioCodingModule* acm) {
        acm->SetReceiveCodecs({{0, {"MockPCMu", 8000, 1}},
@ -1284,12 +1284,12 @@ class AcmSenderBitExactnessNewApi : public AcmSenderBitExactnessOldApi {};
 TEST_F(AcmSenderBitExactnessOldApi, IsacWb30ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 16000, 1, 103, 480, 480));
  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
-          /*others=*/"a3077ac01b0137e8bbc237fb1f9816a5",
+          /*others=*/"2c9cb15d4ed55b5a0cadd04883bc73b0",
          /*win64=*/"9336a9b993cbd8a751f0e8958e66c89c",
-          /*android_arm32=*/"ab39f101ca76efdf6a5b2250550f10c4",
+          /*android_arm32=*/"5c2eb46199994506236f68b2c8e51b0d",
          /*android_arm64=*/"343f1f42be0607c61e6516aece424609",
-          /*android_arm64_clang=*/"a3077ac01b0137e8bbc237fb1f9816a5",
-          /*mac_arm64=*/"a3077ac01b0137e8bbc237fb1f9816a5"),
+          /*android_arm64_clang=*/"2c9cb15d4ed55b5a0cadd04883bc73b0",
+          /*mac_arm64=*/"2c9cb15d4ed55b5a0cadd04883bc73b0"),
      AcmReceiverBitExactnessOldApi::PlatformChecksum(
          /*others=*/"3c79f16f34218271f3dca4e2b1dfe1bb",
          /*win64=*/"d42cb5195463da26c8129bbfe73a22e6",
@ -1303,12 +1303,12 @@ TEST_F(AcmSenderBitExactnessOldApi, IsacWb30ms) {
 TEST_F(AcmSenderBitExactnessOldApi, IsacWb60ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 16000, 1, 103, 960, 960));
  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
-          /*others=*/"76da9b7514f986fc2bb32b1c3170e8d4",
+          /*others=*/"1ad29139a04782a33daad8c2b9b35875",
          /*win64=*/"14d63c5f08127d280e722e3191b73bdd",
-          /*android_arm32=*/"0bd883118ff9c26b9471df7a0c664197",
+          /*android_arm32=*/"9a81e467eb1485f84aca796f8ea65011",
          /*android_arm64=*/"ef75e900e6f375e3061163c53fd09a63",
-          /*android_arm64_clang=*/"76da9b7514f986fc2bb32b1c3170e8d4",
-          /*mac_arm64=*/"76da9b7514f986fc2bb32b1c3170e8d4"),
+          /*android_arm64_clang=*/"1ad29139a04782a33daad8c2b9b35875",
+          /*mac_arm64=*/"1ad29139a04782a33daad8c2b9b35875"),
      AcmReceiverBitExactnessOldApi::PlatformChecksum(
          /*others=*/"9e0a0ab743ad987b55b8e14802769c56",
          /*win64=*/"ebe04a819d3a9d83a83a17f271e1139a",
@ -1330,10 +1330,10 @@ TEST_F(AcmSenderBitExactnessOldApi, IsacWb60ms) {
 TEST_F(AcmSenderBitExactnessOldApi, MAYBE_IsacSwb30ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 32000, 1, 104, 960, 960));
  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
-          /*others=*/"f4cf577f28a0dcbac33358b757518e0c",
+          /*others=*/"5683b58da0fbf2063c7adc2e6bfb3fb8",
          /*win64=*/"2b3c387d06f00b7b7aad4c9be56fb83d", "android_arm32_audio",
          "android_arm64_audio", "android_arm64_clang_audio",
-          /*mac_arm64=*/"f4cf577f28a0dcbac33358b757518e0c"),
+          /*mac_arm64=*/"5683b58da0fbf2063c7adc2e6bfb3fb8"),
      AcmReceiverBitExactnessOldApi::PlatformChecksum(
          /*others=*/"ce86106a93419aefb063097108ec94ab",
          /*win64=*/"bcc2041e7744c7ebd9f701866856849c", "android_arm32_payload",
@ -1345,61 +1345,61 @@ TEST_F(AcmSenderBitExactnessOldApi, MAYBE_IsacSwb30ms) {

 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_8000khz_10ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 8000, 1, 107, 80, 80));
-  Run("69118ed438ac76252d023e0463819471", "c1edd36339ce0326cc4550041ad719a0",
+  Run("15396f66b5b0ab6842e151c807395e4c", "c1edd36339ce0326cc4550041ad719a0",
      100, test::AcmReceiveTestOldApi::kMonoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_16000khz_10ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 16000, 1, 108, 160, 160));
-  Run("bc6ab94d12a464921763d7544fdbd07e", "ad786526383178b08d80d6eee06e9bad",
+  Run("54ae004529874c2b362c7f0ccd19cb99", "ad786526383178b08d80d6eee06e9bad",
      100, test::AcmReceiveTestOldApi::kMonoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_32000khz_10ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 32000, 1, 109, 320, 320));
-  Run("c50244419c5c3a2f04cc69a022c266a2", "5ef82ea885e922263606c6fdbc49f651",
+  Run("d6a4a68b8c838dcc1e7ae7136467cdf0", "5ef82ea885e922263606c6fdbc49f651",
      100, test::AcmReceiveTestOldApi::kMonoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_stereo_8000khz_10ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 8000, 2, 111, 80, 80));
-  Run("4fccf4cc96f1e8e8de4b9fadf62ded9e", "62ce5adb0d4965d0a52ec98ae7f98974",
+  Run("6b011dab43e3a8a46ccff7e4412ed8a2", "62ce5adb0d4965d0a52ec98ae7f98974",
      100, test::AcmReceiveTestOldApi::kStereoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_stereo_16000khz_10ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 16000, 2, 112, 160, 160));
-  Run("e15e388d9d4af8c02a59fe1552fedee3", "41ca8edac4b8c71cd54fd9f25ec14870",
+  Run("17fc9854358bfe0419408290664bd78e", "41ca8edac4b8c71cd54fd9f25ec14870",
      100, test::AcmReceiveTestOldApi::kStereoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_stereo_32000khz_10ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 32000, 2, 113, 320, 320));
-  Run("b240520c0d05003fde7a174ae5957286", "50e58502fb04421bf5b857dda4c96879",
+  Run("9ac9a1f64d55da2fc9f3167181cc511d", "50e58502fb04421bf5b857dda4c96879",
      100, test::AcmReceiveTestOldApi::kStereoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcmu_20ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("PCMU", 8000, 1, 0, 160, 160));
-  Run("c8d1fc677f33c2022ec5f83c7f302280", "8f9b8750bd80fe26b6cbf6659b89f0f9",
+  Run("81a9d4c0bb72e9becc43aef124c981e9", "8f9b8750bd80fe26b6cbf6659b89f0f9",
      50, test::AcmReceiveTestOldApi::kMonoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcma_20ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("PCMA", 8000, 1, 8, 160, 160));
-  Run("47eb60e855eb12d1b0e6da9c975754a4", "6ad745e55aa48981bfc790d0eeef2dd1",
+  Run("39611f798969053925a49dc06d08de29", "6ad745e55aa48981bfc790d0eeef2dd1",
      50, test::AcmReceiveTestOldApi::kMonoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcmu_stereo_20ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("PCMU", 8000, 2, 110, 160, 160));
-  Run("6ef2f57d4934714787fd0a834e3ea18e", "60b6f25e8d1e74cb679cfe756dd9bca5",
+  Run("437bec032fdc5cbaa0d5175430af7b18", "60b6f25e8d1e74cb679cfe756dd9bca5",
      50, test::AcmReceiveTestOldApi::kStereoOutput);
 }

 TEST_F(AcmSenderBitExactnessOldApi, Pcma_stereo_20ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("PCMA", 8000, 2, 118, 160, 160));
-  Run("a84d75e098d87ab6b260687eb4b612a2", "92b282c83efd20e7eeef52ba40842cf7",
+  Run("a5c6d83c5b7cedbeff734238220a4b0c", "92b282c83efd20e7eeef52ba40842cf7",
      50, test::AcmReceiveTestOldApi::kStereoOutput);
 }

@ -1412,10 +1412,10 @@ TEST_F(AcmSenderBitExactnessOldApi, Pcma_stereo_20ms) {
 TEST_F(AcmSenderBitExactnessOldApi, MAYBE_Ilbc_30ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("ILBC", 8000, 1, 102, 240, 240));
  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
-          /*others=*/"b14dba0de36efa5ec88a32c0b320b70f",
-          /*win64=*/"b14dba0de36efa5ec88a32c0b320b70f", "android_arm32_audio",
+          /*others=*/"7b6ec10910debd9af08011d3ed5249f7",
+          /*win64=*/"7b6ec10910debd9af08011d3ed5249f7", "android_arm32_audio",
          "android_arm64_audio", "android_arm64_clang_audio",
-          /*mac_arm64=*/"b14dba0de36efa5ec88a32c0b320b70f"),
+          /*mac_arm64=*/"7b6ec10910debd9af08011d3ed5249f7"),
      AcmReceiverBitExactnessOldApi::PlatformChecksum(
          /*others=*/"cfae2e9f6aba96e145f2bcdd5050ce78",
          /*win64=*/"cfae2e9f6aba96e145f2bcdd5050ce78", "android_arm32_payload",
@ -1433,10 +1433,10 @@ TEST_F(AcmSenderBitExactnessOldApi, MAYBE_Ilbc_30ms) {
 TEST_F(AcmSenderBitExactnessOldApi, MAYBE_G722_20ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("G722", 16000, 1, 9, 320, 160));
  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
-          /*others=*/"a87a91ec0124510a64967f5d768554ff",
-          /*win64=*/"a87a91ec0124510a64967f5d768554ff", "android_arm32_audio",
+          /*others=*/"e99c89be49a46325d03c0d990c292d68",
+          /*win64=*/"e99c89be49a46325d03c0d990c292d68", "android_arm32_audio",
          "android_arm64_audio", "android_arm64_clang_audio",
-          /*mac_arm64=*/"a87a91ec0124510a64967f5d768554ff"),
+          /*mac_arm64=*/"e99c89be49a46325d03c0d990c292d68"),
      AcmReceiverBitExactnessOldApi::PlatformChecksum(
          /*others=*/"fc68a87e1380614e658087cb35d5ca10",
          /*win64=*/"fc68a87e1380614e658087cb35d5ca10", "android_arm32_payload",
@ -1453,10 +1453,10 @@ TEST_F(AcmSenderBitExactnessOldApi, MAYBE_G722_20ms) {
 TEST_F(AcmSenderBitExactnessOldApi, MAYBE_G722_stereo_20ms) {
  ASSERT_NO_FATAL_FAILURE(SetUpTest("G722", 16000, 2, 119, 320, 160));
  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
-          /*others=*/"be0b8528ff9db3a2219f55ddd36faf7f",
-          /*win64=*/"be0b8528ff9db3a2219f55ddd36faf7f", "android_arm32_audio",
+          /*others=*/"e280aed283e499d37091b481ca094807",
+          /*win64=*/"e280aed283e499d37091b481ca094807", "android_arm32_audio",
          "android_arm64_audio", "android_arm64_clang_audio",
-          /*mac_arm64=*/"be0b8528ff9db3a2219f55ddd36faf7f"),
+          /*mac_arm64=*/"e280aed283e499d37091b481ca094807"),
      AcmReceiverBitExactnessOldApi::PlatformChecksum(
          /*others=*/"66516152eeaa1e650ad94ff85f668dac",
          /*win64=*/"66516152eeaa1e650ad94ff85f668dac", "android_arm32_payload",
@ -1831,7 +1831,7 @@ TEST_F(AcmSenderBitExactnessOldApi, External_Pcmu_20ms) {
  ASSERT_TRUE(SetUpSender(kTestFileMono32kHz, 32000));
  ASSERT_NO_FATAL_FAILURE(
      SetUpTestExternalEncoder(std::move(mock_encoder), config.payload_type));
-  Run("c8d1fc677f33c2022ec5f83c7f302280", "8f9b8750bd80fe26b6cbf6659b89f0f9",
+  Run("81a9d4c0bb72e9becc43aef124c981e9", "8f9b8750bd80fe26b6cbf6659b89f0f9",
      50, test::AcmReceiveTestOldApi::kMonoOutput);
 }

--- a/modules/audio_coding/neteq/delay_manager.cc
+++ b/modules/audio_coding/neteq/delay_manager.cc
@ -20,7 +20,6 @@

 #include "modules/include/module_common_types_public.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/experiments/struct_parameters_parser.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/numerics/safe_minmax.h"
@ -46,17 +45,9 @@ std::unique_ptr<ReorderOptimizer> MaybeCreateReorderOptimizer(
 }  // namespace

 DelayManager::Config::Config() {
-  StructParametersParser::Create(                       //
-      "quantile", &quantile,                            //
-      "forget_factor", &forget_factor,                  //
-      "start_forget_weight", &start_forget_weight,      //
-      "resample_interval_ms", &resample_interval_ms,    //
-      "max_history_ms", &max_history_ms,                //
-      "use_reorder_optimizer", &use_reorder_optimizer,  //
-      "reorder_forget_factor", &reorder_forget_factor,  //
-      "ms_per_loss_percent", &ms_per_loss_percent)
-      ->Parse(webrtc::field_trial::FindFullName(
-          "WebRTC-Audio-NetEqDelayManagerConfig"));
+  Parser()->Parse(webrtc::field_trial::FindFullName(
+      "WebRTC-Audio-NetEqDelayManagerConfig"));
+  MaybeUpdateFromLegacyFieldTrial();
 }

 void DelayManager::Config::Log() {
@ -72,6 +63,42 @@ void DelayManager::Config::Log() {
                   << " ms_per_loss_percent=" << ms_per_loss_percent;
 }

+std::unique_ptr<StructParametersParser> DelayManager::Config::Parser() {
+  return StructParametersParser::Create(                //
+      "quantile", &quantile,                            //
+      "forget_factor", &forget_factor,                  //
+      "start_forget_weight", &start_forget_weight,      //
+      "resample_interval_ms", &resample_interval_ms,    //
+      "max_history_ms", &max_history_ms,                //
+      "use_reorder_optimizer", &use_reorder_optimizer,  //
+      "reorder_forget_factor", &reorder_forget_factor,  //
+      "ms_per_loss_percent", &ms_per_loss_percent);
+}
+
+// TODO(jakobi): remove legacy field trial.
+void DelayManager::Config::MaybeUpdateFromLegacyFieldTrial() {
+  constexpr char kDelayHistogramFieldTrial[] =
+      "WebRTC-Audio-NetEqDelayHistogram";
+  if (!webrtc::field_trial::IsEnabled(kDelayHistogramFieldTrial)) {
+    return;
+  }
+  const auto field_trial_string =
+      webrtc::field_trial::FindFullName(kDelayHistogramFieldTrial);
+  double percentile = -1.0;
+  double forget_factor = -1.0;
+  double start_forget_weight = -1.0;
+  if (sscanf(field_trial_string.c_str(), "Enabled-%lf-%lf-%lf", &percentile,
+             &forget_factor, &start_forget_weight) >= 2 &&
+      percentile >= 0.0 && percentile <= 100.0 && forget_factor >= 0.0 &&
+      forget_factor <= 1.0) {
+    this->quantile = percentile / 100;
+    this->forget_factor = forget_factor;
+    this->start_forget_weight = start_forget_weight >= 1
+                                    ? absl::make_optional(start_forget_weight)
+                                    : absl::nullopt;
+  }
+}
+
 DelayManager::DelayManager(const Config& config, const TickTimer* tick_timer)
    : max_packets_in_buffer_(config.max_packets_in_buffer),
      underrun_optimizer_(tick_timer,
--- a/modules/audio_coding/neteq/delay_manager.h
+++ b/modules/audio_coding/neteq/delay_manager.h
@ -23,6 +23,7 @@
 #include "modules/audio_coding/neteq/reorder_optimizer.h"
 #include "modules/audio_coding/neteq/underrun_optimizer.h"
 #include "rtc_base/constructor_magic.h"
+#include "rtc_base/experiments/struct_parameters_parser.h"

 namespace webrtc {

@ -33,10 +34,10 @@ class DelayManager {
    void Log();

    // Options that can be configured via field trial.
-    double quantile = 0.95;
-    double forget_factor = 0.983;
+    double quantile = 0.97;
+    double forget_factor = 0.9993;
    absl::optional<double> start_forget_weight = 2;
-    absl::optional<int> resample_interval_ms = 500;
+    absl::optional<int> resample_interval_ms;
    int max_history_ms = 2000;

    bool use_reorder_optimizer = true;
@ -46,6 +47,12 @@ class DelayManager {
    // Options that are externally populated.
    int max_packets_in_buffer = 200;
    int base_minimum_delay_ms = 0;
+
+   private:
+    std::unique_ptr<StructParametersParser> Parser();
+
+    // TODO(jakobi): remove legacy field trial.
+    void MaybeUpdateFromLegacyFieldTrial();
  };

  DelayManager(const Config& config, const TickTimer* tick_timer);
--- a/modules/audio_coding/neteq/delay_manager_unittest.cc
+++ b/modules/audio_coding/neteq/delay_manager_unittest.cc
@ -44,8 +44,8 @@ class DelayManagerTest : public ::testing::Test {
  absl::optional<int> InsertNextPacket();
  void IncreaseTime(int inc_ms);

-  TickTimer tick_timer_;
  DelayManager dm_;
+  TickTimer tick_timer_;
  uint32_t ts_;
 };

@ -74,18 +74,39 @@ TEST_F(DelayManagerTest, CreateAndDestroy) {
 }

 TEST_F(DelayManagerTest, UpdateNormal) {
-  for (int i = 0; i < 50; ++i) {
-    InsertNextPacket();
-    IncreaseTime(kFrameSizeMs);
-  }
+  // First packet arrival.
+  InsertNextPacket();
+  // Advance time by one frame size.
+  IncreaseTime(kFrameSizeMs);
+  // Second packet arrival.
+  InsertNextPacket();
  EXPECT_EQ(20, dm_.TargetDelayMs());
 }

-TEST_F(DelayManagerTest, MaxDelay) {
+TEST_F(DelayManagerTest, UpdateLongInterArrivalTime) {
+  // First packet arrival.
  InsertNextPacket();
-  const int kMaxDelayMs = 60;
-  EXPECT_GT(dm_.TargetDelayMs(), kMaxDelayMs);
+  // Advance time by two frame size.
+  IncreaseTime(2 * kFrameSizeMs);
+  // Second packet arrival.
+  InsertNextPacket();
+  EXPECT_EQ(40, dm_.TargetDelayMs());
+}
+
+TEST_F(DelayManagerTest, MaxDelay) {
+  const int kExpectedTarget = 5 * kFrameSizeMs;
+  // First packet arrival.
+  InsertNextPacket();
+  // Second packet arrival.
+  IncreaseTime(kExpectedTarget);
+  InsertNextPacket();
+
+  // No limit is set.
+  EXPECT_EQ(kExpectedTarget, dm_.TargetDelayMs());
+
+  const int kMaxDelayMs = 3 * kFrameSizeMs;
  EXPECT_TRUE(dm_.SetMaximumDelay(kMaxDelayMs));
+  IncreaseTime(kFrameSizeMs);
  InsertNextPacket();
  EXPECT_EQ(kMaxDelayMs, dm_.TargetDelayMs());

@ -94,9 +115,17 @@ TEST_F(DelayManagerTest, MaxDelay) {
 }

 TEST_F(DelayManagerTest, MinDelay) {
+  const int kExpectedTarget = 5 * kFrameSizeMs;
+  // First packet arrival.
  InsertNextPacket();
+  // Second packet arrival.
+  IncreaseTime(kExpectedTarget);
+  InsertNextPacket();
+
+  // No limit is applied.
+  EXPECT_EQ(kExpectedTarget, dm_.TargetDelayMs());
+
  int kMinDelayMs = 7 * kFrameSizeMs;
-  EXPECT_LT(dm_.TargetDelayMs(), kMinDelayMs);
  dm_.SetMinimumDelay(kMinDelayMs);
  IncreaseTime(kFrameSizeMs);
  InsertNextPacket();
@ -222,11 +251,48 @@ TEST_F(DelayManagerTest, MinimumDelayMemorization) {
 }

 TEST_F(DelayManagerTest, BaseMinimumDelay) {
+  const int kExpectedTarget = 5 * kFrameSizeMs;
  // First packet arrival.
  InsertNextPacket();
+  // Second packet arrival.
+  IncreaseTime(kExpectedTarget);
+  InsertNextPacket();
+
+  // No limit is applied.
+  EXPECT_EQ(kExpectedTarget, dm_.TargetDelayMs());

  constexpr int kBaseMinimumDelayMs = 7 * kFrameSizeMs;
-  EXPECT_LT(dm_.TargetDelayMs(), kBaseMinimumDelayMs);
+  EXPECT_TRUE(dm_.SetBaseMinimumDelay(kBaseMinimumDelayMs));
+  EXPECT_EQ(dm_.GetBaseMinimumDelay(), kBaseMinimumDelayMs);
+
+  IncreaseTime(kFrameSizeMs);
+  InsertNextPacket();
+  EXPECT_EQ(dm_.GetBaseMinimumDelay(), kBaseMinimumDelayMs);
+  EXPECT_EQ(kBaseMinimumDelayMs, dm_.TargetDelayMs());
+}
+
+TEST_F(DelayManagerTest, BaseMinimumDelayAffectsTargetDelay) {
+  const int kExpectedTarget = 5;
+  const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
+  // First packet arrival.
+  InsertNextPacket();
+  // Second packet arrival.
+  IncreaseTime(kTimeIncrement);
+  InsertNextPacket();
+
+  // No limit is applied.
+  EXPECT_EQ(kTimeIncrement, dm_.TargetDelayMs());
+
+  // Minimum delay is lower than base minimum delay, that is why base minimum
+  // delay is used to calculate target level.
+  constexpr int kMinimumDelayPackets = kExpectedTarget + 1;
+  constexpr int kBaseMinimumDelayPackets = kExpectedTarget + 2;
+
+  constexpr int kMinimumDelayMs = kMinimumDelayPackets * kFrameSizeMs;
+  constexpr int kBaseMinimumDelayMs = kBaseMinimumDelayPackets * kFrameSizeMs;
+
+  EXPECT_TRUE(kMinimumDelayMs < kBaseMinimumDelayMs);
+  EXPECT_TRUE(dm_.SetMinimumDelay(kMinimumDelayMs));
  EXPECT_TRUE(dm_.SetBaseMinimumDelay(kBaseMinimumDelayMs));
  EXPECT_EQ(dm_.GetBaseMinimumDelay(), kBaseMinimumDelayMs);

--- a/modules/audio_coding/neteq/neteq_impl.cc
+++ b/modules/audio_coding/neteq/neteq_impl.cc
@ -1370,7 +1370,7 @@ int NetEqImpl::GetDecision(Operation* operation,
    }
  }

-  timestamp_ = sync_buffer_->end_timestamp();
+  timestamp_ = end_timestamp;
  return 0;
 }

--- a/modules/audio_coding/neteq/neteq_impl_unittest.cc
+++ b/modules/audio_coding/neteq/neteq_impl_unittest.cc
@ -1026,37 +1026,22 @@ TEST_F(NetEqImplTest, CodecInternalCng) {
  EXPECT_CALL(mock_decoder, PacketDuration(nullptr, 0))
      .WillRepeatedly(Return(rtc::checked_cast<int>(kPayloadLengthSamples)));

-  EXPECT_TRUE(neteq_->RegisterPayloadType(kPayloadType,
-                                          SdpAudioFormat("opus", 48000, 2)));
+  // Pointee(x) verifies that first byte of the payload equals x, this makes it
+  // possible to verify that the correct payload is fed to Decode().
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(0), kPayloadLengthBytes,
+                                           kSampleRateKhz * 1000, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
+                                          dummy_output + kPayloadLengthSamples),
+                      SetArgPointee<4>(AudioDecoder::kSpeech),
+                      Return(rtc::checked_cast<int>(kPayloadLengthSamples))));

-  struct Packet {
-    int sequence_number_delta;
-    int timestamp_delta;
-    AudioDecoder::SpeechType decoder_output_type;
-  };
-  std::vector<Packet> packets = {
-      {0, 0, AudioDecoder::kSpeech},
-      {1, kPayloadLengthSamples, AudioDecoder::kComfortNoise},
-      {2, 2 * kPayloadLengthSamples, AudioDecoder::kSpeech},
-      {1, kPayloadLengthSamples, AudioDecoder::kSpeech}};
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(1), kPayloadLengthBytes,
+                                           kSampleRateKhz * 1000, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
+                                          dummy_output + kPayloadLengthSamples),
+                      SetArgPointee<4>(AudioDecoder::kComfortNoise),
+                      Return(rtc::checked_cast<int>(kPayloadLengthSamples))));

-  for (size_t i = 0; i < packets.size(); ++i) {
-    rtp_header.sequenceNumber += packets[i].sequence_number_delta;
-    rtp_header.timestamp += packets[i].timestamp_delta;
-    payload[0] = i;
-    EXPECT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header, payload));
-
-    // Pointee(x) verifies that first byte of the payload equals x, this makes
-    // it possible to verify that the correct payload is fed to Decode().
-    EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(i), kPayloadLengthBytes,
-                                             kSampleRateKhz * 1000, _, _))
-        .WillOnce(DoAll(SetArrayArgument<3>(
-                            dummy_output, dummy_output + kPayloadLengthSamples),
-                        SetArgPointee<4>(packets[i].decoder_output_type),
-                        Return(rtc::checked_cast<int>(kPayloadLengthSamples))));
-  }
-
-  // Expect comfort noise to be returned by the decoder.
  EXPECT_CALL(mock_decoder,
              DecodeInternal(IsNull(), 0, kSampleRateKhz * 1000, _, _))
      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
@ -1064,24 +1049,87 @@ TEST_F(NetEqImplTest, CodecInternalCng) {
                      SetArgPointee<4>(AudioDecoder::kComfortNoise),
                      Return(rtc::checked_cast<int>(kPayloadLengthSamples))));

-  std::vector<AudioFrame::SpeechType> expected_output = {
-      AudioFrame::kNormalSpeech, AudioFrame::kCNG, AudioFrame::kNormalSpeech};
-  size_t output_index = 0;
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(2), kPayloadLengthBytes,
+                                           kSampleRateKhz * 1000, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
+                                          dummy_output + kPayloadLengthSamples),
+                      SetArgPointee<4>(AudioDecoder::kSpeech),
+                      Return(rtc::checked_cast<int>(kPayloadLengthSamples))));

-  int timeout_counter = 0;
-  while (!packet_buffer_->Empty()) {
-    ASSERT_LT(timeout_counter++, 20) << "Test timed out";
-    AudioFrame output;
-    bool muted;
-    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
-    if (output_index + 1 < expected_output.size() &&
-        output.speech_type_ == expected_output[output_index + 1]) {
-      ++output_index;
+  EXPECT_TRUE(neteq_->RegisterPayloadType(kPayloadType,
+                                          SdpAudioFormat("opus", 48000, 2)));
+
+  const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateKhz);
+  AudioFrame output;
+  AudioFrame::SpeechType expected_type[8] = {
+      AudioFrame::kNormalSpeech, AudioFrame::kNormalSpeech, AudioFrame::kCNG,
+      AudioFrame::kCNG,          AudioFrame::kCNG,          AudioFrame::kCNG,
+      AudioFrame::kNormalSpeech, AudioFrame::kNormalSpeech};
+  int expected_timestamp_increment[8] = {
+      -1,  // will not be used.
+      10 * kSampleRateKhz,
+      -1,
+      -1,  // timestamp will be empty during CNG mode; indicated by -1 here.
+      -1,
+      -1,
+      50 * kSampleRateKhz,
+      10 * kSampleRateKhz};
+
+  // Insert one packet (decoder will return speech).
+  EXPECT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header, payload));
+
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
+  absl::optional<uint32_t> last_timestamp = neteq_->GetPlayoutTimestamp();
+  ASSERT_TRUE(last_timestamp);
+
+  // Insert second packet (decoder will return CNG).
+  payload[0] = 1;
+  rtp_header.sequenceNumber++;
+  rtp_header.timestamp += kPayloadLengthSamples;
+  EXPECT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header, payload));
+
+  // Lambda for verifying the timestamps.
+  auto verify_timestamp = [&last_timestamp, &expected_timestamp_increment](
+                              absl::optional<uint32_t> ts, size_t i) {
+    if (expected_timestamp_increment[i] == -1) {
+      // Expect to get an empty timestamp value during CNG and PLC.
+      EXPECT_FALSE(ts) << "i = " << i;
    } else {
-      EXPECT_EQ(output.speech_type_, expected_output[output_index]);
+      ASSERT_TRUE(ts) << "i = " << i;
+      EXPECT_EQ(*ts, *last_timestamp + expected_timestamp_increment[i])
+          << "i = " << i;
+      last_timestamp = ts;
    }
+  };
+
+  for (size_t i = 1; i < 6; ++i) {
+    ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
+    EXPECT_EQ(1u, output.num_channels_);
+    EXPECT_EQ(expected_type[i - 1], output.speech_type_);
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
+    SCOPED_TRACE("");
+    verify_timestamp(neteq_->GetPlayoutTimestamp(), i);
  }

+  // Insert third packet, which leaves a gap from last packet.
+  payload[0] = 2;
+  rtp_header.sequenceNumber += 2;
+  rtp_header.timestamp += 2 * kPayloadLengthSamples;
+  EXPECT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header, payload));
+
+  for (size_t i = 6; i < 8; ++i) {
+    ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
+    EXPECT_EQ(1u, output.num_channels_);
+    EXPECT_EQ(expected_type[i - 1], output.speech_type_);
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
+    SCOPED_TRACE("");
+    verify_timestamp(neteq_->GetPlayoutTimestamp(), i);
+  }
+
+  // Now check the packet buffer, and make sure it is empty.
+  EXPECT_TRUE(packet_buffer_->Empty());
+
  EXPECT_CALL(mock_decoder, Die());
 }

--- a/modules/audio_coding/neteq/neteq_network_stats_unittest.cc
+++ b/modules/audio_coding/neteq/neteq_network_stats_unittest.cc
@ -274,7 +274,7 @@ class NetEqNetworkStatsTest {

    // Next we introduce packet losses.
    SetPacketLossRate(0.1);
-    expects.stats_ref.expand_rate = expects.stats_ref.speech_expand_rate = 898;
+    expects.stats_ref.expand_rate = expects.stats_ref.speech_expand_rate = 1065;
    RunTest(50, expects);

    // Next we enable FEC.
--- a/modules/audio_coding/neteq/neteq_unittest.cc
+++ b/modules/audio_coding/neteq/neteq_unittest.cc
@ -82,17 +82,17 @@ TEST_F(NetEqDecodingTest, MAYBE_TestBitExactness) {
  const std::string input_rtp_file =
      webrtc::test::ResourcePath("audio_coding/neteq_universal_new", "rtp");

-  const std::string output_checksum =
-      PlatformChecksum("ba4fae83a52f5e9d95b0910f05d540114285697b",
-                       "aa557f30f7fdcebbbbf99d7f235ccba3a1c98983", "not used",
-                       "ba4fae83a52f5e9d95b0910f05d540114285697b",
-                       "64b46bb3c1165537a880ae8404afce2efba456c0");
+  const std::string output_checksum = PlatformChecksum(
+      "6c35140ce4d75874bdd60aa1872400b05fd05ca2",
+      "ab451bb8301d9a92fbf4de91556b56f1ea38b4ce", "not used",
+      "6c35140ce4d75874bdd60aa1872400b05fd05ca2",
+      "64b46bb3c1165537a880ae8404afce2efba456c0");

-  const std::string network_stats_checksum =
-      PlatformChecksum("fa878a8464ef1cb3d01503b7f927c3e2ce6f02c4",
-                       "300ccc2aaee7ed1971afb2f9a20247ed8760441d", "not used",
-                       "fa878a8464ef1cb3d01503b7f927c3e2ce6f02c4",
-                       "fa878a8464ef1cb3d01503b7f927c3e2ce6f02c4");
+  const std::string network_stats_checksum = PlatformChecksum(
+      "90594d85fa31d3d9584d79293bf7aa4ee55ed751",
+      "77b9c3640b81aff6a38d69d07dd782d39c15321d", "not used",
+      "90594d85fa31d3d9584d79293bf7aa4ee55ed751",
+      "90594d85fa31d3d9584d79293bf7aa4ee55ed751");

  DecodeAndCompare(input_rtp_file, output_checksum, network_stats_checksum,
                   absl::GetFlag(FLAGS_gen_ref));
@ -531,16 +531,11 @@ TEST_F(NetEqDecodingTest, DiscardDuplicateCng) {
              out_frame_.timestamp_ + out_frame_.samples_per_channel_);
  }

+  // Insert speech again.
  ++seq_no;
  timestamp += kCngPeriodSamples;
-  uint32_t first_speech_timestamp = timestamp;
-  // Insert speech again.
-  for (int i = 0; i < 3; ++i) {
-    PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload));
-    ++seq_no;
-    timestamp += kSamples;
-  }
+  PopulateRtpInfo(seq_no, timestamp, &rtp_info);
+  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload));

  // Pull audio once and verify that the output is speech again.
  ASSERT_EQ(0, neteq_->GetAudio(&out_frame_, &muted));
@ -548,7 +543,7 @@ TEST_F(NetEqDecodingTest, DiscardDuplicateCng) {
  EXPECT_EQ(AudioFrame::kNormalSpeech, out_frame_.speech_type_);
  absl::optional<uint32_t> playout_timestamp = neteq_->GetPlayoutTimestamp();
  ASSERT_TRUE(playout_timestamp);
-  EXPECT_EQ(first_speech_timestamp + kSamples - algorithmic_delay_samples,
+  EXPECT_EQ(timestamp + kSamples - algorithmic_delay_samples,
            *playout_timestamp);
 }

@ -1268,7 +1263,7 @@ TEST(NetEqOutputDelayTest, RunTestWithFieldTrial) {
  // The base delay values are taken from the resuts of the non-delayed case in
  // NetEqOutputDelayTest.RunTest above.
  EXPECT_EQ(20 + kExpectedDelayMs, result.target_delay_ms);
-  EXPECT_EQ(60 + kExpectedDelayMs, result.filtered_current_delay_ms);
+  EXPECT_EQ(24 + kExpectedDelayMs, result.filtered_current_delay_ms);
 }

 // Set a non-multiple-of-10 value in the field trial, and verify that we don't
@ -1283,7 +1278,7 @@ TEST(NetEqOutputDelayTest, RunTestWithFieldTrialOddValue) {
  // The base delay values are taken from the resuts of the non-delayed case in
  // NetEqOutputDelayTest.RunTest above.
  EXPECT_EQ(20 + kRoundedDelayMs, result.target_delay_ms);
-  EXPECT_EQ(60 + kRoundedDelayMs, result.filtered_current_delay_ms);
+  EXPECT_EQ(24 + kRoundedDelayMs, result.filtered_current_delay_ms);
 }

 }  // namespace test
--- a/modules/audio_coding/neteq/relative_arrival_delay_tracker.cc
+++ b/modules/audio_coding/neteq/relative_arrival_delay_tracker.cc
@ -49,7 +49,7 @@ absl::optional<int> RelativeArrivalDelayTracker::Update(uint32_t timestamp,

 void RelativeArrivalDelayTracker::Reset() {
  delay_history_.clear();
-  packet_iat_stopwatch_.reset();
+  packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
  newest_timestamp_ = absl::nullopt;
  last_timestamp_ = absl::nullopt;
 }
--- a/modules/audio_coding/neteq/test/neteq_decoding_test.cc
+++ b/modules/audio_coding/neteq/test/neteq_decoding_test.cc
@ -245,9 +245,15 @@ void NetEqDecodingTest::WrapTest(uint16_t start_seq_no,
      NetEqNetworkStatistics network_stats;
      ASSERT_EQ(0, neteq_->NetworkStatistics(&network_stats));

-      EXPECT_LE(network_stats.preferred_buffer_size_ms, 80);
-      EXPECT_LE(network_stats.current_buffer_size_ms,
-                80 + algorithmic_delay_ms_);
+      // Due to internal NetEq logic, preferred buffer-size is about 4 times the
+      // packet size for first few packets. Therefore we refrain from checking
+      // the criteria.
+      if (packets_inserted > 4) {
+        // Expect preferred and actual buffer size to be no more than 2 frames.
+        EXPECT_LE(network_stats.preferred_buffer_size_ms, kFrameSizeMs * 2);
+        EXPECT_LE(network_stats.current_buffer_size_ms,
+                  kFrameSizeMs * 2 + algorithmic_delay_ms_);
+      }
      last_seq_no = seq_no;
      last_timestamp = timestamp;

--- a/modules/audio_coding/neteq/underrun_optimizer.cc
+++ b/modules/audio_coding/neteq/underrun_optimizer.cc
@ -63,7 +63,7 @@ void UnderrunOptimizer::Update(int relative_delay_ms) {

 void UnderrunOptimizer::Reset() {
  histogram_.Reset();
-  resample_stopwatch_.reset();
+  resample_stopwatch_ = tick_timer_->GetNewStopwatch();
  max_delay_in_interval_ms_ = 0;
  optimal_delay_ms_.reset();
 }