tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

render_delay_buffer_unittest.cc (4681B)

      1 /*
      2 *  Copyright (c) 2017 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 #include "modules/audio_processing/aec3/render_delay_buffer.h"
     12 
     13 #include <cstddef>
     14 #include <memory>
     15 #include <string>
     16 
     17 #include "api/audio/echo_canceller3_config.h"
     18 #include "modules/audio_processing/aec3/aec3_common.h"
     19 #include "modules/audio_processing/aec3/block.h"
     20 #include "rtc_base/checks.h"
     21 #include "rtc_base/strings/string_builder.h"
     22 #include "test/gtest.h"
     23 
     24 namespace webrtc {
     25 namespace {
     26 
     27 std::string ProduceDebugText(int sample_rate_hz) {
     28  StringBuilder ss;
     29  ss << "Sample rate: " << sample_rate_hz;
     30  return ss.Release();
     31 }
     32 
     33 }  // namespace
     34 
     35 // Verifies that the buffer overflow is correctly reported.
     36 TEST(RenderDelayBuffer, BufferOverflow) {
     37  const EchoCanceller3Config config;
     38  for (auto num_channels : {1, 2, 8}) {
     39    for (auto rate : {16000, 32000, 48000}) {
     40      SCOPED_TRACE(ProduceDebugText(rate));
     41      std::unique_ptr<RenderDelayBuffer> delay_buffer(
     42          RenderDelayBuffer::Create(config, rate, num_channels));
     43      Block block_to_insert(NumBandsForRate(rate), num_channels);
     44      for (size_t k = 0; k < 10; ++k) {
     45        EXPECT_EQ(RenderDelayBuffer::BufferingEvent::kNone,
     46                  delay_buffer->Insert(block_to_insert));
     47      }
     48      bool overrun_occurred = false;
     49      for (size_t k = 0; k < 1000; ++k) {
     50        RenderDelayBuffer::BufferingEvent event =
     51            delay_buffer->Insert(block_to_insert);
     52        overrun_occurred =
     53            overrun_occurred ||
     54            RenderDelayBuffer::BufferingEvent::kRenderOverrun == event;
     55      }
     56 
     57      EXPECT_TRUE(overrun_occurred);
     58    }
     59  }
     60 }
     61 
     62 // Verifies that the check for available block works.
     63 TEST(RenderDelayBuffer, AvailableBlock) {
     64  constexpr size_t kNumChannels = 1;
     65  constexpr int kSampleRateHz = 48000;
     66  constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz);
     67  std::unique_ptr<RenderDelayBuffer> delay_buffer(RenderDelayBuffer::Create(
     68      EchoCanceller3Config(), kSampleRateHz, kNumChannels));
     69  Block input_block(kNumBands, kNumChannels, 1.0f);
     70  EXPECT_EQ(RenderDelayBuffer::BufferingEvent::kNone,
     71            delay_buffer->Insert(input_block));
     72  delay_buffer->PrepareCaptureProcessing();
     73 }
     74 
     75 // Verifies the AlignFromDelay method.
     76 TEST(RenderDelayBuffer, AlignFromDelay) {
     77  EchoCanceller3Config config;
     78  std::unique_ptr<RenderDelayBuffer> delay_buffer(
     79      RenderDelayBuffer::Create(config, 16000, 1));
     80  ASSERT_TRUE(delay_buffer->Delay());
     81  delay_buffer->Reset();
     82  size_t initial_internal_delay = 0;
     83  for (size_t delay = initial_internal_delay;
     84       delay < initial_internal_delay + 20; ++delay) {
     85    ASSERT_TRUE(delay_buffer->AlignFromDelay(delay));
     86    EXPECT_EQ(delay, delay_buffer->Delay());
     87  }
     88 }
     89 
     90 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
     91 
     92 // Verifies the check for feasible delay.
     93 // TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
     94 // tests on test bots has been fixed.
     95 TEST(RenderDelayBufferDeathTest, DISABLED_WrongDelay) {
     96  std::unique_ptr<RenderDelayBuffer> delay_buffer(
     97      RenderDelayBuffer::Create(EchoCanceller3Config(), 48000, 1));
     98  EXPECT_DEATH(delay_buffer->AlignFromDelay(21), "");
     99 }
    100 
    101 // Verifies the check for the number of bands in the inserted blocks.
    102 TEST(RenderDelayBufferDeathTest, WrongNumberOfBands) {
    103  for (auto rate : {16000, 32000, 48000}) {
    104    for (size_t num_channels : {1, 2, 8}) {
    105      SCOPED_TRACE(ProduceDebugText(rate));
    106      std::unique_ptr<RenderDelayBuffer> delay_buffer(RenderDelayBuffer::Create(
    107          EchoCanceller3Config(), rate, num_channels));
    108      Block block_to_insert(
    109          NumBandsForRate(rate < 48000 ? rate + 16000 : 16000), num_channels);
    110      EXPECT_DEATH(delay_buffer->Insert(block_to_insert), "");
    111    }
    112  }
    113 }
    114 
    115 // Verifies the check for the number of channels in the inserted blocks.
    116 TEST(RenderDelayBufferDeathTest, WrongNumberOfChannels) {
    117  for (auto rate : {16000, 32000, 48000}) {
    118    for (size_t num_channels : {1, 2, 8}) {
    119      SCOPED_TRACE(ProduceDebugText(rate));
    120      std::unique_ptr<RenderDelayBuffer> delay_buffer(RenderDelayBuffer::Create(
    121          EchoCanceller3Config(), rate, num_channels));
    122      Block block_to_insert(NumBandsForRate(rate), num_channels + 1);
    123      EXPECT_DEATH(delay_buffer->Insert(block_to_insert), "");
    124    }
    125  }
    126 }
    127 
    128 #endif
    129 
    130 }  // namespace webrtc