OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include "webrtc/audio/utility/audio_frame_operations.h" | 11 #include "webrtc/audio/utility/audio_frame_operations.h" |
12 #include "webrtc/base/checks.h" | 12 #include "webrtc/base/checks.h" |
13 #include "webrtc/modules/include/module_common_types.h" | 13 #include "webrtc/modules/include/module_common_types.h" |
14 #include "webrtc/test/gtest.h" | 14 #include "webrtc/test/gtest.h" |
15 | 15 |
16 namespace webrtc { | 16 namespace webrtc { |
17 namespace { | 17 namespace { |
18 | 18 |
19 class AudioFrameOperationsTest : public ::testing::Test { | 19 class AudioFrameOperationsTest : public ::testing::Test { |
20 protected: | 20 protected: |
21 AudioFrameOperationsTest() { | 21 AudioFrameOperationsTest() { |
22 // Set typical values. | 22 // Set typical values. |
23 frame_.samples_per_channel_ = 320; | 23 frame_.samples_per_channel_ = 320; |
24 frame_.num_channels_ = 2; | 24 frame_.num_channels_ = 2; |
25 } | 25 } |
26 | 26 |
27 AudioFrame frame_; | 27 AudioFrame frame_; |
28 }; | 28 }; |
29 | 29 |
30 void SetFrameData(AudioFrame* frame, int16_t left, int16_t right) { | 30 void SetFrameData(int16_t ch1, |
| 31 int16_t ch2, |
| 32 int16_t ch3, |
| 33 int16_t ch4, |
| 34 AudioFrame* frame) { |
| 35 for (size_t i = 0; i < frame->samples_per_channel_ * 4; i += 4) { |
| 36 frame->data_[i] = ch1; |
| 37 frame->data_[i + 1] = ch2; |
| 38 frame->data_[i + 2] = ch3; |
| 39 frame->data_[i + 3] = ch4; |
| 40 } |
| 41 } |
| 42 |
| 43 void SetFrameData(int16_t left, int16_t right, AudioFrame* frame) { |
31 for (size_t i = 0; i < frame->samples_per_channel_ * 2; i += 2) { | 44 for (size_t i = 0; i < frame->samples_per_channel_ * 2; i += 2) { |
32 frame->data_[i] = left; | 45 frame->data_[i] = left; |
33 frame->data_[i + 1] = right; | 46 frame->data_[i + 1] = right; |
34 } | 47 } |
35 } | 48 } |
36 | 49 |
37 void SetFrameData(AudioFrame* frame, int16_t data) { | 50 void SetFrameData(int16_t data, AudioFrame* frame) { |
38 for (size_t i = 0; i < frame->samples_per_channel_; i++) { | 51 for (size_t i = 0; i < frame->samples_per_channel_; i++) { |
39 frame->data_[i] = data; | 52 frame->data_[i] = data; |
40 } | 53 } |
41 } | 54 } |
42 | 55 |
43 void VerifyFramesAreEqual(const AudioFrame& frame1, const AudioFrame& frame2) { | 56 void VerifyFramesAreEqual(const AudioFrame& frame1, const AudioFrame& frame2) { |
44 EXPECT_EQ(frame1.num_channels_, frame2.num_channels_); | 57 EXPECT_EQ(frame1.num_channels_, frame2.num_channels_); |
45 EXPECT_EQ(frame1.samples_per_channel_, | 58 EXPECT_EQ(frame1.samples_per_channel_, |
46 frame2.samples_per_channel_); | 59 frame2.samples_per_channel_); |
47 for (size_t i = 0; i < frame1.samples_per_channel_ * frame1.num_channels_; | 60 for (size_t i = 0; i < frame1.samples_per_channel_ * frame1.num_channels_; |
48 i++) { | 61 i++) { |
49 EXPECT_EQ(frame1.data_[i], frame2.data_[i]); | 62 EXPECT_EQ(frame1.data_[i], frame2.data_[i]); |
50 } | 63 } |
51 } | 64 } |
52 | 65 |
53 void InitFrame(AudioFrame* frame, size_t channels, size_t samples_per_channel, | 66 void InitFrame(AudioFrame* frame, size_t channels, size_t samples_per_channel, |
54 int16_t left_data, int16_t right_data) { | 67 int16_t left_data, int16_t right_data) { |
55 RTC_DCHECK(frame); | 68 RTC_DCHECK(frame); |
56 RTC_DCHECK_GE(2, channels); | 69 RTC_DCHECK_GE(2, channels); |
57 RTC_DCHECK_GE(AudioFrame::kMaxDataSizeSamples, | 70 RTC_DCHECK_GE(AudioFrame::kMaxDataSizeSamples, |
58 samples_per_channel * channels); | 71 samples_per_channel * channels); |
59 frame->samples_per_channel_ = samples_per_channel; | 72 frame->samples_per_channel_ = samples_per_channel; |
60 frame->num_channels_ = channels; | 73 frame->num_channels_ = channels; |
61 if (channels == 2) { | 74 if (channels == 2) { |
62 SetFrameData(frame, left_data, right_data); | 75 SetFrameData(left_data, right_data, frame); |
63 } else if (channels == 1) { | 76 } else if (channels == 1) { |
64 SetFrameData(frame, left_data); | 77 SetFrameData(left_data, frame); |
65 } | 78 } |
66 } | 79 } |
67 | 80 |
68 int16_t GetChannelData(const AudioFrame& frame, size_t channel, size_t index) { | 81 int16_t GetChannelData(const AudioFrame& frame, size_t channel, size_t index) { |
69 RTC_DCHECK_LT(channel, frame.num_channels_); | 82 RTC_DCHECK_LT(channel, frame.num_channels_); |
70 RTC_DCHECK_LT(index, frame.samples_per_channel_); | 83 RTC_DCHECK_LT(index, frame.samples_per_channel_); |
71 return frame.data_[index * frame.num_channels_ + channel]; | 84 return frame.data_[index * frame.num_channels_ + channel]; |
72 } | 85 } |
73 | 86 |
74 void VerifyFrameDataBounds(const AudioFrame& frame, size_t channel, int16_t max, | 87 void VerifyFrameDataBounds(const AudioFrame& frame, size_t channel, int16_t max, |
75 int16_t min) { | 88 int16_t min) { |
76 for (size_t i = 0; i < frame.samples_per_channel_; ++i) { | 89 for (size_t i = 0; i < frame.samples_per_channel_; ++i) { |
77 int16_t s = GetChannelData(frame, channel, i); | 90 int16_t s = GetChannelData(frame, channel, i); |
78 EXPECT_LE(min, s); | 91 EXPECT_LE(min, s); |
79 EXPECT_GE(max, s); | 92 EXPECT_GE(max, s); |
80 } | 93 } |
81 } | 94 } |
82 | 95 |
83 TEST_F(AudioFrameOperationsTest, MonoToStereoFailsWithBadParameters) { | 96 TEST_F(AudioFrameOperationsTest, MonoToStereoFailsWithBadParameters) { |
84 EXPECT_EQ(-1, AudioFrameOperations::MonoToStereo(&frame_)); | 97 EXPECT_EQ(-1, AudioFrameOperations::MonoToStereo(&frame_)); |
85 | 98 |
86 frame_.samples_per_channel_ = AudioFrame::kMaxDataSizeSamples; | 99 frame_.samples_per_channel_ = AudioFrame::kMaxDataSizeSamples; |
87 frame_.num_channels_ = 1; | 100 frame_.num_channels_ = 1; |
88 EXPECT_EQ(-1, AudioFrameOperations::MonoToStereo(&frame_)); | 101 EXPECT_EQ(-1, AudioFrameOperations::MonoToStereo(&frame_)); |
89 } | 102 } |
90 | 103 |
91 TEST_F(AudioFrameOperationsTest, MonoToStereoSucceeds) { | 104 TEST_F(AudioFrameOperationsTest, MonoToStereoSucceeds) { |
92 frame_.num_channels_ = 1; | 105 frame_.num_channels_ = 1; |
93 SetFrameData(&frame_, 1); | 106 SetFrameData(1, &frame_); |
94 AudioFrame temp_frame; | 107 |
95 temp_frame.CopyFrom(frame_); | |
96 EXPECT_EQ(0, AudioFrameOperations::MonoToStereo(&frame_)); | 108 EXPECT_EQ(0, AudioFrameOperations::MonoToStereo(&frame_)); |
97 | 109 |
98 AudioFrame stereo_frame; | 110 AudioFrame stereo_frame; |
99 stereo_frame.samples_per_channel_ = 320; | 111 stereo_frame.samples_per_channel_ = 320; |
100 stereo_frame.num_channels_ = 2; | 112 stereo_frame.num_channels_ = 2; |
101 SetFrameData(&stereo_frame, 1, 1); | 113 SetFrameData(1, 1, &stereo_frame); |
102 VerifyFramesAreEqual(stereo_frame, frame_); | |
103 | |
104 SetFrameData(&frame_, 0); | |
105 AudioFrameOperations::MonoToStereo(temp_frame.data_, | |
106 frame_.samples_per_channel_, | |
107 frame_.data_); | |
108 frame_.num_channels_ = 2; // Need to set manually. | |
109 VerifyFramesAreEqual(stereo_frame, frame_); | 114 VerifyFramesAreEqual(stereo_frame, frame_); |
110 } | 115 } |
111 | 116 |
| 117 TEST_F(AudioFrameOperationsTest, MonoToStereoBufferSucceeds) { |
| 118 AudioFrame target_frame; |
| 119 frame_.num_channels_ = 1; |
| 120 SetFrameData(4, &frame_); |
| 121 |
| 122 target_frame.num_channels_ = 2; |
| 123 target_frame.samples_per_channel_ = frame_.samples_per_channel_; |
| 124 |
| 125 AudioFrameOperations::MonoToStereo(frame_.data_, frame_.samples_per_channel_, |
| 126 target_frame.data_); |
| 127 |
| 128 AudioFrame stereo_frame; |
| 129 stereo_frame.samples_per_channel_ = 320; |
| 130 stereo_frame.num_channels_ = 2; |
| 131 SetFrameData(4, 4, &stereo_frame); |
| 132 VerifyFramesAreEqual(stereo_frame, target_frame); |
| 133 } |
| 134 |
112 TEST_F(AudioFrameOperationsTest, StereoToMonoFailsWithBadParameters) { | 135 TEST_F(AudioFrameOperationsTest, StereoToMonoFailsWithBadParameters) { |
113 frame_.num_channels_ = 1; | 136 frame_.num_channels_ = 1; |
114 EXPECT_EQ(-1, AudioFrameOperations::StereoToMono(&frame_)); | 137 EXPECT_EQ(-1, AudioFrameOperations::StereoToMono(&frame_)); |
115 } | 138 } |
116 | 139 |
117 TEST_F(AudioFrameOperationsTest, StereoToMonoSucceeds) { | 140 TEST_F(AudioFrameOperationsTest, StereoToMonoSucceeds) { |
118 SetFrameData(&frame_, 4, 2); | 141 SetFrameData(4, 2, &frame_); |
119 AudioFrame temp_frame; | |
120 temp_frame.CopyFrom(frame_); | |
121 EXPECT_EQ(0, AudioFrameOperations::StereoToMono(&frame_)); | 142 EXPECT_EQ(0, AudioFrameOperations::StereoToMono(&frame_)); |
122 | 143 |
123 AudioFrame mono_frame; | 144 AudioFrame mono_frame; |
124 mono_frame.samples_per_channel_ = 320; | 145 mono_frame.samples_per_channel_ = 320; |
125 mono_frame.num_channels_ = 1; | 146 mono_frame.num_channels_ = 1; |
126 SetFrameData(&mono_frame, 3); | 147 SetFrameData(3, &mono_frame); |
127 VerifyFramesAreEqual(mono_frame, frame_); | |
128 | |
129 SetFrameData(&frame_, 0); | |
130 AudioFrameOperations::StereoToMono(temp_frame.data_, | |
131 frame_.samples_per_channel_, | |
132 frame_.data_); | |
133 frame_.num_channels_ = 1; // Need to set manually. | |
134 VerifyFramesAreEqual(mono_frame, frame_); | 148 VerifyFramesAreEqual(mono_frame, frame_); |
135 } | 149 } |
136 | 150 |
| 151 TEST_F(AudioFrameOperationsTest, StereoToMonoBufferSucceeds) { |
| 152 AudioFrame target_frame; |
| 153 SetFrameData(4, 2, &frame_); |
| 154 |
| 155 target_frame.num_channels_ = 1; |
| 156 target_frame.samples_per_channel_ = frame_.samples_per_channel_; |
| 157 |
| 158 AudioFrameOperations::StereoToMono(frame_.data_, frame_.samples_per_channel_, |
| 159 target_frame.data_); |
| 160 |
| 161 AudioFrame mono_frame; |
| 162 mono_frame.samples_per_channel_ = 320; |
| 163 mono_frame.num_channels_ = 1; |
| 164 SetFrameData(3, &mono_frame); |
| 165 VerifyFramesAreEqual(mono_frame, target_frame); |
| 166 } |
| 167 |
137 TEST_F(AudioFrameOperationsTest, StereoToMonoDoesNotWrapAround) { | 168 TEST_F(AudioFrameOperationsTest, StereoToMonoDoesNotWrapAround) { |
138 SetFrameData(&frame_, -32768, -32768); | 169 SetFrameData(-32768, -32768, &frame_); |
139 EXPECT_EQ(0, AudioFrameOperations::StereoToMono(&frame_)); | 170 EXPECT_EQ(0, AudioFrameOperations::StereoToMono(&frame_)); |
140 | 171 |
141 AudioFrame mono_frame; | 172 AudioFrame mono_frame; |
142 mono_frame.samples_per_channel_ = 320; | 173 mono_frame.samples_per_channel_ = 320; |
143 mono_frame.num_channels_ = 1; | 174 mono_frame.num_channels_ = 1; |
144 SetFrameData(&mono_frame, -32768); | 175 SetFrameData(-32768, &mono_frame); |
145 VerifyFramesAreEqual(mono_frame, frame_); | 176 VerifyFramesAreEqual(mono_frame, frame_); |
146 } | 177 } |
147 | 178 |
| 179 TEST_F(AudioFrameOperationsTest, QuadToMonoFailsWithBadParameters) { |
| 180 frame_.num_channels_ = 1; |
| 181 EXPECT_EQ(-1, AudioFrameOperations::QuadToMono(&frame_)); |
| 182 frame_.num_channels_ = 2; |
| 183 EXPECT_EQ(-1, AudioFrameOperations::QuadToMono(&frame_)); |
| 184 } |
| 185 |
| 186 TEST_F(AudioFrameOperationsTest, QuadToMonoSucceeds) { |
| 187 frame_.num_channels_ = 4; |
| 188 SetFrameData(4, 2, 6, 8, &frame_); |
| 189 |
| 190 EXPECT_EQ(0, AudioFrameOperations::QuadToMono(&frame_)); |
| 191 |
| 192 AudioFrame mono_frame; |
| 193 mono_frame.samples_per_channel_ = 320; |
| 194 mono_frame.num_channels_ = 1; |
| 195 SetFrameData(5, &mono_frame); |
| 196 VerifyFramesAreEqual(mono_frame, frame_); |
| 197 } |
| 198 |
| 199 TEST_F(AudioFrameOperationsTest, QuadToMonoBufferSucceeds) { |
| 200 AudioFrame target_frame; |
| 201 frame_.num_channels_ = 4; |
| 202 SetFrameData(4, 2, 6, 8, &frame_); |
| 203 |
| 204 target_frame.num_channels_ = 1; |
| 205 target_frame.samples_per_channel_ = frame_.samples_per_channel_; |
| 206 |
| 207 AudioFrameOperations::QuadToMono(frame_.data_, frame_.samples_per_channel_, |
| 208 target_frame.data_); |
| 209 AudioFrame mono_frame; |
| 210 mono_frame.samples_per_channel_ = 320; |
| 211 mono_frame.num_channels_ = 1; |
| 212 SetFrameData(5, &mono_frame); |
| 213 VerifyFramesAreEqual(mono_frame, target_frame); |
| 214 } |
| 215 |
| 216 TEST_F(AudioFrameOperationsTest, QuadToMonoDoesNotWrapAround) { |
| 217 frame_.num_channels_ = 4; |
| 218 SetFrameData(-32768, -32768, -32768, -32768, &frame_); |
| 219 EXPECT_EQ(0, AudioFrameOperations::QuadToMono(&frame_)); |
| 220 |
| 221 AudioFrame mono_frame; |
| 222 mono_frame.samples_per_channel_ = 320; |
| 223 mono_frame.num_channels_ = 1; |
| 224 SetFrameData(-32768, &mono_frame); |
| 225 VerifyFramesAreEqual(mono_frame, frame_); |
| 226 } |
| 227 |
| 228 TEST_F(AudioFrameOperationsTest, QuadToStereoFailsWithBadParameters) { |
| 229 frame_.num_channels_ = 1; |
| 230 EXPECT_EQ(-1, AudioFrameOperations::QuadToStereo(&frame_)); |
| 231 frame_.num_channels_ = 2; |
| 232 EXPECT_EQ(-1, AudioFrameOperations::QuadToStereo(&frame_)); |
| 233 } |
| 234 |
| 235 TEST_F(AudioFrameOperationsTest, QuadToStereoSucceeds) { |
| 236 frame_.num_channels_ = 4; |
| 237 SetFrameData(4, 2, 6, 8, &frame_); |
| 238 EXPECT_EQ(0, AudioFrameOperations::QuadToStereo(&frame_)); |
| 239 |
| 240 AudioFrame stereo_frame; |
| 241 stereo_frame.samples_per_channel_ = 320; |
| 242 stereo_frame.num_channels_ = 2; |
| 243 SetFrameData(3, 7, &stereo_frame); |
| 244 VerifyFramesAreEqual(stereo_frame, frame_); |
| 245 } |
| 246 |
| 247 TEST_F(AudioFrameOperationsTest, QuadToStereoBufferSucceeds) { |
| 248 AudioFrame target_frame; |
| 249 frame_.num_channels_ = 4; |
| 250 SetFrameData(4, 2, 6, 8, &frame_); |
| 251 |
| 252 target_frame.num_channels_ = 2; |
| 253 target_frame.samples_per_channel_ = frame_.samples_per_channel_; |
| 254 |
| 255 AudioFrameOperations::QuadToStereo(frame_.data_, frame_.samples_per_channel_, |
| 256 target_frame.data_); |
| 257 AudioFrame stereo_frame; |
| 258 stereo_frame.samples_per_channel_ = 320; |
| 259 stereo_frame.num_channels_ = 2; |
| 260 SetFrameData(3, 7, &stereo_frame); |
| 261 VerifyFramesAreEqual(stereo_frame, target_frame); |
| 262 } |
| 263 |
| 264 TEST_F(AudioFrameOperationsTest, QuadToStereoDoesNotWrapAround) { |
| 265 frame_.num_channels_ = 4; |
| 266 SetFrameData(-32768, -32768, -32768, -32768, &frame_); |
| 267 EXPECT_EQ(0, AudioFrameOperations::QuadToStereo(&frame_)); |
| 268 |
| 269 AudioFrame stereo_frame; |
| 270 stereo_frame.samples_per_channel_ = 320; |
| 271 stereo_frame.num_channels_ = 2; |
| 272 SetFrameData(-32768, -32768, &stereo_frame); |
| 273 VerifyFramesAreEqual(stereo_frame, frame_); |
| 274 } |
| 275 |
148 TEST_F(AudioFrameOperationsTest, SwapStereoChannelsSucceedsOnStereo) { | 276 TEST_F(AudioFrameOperationsTest, SwapStereoChannelsSucceedsOnStereo) { |
149 SetFrameData(&frame_, 0, 1); | 277 SetFrameData(0, 1, &frame_); |
150 | 278 |
151 AudioFrame swapped_frame; | 279 AudioFrame swapped_frame; |
152 swapped_frame.samples_per_channel_ = 320; | 280 swapped_frame.samples_per_channel_ = 320; |
153 swapped_frame.num_channels_ = 2; | 281 swapped_frame.num_channels_ = 2; |
154 SetFrameData(&swapped_frame, 1, 0); | 282 SetFrameData(1, 0, &swapped_frame); |
155 | 283 |
156 AudioFrameOperations::SwapStereoChannels(&frame_); | 284 AudioFrameOperations::SwapStereoChannels(&frame_); |
157 VerifyFramesAreEqual(swapped_frame, frame_); | 285 VerifyFramesAreEqual(swapped_frame, frame_); |
158 } | 286 } |
159 | 287 |
160 TEST_F(AudioFrameOperationsTest, SwapStereoChannelsFailsOnMono) { | 288 TEST_F(AudioFrameOperationsTest, SwapStereoChannelsFailsOnMono) { |
161 frame_.num_channels_ = 1; | 289 frame_.num_channels_ = 1; |
162 // Set data to "stereo", despite it being a mono frame. | 290 // Set data to "stereo", despite it being a mono frame. |
163 SetFrameData(&frame_, 0, 1); | 291 SetFrameData(0, 1, &frame_); |
164 | 292 |
165 AudioFrame orig_frame; | 293 AudioFrame orig_frame; |
166 orig_frame.CopyFrom(frame_); | 294 orig_frame.CopyFrom(frame_); |
167 AudioFrameOperations::SwapStereoChannels(&frame_); | 295 AudioFrameOperations::SwapStereoChannels(&frame_); |
168 // Verify that no swap occurred. | 296 // Verify that no swap occurred. |
169 VerifyFramesAreEqual(orig_frame, frame_); | 297 VerifyFramesAreEqual(orig_frame, frame_); |
170 } | 298 } |
171 | 299 |
172 TEST_F(AudioFrameOperationsTest, MuteDisabled) { | 300 TEST_F(AudioFrameOperationsTest, MuteDisabled) { |
173 SetFrameData(&frame_, 1000, -1000); | 301 SetFrameData(1000, -1000, &frame_); |
174 AudioFrameOperations::Mute(&frame_, false, false); | 302 AudioFrameOperations::Mute(&frame_, false, false); |
175 | 303 |
176 AudioFrame muted_frame; | 304 AudioFrame muted_frame; |
177 muted_frame.samples_per_channel_ = 320; | 305 muted_frame.samples_per_channel_ = 320; |
178 muted_frame.num_channels_ = 2; | 306 muted_frame.num_channels_ = 2; |
179 SetFrameData(&muted_frame, 1000, -1000); | 307 SetFrameData(1000, -1000, &muted_frame); |
180 VerifyFramesAreEqual(muted_frame, frame_); | 308 VerifyFramesAreEqual(muted_frame, frame_); |
181 } | 309 } |
182 | 310 |
183 TEST_F(AudioFrameOperationsTest, MuteEnabled) { | 311 TEST_F(AudioFrameOperationsTest, MuteEnabled) { |
184 SetFrameData(&frame_, 1000, -1000); | 312 SetFrameData(1000, -1000, &frame_); |
185 AudioFrameOperations::Mute(&frame_, true, true); | 313 AudioFrameOperations::Mute(&frame_, true, true); |
186 | 314 |
187 AudioFrame muted_frame; | 315 AudioFrame muted_frame; |
188 muted_frame.samples_per_channel_ = 320; | 316 muted_frame.samples_per_channel_ = 320; |
189 muted_frame.num_channels_ = 2; | 317 muted_frame.num_channels_ = 2; |
190 SetFrameData(&muted_frame, 0, 0); | 318 SetFrameData(0, 0, &muted_frame); |
191 VerifyFramesAreEqual(muted_frame, frame_); | 319 VerifyFramesAreEqual(muted_frame, frame_); |
192 } | 320 } |
193 | 321 |
194 // Verify that *beginning* to mute works for short and long (>128) frames, mono | 322 // Verify that *beginning* to mute works for short and long (>128) frames, mono |
195 // and stereo. Beginning mute should yield a ramp down to zero. | 323 // and stereo. Beginning mute should yield a ramp down to zero. |
196 TEST_F(AudioFrameOperationsTest, MuteBeginMonoLong) { | 324 TEST_F(AudioFrameOperationsTest, MuteBeginMonoLong) { |
197 InitFrame(&frame_, 1, 228, 1000, -1000); | 325 InitFrame(&frame_, 1, 228, 1000, -1000); |
198 AudioFrameOperations::Mute(&frame_, false, true); | 326 AudioFrameOperations::Mute(&frame_, false, true); |
199 VerifyFrameDataBounds(frame_, 0, 1000, 0); | 327 VerifyFrameDataBounds(frame_, 0, 1000, 0); |
200 EXPECT_EQ(1000, GetChannelData(frame_, 0, 99)); | 328 EXPECT_EQ(1000, GetChannelData(frame_, 0, 99)); |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 frame_.num_channels_ = 3; | 431 frame_.num_channels_ = 3; |
304 EXPECT_EQ(-1, AudioFrameOperations::Scale(1.0, 1.0, frame_)); | 432 EXPECT_EQ(-1, AudioFrameOperations::Scale(1.0, 1.0, frame_)); |
305 | 433 |
306 frame_.num_channels_ = 2; | 434 frame_.num_channels_ = 2; |
307 EXPECT_EQ(-1, AudioFrameOperations::Scale(-1.0, 1.0, frame_)); | 435 EXPECT_EQ(-1, AudioFrameOperations::Scale(-1.0, 1.0, frame_)); |
308 EXPECT_EQ(-1, AudioFrameOperations::Scale(1.0, -1.0, frame_)); | 436 EXPECT_EQ(-1, AudioFrameOperations::Scale(1.0, -1.0, frame_)); |
309 } | 437 } |
310 | 438 |
311 // TODO(andrew): fix the wraparound bug. We should always saturate. | 439 // TODO(andrew): fix the wraparound bug. We should always saturate. |
312 TEST_F(AudioFrameOperationsTest, DISABLED_ScaleDoesNotWrapAround) { | 440 TEST_F(AudioFrameOperationsTest, DISABLED_ScaleDoesNotWrapAround) { |
313 SetFrameData(&frame_, 4000, -4000); | 441 SetFrameData(4000, -4000, &frame_); |
314 EXPECT_EQ(0, AudioFrameOperations::Scale(10.0, 10.0, frame_)); | 442 EXPECT_EQ(0, AudioFrameOperations::Scale(10.0, 10.0, frame_)); |
315 | 443 |
316 AudioFrame clipped_frame; | 444 AudioFrame clipped_frame; |
317 clipped_frame.samples_per_channel_ = 320; | 445 clipped_frame.samples_per_channel_ = 320; |
318 clipped_frame.num_channels_ = 2; | 446 clipped_frame.num_channels_ = 2; |
319 SetFrameData(&clipped_frame, 32767, -32768); | 447 SetFrameData(32767, -32768, &clipped_frame); |
320 VerifyFramesAreEqual(clipped_frame, frame_); | 448 VerifyFramesAreEqual(clipped_frame, frame_); |
321 } | 449 } |
322 | 450 |
323 TEST_F(AudioFrameOperationsTest, ScaleSucceeds) { | 451 TEST_F(AudioFrameOperationsTest, ScaleSucceeds) { |
324 SetFrameData(&frame_, 1, -1); | 452 SetFrameData(1, -1, &frame_); |
325 EXPECT_EQ(0, AudioFrameOperations::Scale(2.0, 3.0, frame_)); | 453 EXPECT_EQ(0, AudioFrameOperations::Scale(2.0, 3.0, frame_)); |
326 | 454 |
327 AudioFrame scaled_frame; | 455 AudioFrame scaled_frame; |
328 scaled_frame.samples_per_channel_ = 320; | 456 scaled_frame.samples_per_channel_ = 320; |
329 scaled_frame.num_channels_ = 2; | 457 scaled_frame.num_channels_ = 2; |
330 SetFrameData(&scaled_frame, 2, -3); | 458 SetFrameData(2, -3, &scaled_frame); |
331 VerifyFramesAreEqual(scaled_frame, frame_); | 459 VerifyFramesAreEqual(scaled_frame, frame_); |
332 } | 460 } |
333 | 461 |
334 // TODO(andrew): should fail with a negative scale. | 462 // TODO(andrew): should fail with a negative scale. |
335 TEST_F(AudioFrameOperationsTest, DISABLED_ScaleWithSatFailsWithBadParameters) { | 463 TEST_F(AudioFrameOperationsTest, DISABLED_ScaleWithSatFailsWithBadParameters) { |
336 EXPECT_EQ(-1, AudioFrameOperations::ScaleWithSat(-1.0, frame_)); | 464 EXPECT_EQ(-1, AudioFrameOperations::ScaleWithSat(-1.0, frame_)); |
337 } | 465 } |
338 | 466 |
339 TEST_F(AudioFrameOperationsTest, ScaleWithSatDoesNotWrapAround) { | 467 TEST_F(AudioFrameOperationsTest, ScaleWithSatDoesNotWrapAround) { |
340 frame_.num_channels_ = 1; | 468 frame_.num_channels_ = 1; |
341 SetFrameData(&frame_, 4000); | 469 SetFrameData(4000, &frame_); |
342 EXPECT_EQ(0, AudioFrameOperations::ScaleWithSat(10.0, frame_)); | 470 EXPECT_EQ(0, AudioFrameOperations::ScaleWithSat(10.0, frame_)); |
343 | 471 |
344 AudioFrame clipped_frame; | 472 AudioFrame clipped_frame; |
345 clipped_frame.samples_per_channel_ = 320; | 473 clipped_frame.samples_per_channel_ = 320; |
346 clipped_frame.num_channels_ = 1; | 474 clipped_frame.num_channels_ = 1; |
347 SetFrameData(&clipped_frame, 32767); | 475 SetFrameData(32767, &clipped_frame); |
348 VerifyFramesAreEqual(clipped_frame, frame_); | 476 VerifyFramesAreEqual(clipped_frame, frame_); |
349 | 477 |
350 SetFrameData(&frame_, -4000); | 478 SetFrameData(-4000, &frame_); |
351 EXPECT_EQ(0, AudioFrameOperations::ScaleWithSat(10.0, frame_)); | 479 EXPECT_EQ(0, AudioFrameOperations::ScaleWithSat(10.0, frame_)); |
352 SetFrameData(&clipped_frame, -32768); | 480 SetFrameData(-32768, &clipped_frame); |
353 VerifyFramesAreEqual(clipped_frame, frame_); | 481 VerifyFramesAreEqual(clipped_frame, frame_); |
354 } | 482 } |
355 | 483 |
356 TEST_F(AudioFrameOperationsTest, ScaleWithSatSucceeds) { | 484 TEST_F(AudioFrameOperationsTest, ScaleWithSatSucceeds) { |
357 frame_.num_channels_ = 1; | 485 frame_.num_channels_ = 1; |
358 SetFrameData(&frame_, 1); | 486 SetFrameData(1, &frame_); |
359 EXPECT_EQ(0, AudioFrameOperations::ScaleWithSat(2.0, frame_)); | 487 EXPECT_EQ(0, AudioFrameOperations::ScaleWithSat(2.0, frame_)); |
360 | 488 |
361 AudioFrame scaled_frame; | 489 AudioFrame scaled_frame; |
362 scaled_frame.samples_per_channel_ = 320; | 490 scaled_frame.samples_per_channel_ = 320; |
363 scaled_frame.num_channels_ = 1; | 491 scaled_frame.num_channels_ = 1; |
364 SetFrameData(&scaled_frame, 2); | 492 SetFrameData(2, &scaled_frame); |
365 VerifyFramesAreEqual(scaled_frame, frame_); | 493 VerifyFramesAreEqual(scaled_frame, frame_); |
366 } | 494 } |
367 | 495 |
368 TEST_F(AudioFrameOperationsTest, AddingXToEmptyGivesX) { | 496 TEST_F(AudioFrameOperationsTest, AddingXToEmptyGivesX) { |
369 // When samples_per_channel_ is 0, the frame counts as empty and zero. | 497 // When samples_per_channel_ is 0, the frame counts as empty and zero. |
370 AudioFrame frame_to_add_to; | 498 AudioFrame frame_to_add_to; |
371 frame_to_add_to.samples_per_channel_ = 0; | 499 frame_to_add_to.samples_per_channel_ = 0; |
372 frame_to_add_to.num_channels_ = frame_.num_channels_; | 500 frame_to_add_to.num_channels_ = frame_.num_channels_; |
373 | 501 |
374 AudioFrameOperations::Add(frame_, &frame_to_add_to); | 502 AudioFrameOperations::Add(frame_, &frame_to_add_to); |
375 VerifyFramesAreEqual(frame_, frame_to_add_to); | 503 VerifyFramesAreEqual(frame_, frame_to_add_to); |
376 } | 504 } |
377 | 505 |
378 TEST_F(AudioFrameOperationsTest, AddingTwoFramesProducesTheirSum) { | 506 TEST_F(AudioFrameOperationsTest, AddingTwoFramesProducesTheirSum) { |
379 AudioFrame frame_to_add_to; | 507 AudioFrame frame_to_add_to; |
380 frame_to_add_to.samples_per_channel_ = frame_.samples_per_channel_; | 508 frame_to_add_to.samples_per_channel_ = frame_.samples_per_channel_; |
381 frame_to_add_to.num_channels_ = frame_.num_channels_; | 509 frame_to_add_to.num_channels_ = frame_.num_channels_; |
382 SetFrameData(&frame_to_add_to, 1000); | 510 SetFrameData(1000, &frame_to_add_to); |
383 | 511 |
384 AudioFrameOperations::Add(frame_, &frame_to_add_to); | 512 AudioFrameOperations::Add(frame_, &frame_to_add_to); |
385 SetFrameData(&frame_, frame_.data_[0] + 1000); | 513 SetFrameData(frame_.data_[0] + 1000, &frame_); |
386 VerifyFramesAreEqual(frame_, frame_to_add_to); | 514 VerifyFramesAreEqual(frame_, frame_to_add_to); |
387 } | 515 } |
388 } // namespace | 516 } // namespace |
389 } // namespace webrtc | 517 } // namespace webrtc |
OLD | NEW |