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 Normal class.
12
13 #include "modules/audio_coding/neteq/normal.h"
14
15 #include <memory>
16 #include <vector>
17
18 #include "common_audio/signal_processing/include/signal_processing_library.h"
19 #include "modules/audio_coding/neteq/audio_multi_vector.h"
20 #include "modules/audio_coding/neteq/background_noise.h"
21 #include "modules/audio_coding/neteq/expand.h"
22 #include "modules/audio_coding/neteq/mock/mock_decoder_database.h"
23 #include "modules/audio_coding/neteq/mock/mock_expand.h"
24 #include "modules/audio_coding/neteq/random_vector.h"
25 #include "modules/audio_coding/neteq/statistics_calculator.h"
26 #include "modules/audio_coding/neteq/sync_buffer.h"
27 #include "test/gtest.h"
28
29 using ::testing::_;
30 using ::testing::Invoke;
31
32 namespace webrtc {
33
34 namespace {
35
ExpandProcess120ms(AudioMultiVector * output)36 int ExpandProcess120ms(AudioMultiVector* output) {
37 AudioMultiVector dummy_audio(1, 11520u);
38 dummy_audio.CopyTo(output);
39 return 0;
40 }
41
42 } // namespace
43
TEST(Normal,CreateAndDestroy)44 TEST(Normal, CreateAndDestroy) {
45 MockDecoderDatabase db;
46 int fs = 8000;
47 size_t channels = 1;
48 BackgroundNoise bgn(channels);
49 SyncBuffer sync_buffer(1, 1000);
50 RandomVector random_vector;
51 StatisticsCalculator statistics;
52 Expand expand(&bgn, &sync_buffer, &random_vector, &statistics, fs, channels);
53 Normal normal(fs, &db, bgn, &expand);
54 EXPECT_CALL(db, Die()); // Called when |db| goes out of scope.
55 }
56
TEST(Normal,AvoidDivideByZero)57 TEST(Normal, AvoidDivideByZero) {
58 WebRtcSpl_Init();
59 MockDecoderDatabase db;
60 int fs = 8000;
61 size_t channels = 1;
62 BackgroundNoise bgn(channels);
63 SyncBuffer sync_buffer(1, 1000);
64 RandomVector random_vector;
65 StatisticsCalculator statistics;
66 MockExpand expand(&bgn, &sync_buffer, &random_vector, &statistics, fs,
67 channels);
68 Normal normal(fs, &db, bgn, &expand);
69
70 int16_t input[1000] = {0};
71 std::unique_ptr<int16_t[]> mute_factor_array(new int16_t[channels]);
72 for (size_t i = 0; i < channels; ++i) {
73 mute_factor_array[i] = 16384;
74 }
75 AudioMultiVector output(channels);
76
77 // Zero input length.
78 EXPECT_EQ(
79 0,
80 normal.Process(input, 0, kModeExpand, mute_factor_array.get(), &output));
81 EXPECT_EQ(0u, output.Size());
82
83 // Try to make energy_length >> scaling = 0;
84 EXPECT_CALL(expand, SetParametersForNormalAfterExpand());
85 EXPECT_CALL(expand, Process(_));
86 EXPECT_CALL(expand, Reset());
87 // If input_size_samples < 64, then energy_length in Normal::Process() will
88 // be equal to input_size_samples. Since the input is all zeros, decoded_max
89 // will be zero, and scaling will be >= 6. Thus, energy_length >> scaling = 0,
90 // and using this as a denominator would lead to problems.
91 int input_size_samples = 63;
92 EXPECT_EQ(input_size_samples,
93 normal.Process(input,
94 input_size_samples,
95 kModeExpand,
96 mute_factor_array.get(),
97 &output));
98
99 EXPECT_CALL(db, Die()); // Called when |db| goes out of scope.
100 EXPECT_CALL(expand, Die()); // Called when |expand| goes out of scope.
101 }
102
TEST(Normal,InputLengthAndChannelsDoNotMatch)103 TEST(Normal, InputLengthAndChannelsDoNotMatch) {
104 WebRtcSpl_Init();
105 MockDecoderDatabase db;
106 int fs = 8000;
107 size_t channels = 2;
108 BackgroundNoise bgn(channels);
109 SyncBuffer sync_buffer(channels, 1000);
110 RandomVector random_vector;
111 StatisticsCalculator statistics;
112 MockExpand expand(&bgn, &sync_buffer, &random_vector, &statistics, fs,
113 channels);
114 Normal normal(fs, &db, bgn, &expand);
115
116 int16_t input[1000] = {0};
117 std::unique_ptr<int16_t[]> mute_factor_array(new int16_t[channels]);
118 for (size_t i = 0; i < channels; ++i) {
119 mute_factor_array[i] = 16384;
120 }
121 AudioMultiVector output(channels);
122
123 // Let the number of samples be one sample less than 80 samples per channel.
124 size_t input_len = 80 * channels - 1;
125 EXPECT_EQ(
126 0,
127 normal.Process(
128 input, input_len, kModeExpand, mute_factor_array.get(), &output));
129 EXPECT_EQ(0u, output.Size());
130
131 EXPECT_CALL(db, Die()); // Called when |db| goes out of scope.
132 EXPECT_CALL(expand, Die()); // Called when |expand| goes out of scope.
133 }
134
TEST(Normal,LastModeExpand120msPacket)135 TEST(Normal, LastModeExpand120msPacket) {
136 WebRtcSpl_Init();
137 MockDecoderDatabase db;
138 const int kFs = 48000;
139 const size_t kPacketsizeBytes = 11520u;
140 const size_t kChannels = 1;
141 BackgroundNoise bgn(kChannels);
142 SyncBuffer sync_buffer(kChannels, 1000);
143 RandomVector random_vector;
144 StatisticsCalculator statistics;
145 MockExpand expand(&bgn, &sync_buffer, &random_vector, &statistics, kFs,
146 kChannels);
147 Normal normal(kFs, &db, bgn, &expand);
148
149 int16_t input[kPacketsizeBytes] = {0};
150
151 std::unique_ptr<int16_t[]> mute_factor_array(new int16_t[kChannels]);
152 for (size_t i = 0; i < kChannels; ++i) {
153 mute_factor_array[i] = 16384;
154 }
155
156 AudioMultiVector output(kChannels);
157
158 EXPECT_CALL(expand, SetParametersForNormalAfterExpand());
159 EXPECT_CALL(expand, Process(_)).WillOnce(Invoke(ExpandProcess120ms));
160 EXPECT_CALL(expand, Reset());
161 EXPECT_EQ(static_cast<int>(kPacketsizeBytes),
162 normal.Process(input,
163 kPacketsizeBytes,
164 kModeExpand,
165 mute_factor_array.get(),
166 &output));
167
168 EXPECT_EQ(kPacketsizeBytes, output.Size());
169
170 EXPECT_CALL(db, Die()); // Called when |db| goes out of scope.
171 EXPECT_CALL(expand, Die()); // Called when |expand| goes out of scope.
172 }
173
174 // TODO(hlundin): Write more tests.
175
176 } // namespace webrtc
177