1 /*
2 * Copyright (c) 2013 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_coding/acm2/acm_remixing.h"
12
13 #include <vector>
14
15 #include "api/audio/audio_frame.h"
16 #include "system_wrappers/include/clock.h"
17 #include "test/gmock.h"
18 #include "test/gtest.h"
19 #include "test/testsupport/file_utils.h"
20
21 using ::testing::AllOf;
22 using ::testing::Each;
23 using ::testing::ElementsAreArray;
24 using ::testing::SizeIs;
25
26 namespace webrtc {
27
TEST(AcmRemixing,DownMixFrame)28 TEST(AcmRemixing, DownMixFrame) {
29 std::vector<int16_t> out(480, 0);
30 AudioFrame in;
31 in.num_channels_ = 2;
32 in.samples_per_channel_ = 480;
33
34 int16_t* const in_data = in.mutable_data();
35 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
36 in_data[2 * k] = 2;
37 in_data[2 * k + 1] = 0;
38 }
39
40 DownMixFrame(in, out);
41
42 EXPECT_THAT(out, AllOf(SizeIs(480), Each(1)));
43 }
44
TEST(AcmRemixing,DownMixMutedFrame)45 TEST(AcmRemixing, DownMixMutedFrame) {
46 std::vector<int16_t> out(480, 0);
47 AudioFrame in;
48 in.num_channels_ = 2;
49 in.samples_per_channel_ = 480;
50
51 int16_t* const in_data = in.mutable_data();
52 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
53 in_data[2 * k] = 2;
54 in_data[2 * k + 1] = 0;
55 }
56
57 in.Mute();
58
59 DownMixFrame(in, out);
60
61 EXPECT_THAT(out, AllOf(SizeIs(480), Each(0)));
62 }
63
TEST(AcmRemixing,RemixMutedStereoFrameTo6Channels)64 TEST(AcmRemixing, RemixMutedStereoFrameTo6Channels) {
65 std::vector<int16_t> out(480, 0);
66 AudioFrame in;
67 in.num_channels_ = 2;
68 in.samples_per_channel_ = 480;
69
70 int16_t* const in_data = in.mutable_data();
71 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
72 in_data[2 * k] = 1;
73 in_data[2 * k + 1] = 2;
74 }
75 in.Mute();
76
77 ReMixFrame(in, 6, &out);
78 EXPECT_EQ(6 * 480u, out.size());
79
80 EXPECT_THAT(out, AllOf(SizeIs(in.samples_per_channel_ * 6), Each(0)));
81 }
82
TEST(AcmRemixing,RemixStereoFrameTo6Channels)83 TEST(AcmRemixing, RemixStereoFrameTo6Channels) {
84 std::vector<int16_t> out(480, 0);
85 AudioFrame in;
86 in.num_channels_ = 2;
87 in.samples_per_channel_ = 480;
88
89 int16_t* const in_data = in.mutable_data();
90 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
91 in_data[2 * k] = 1;
92 in_data[2 * k + 1] = 2;
93 }
94
95 ReMixFrame(in, 6, &out);
96 EXPECT_EQ(6 * 480u, out.size());
97
98 std::vector<int16_t> expected_output(in.samples_per_channel_ * 6);
99 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
100 expected_output[6 * k] = 1;
101 expected_output[6 * k + 1] = 2;
102 }
103
104 EXPECT_THAT(out, ElementsAreArray(expected_output));
105 }
106
TEST(AcmRemixing,RemixMonoFrameTo6Channels)107 TEST(AcmRemixing, RemixMonoFrameTo6Channels) {
108 std::vector<int16_t> out(480, 0);
109 AudioFrame in;
110 in.num_channels_ = 1;
111 in.samples_per_channel_ = 480;
112
113 int16_t* const in_data = in.mutable_data();
114 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
115 in_data[k] = 1;
116 }
117
118 ReMixFrame(in, 6, &out);
119 EXPECT_EQ(6 * 480u, out.size());
120
121 std::vector<int16_t> expected_output(in.samples_per_channel_ * 6, 0);
122 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
123 expected_output[6 * k] = 1;
124 expected_output[6 * k + 1] = 1;
125 }
126
127 EXPECT_THAT(out, ElementsAreArray(expected_output));
128 }
129
TEST(AcmRemixing,RemixStereoFrameToMono)130 TEST(AcmRemixing, RemixStereoFrameToMono) {
131 std::vector<int16_t> out(480, 0);
132 AudioFrame in;
133 in.num_channels_ = 2;
134 in.samples_per_channel_ = 480;
135
136 int16_t* const in_data = in.mutable_data();
137 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
138 in_data[2 * k] = 2;
139 in_data[2 * k + 1] = 0;
140 }
141
142 ReMixFrame(in, 1, &out);
143 EXPECT_EQ(480u, out.size());
144
145 EXPECT_THAT(out, AllOf(SizeIs(in.samples_per_channel_), Each(1)));
146 }
147
TEST(AcmRemixing,RemixMonoFrameToStereo)148 TEST(AcmRemixing, RemixMonoFrameToStereo) {
149 std::vector<int16_t> out(480, 0);
150 AudioFrame in;
151 in.num_channels_ = 1;
152 in.samples_per_channel_ = 480;
153
154 int16_t* const in_data = in.mutable_data();
155 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
156 in_data[k] = 1;
157 }
158
159 ReMixFrame(in, 2, &out);
160 EXPECT_EQ(960u, out.size());
161
162 EXPECT_THAT(out, AllOf(SizeIs(2 * in.samples_per_channel_), Each(1)));
163 }
164
TEST(AcmRemixing,Remix3ChannelFrameToStereo)165 TEST(AcmRemixing, Remix3ChannelFrameToStereo) {
166 std::vector<int16_t> out(480, 0);
167 AudioFrame in;
168 in.num_channels_ = 3;
169 in.samples_per_channel_ = 480;
170
171 int16_t* const in_data = in.mutable_data();
172 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
173 for (size_t j = 0; j < 3; ++j) {
174 in_data[3 * k + j] = j;
175 }
176 }
177
178 ReMixFrame(in, 2, &out);
179 EXPECT_EQ(2 * 480u, out.size());
180
181 std::vector<int16_t> expected_output(in.samples_per_channel_ * 2);
182 for (size_t k = 0; k < in.samples_per_channel_; ++k) {
183 for (size_t j = 0; j < 2; ++j) {
184 expected_output[2 * k + j] = static_cast<int>(j);
185 }
186 }
187
188 EXPECT_THAT(out, ElementsAreArray(expected_output));
189 }
190
191 } // namespace webrtc
192