andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 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 | |
pbos@webrtc.org | 382c8b3 | 2013-05-28 08:11:59 +0000 | [diff] [blame] | 11 | #include "webrtc/modules/audio_processing/audio_buffer.h" |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 12 | |
andrew@webrtc.org | 3c5112c | 2014-03-04 20:58:13 +0000 | [diff] [blame] | 13 | #include "webrtc/common_audio/include/audio_util.h" |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 14 | #include "webrtc/common_audio/resampler/push_sinc_resampler.h" |
pbos@webrtc.org | 382c8b3 | 2013-05-28 08:11:59 +0000 | [diff] [blame] | 15 | #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h" |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 16 | |
| 17 | namespace webrtc { |
| 18 | namespace { |
| 19 | |
| 20 | enum { |
| 21 | kSamplesPer8kHzChannel = 80, |
| 22 | kSamplesPer16kHzChannel = 160, |
| 23 | kSamplesPer32kHzChannel = 320 |
| 24 | }; |
| 25 | |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 26 | bool HasKeyboardChannel(AudioProcessing::ChannelLayout layout) { |
| 27 | switch (layout) { |
| 28 | case AudioProcessing::kMono: |
| 29 | case AudioProcessing::kStereo: |
| 30 | return false; |
| 31 | case AudioProcessing::kMonoAndKeyboard: |
| 32 | case AudioProcessing::kStereoAndKeyboard: |
| 33 | return true; |
| 34 | } |
| 35 | assert(false); |
| 36 | return false; |
| 37 | } |
| 38 | |
| 39 | int KeyboardChannelIndex(AudioProcessing::ChannelLayout layout) { |
| 40 | switch (layout) { |
| 41 | case AudioProcessing::kMono: |
| 42 | case AudioProcessing::kStereo: |
| 43 | assert(false); |
| 44 | return -1; |
| 45 | case AudioProcessing::kMonoAndKeyboard: |
| 46 | return 1; |
| 47 | case AudioProcessing::kStereoAndKeyboard: |
| 48 | return 2; |
| 49 | } |
| 50 | assert(false); |
| 51 | return -1; |
| 52 | } |
| 53 | |
| 54 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 55 | void StereoToMono(const float* left, const float* right, float* out, |
| 56 | int samples_per_channel) { |
| 57 | for (int i = 0; i < samples_per_channel; ++i) { |
| 58 | out[i] = (left[i] + right[i]) / 2; |
| 59 | } |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 60 | } |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 61 | |
| 62 | void StereoToMono(const int16_t* left, const int16_t* right, int16_t* out, |
| 63 | int samples_per_channel) { |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 64 | for (int i = 0; i < samples_per_channel; ++i) { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 65 | out[i] = (left[i] + right[i]) >> 1; |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 66 | } |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 67 | } |
| 68 | |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 69 | } // namespace |
| 70 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 71 | class SplitChannelBuffer { |
| 72 | public: |
| 73 | SplitChannelBuffer(int samples_per_split_channel, int num_channels) |
| 74 | : low_(samples_per_split_channel, num_channels), |
| 75 | high_(samples_per_split_channel, num_channels) { |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 76 | } |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 77 | ~SplitChannelBuffer() {} |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 78 | |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 79 | int16_t* low_channel(int i) { return low_.channel(i); } |
| 80 | int16_t* high_channel(int i) { return high_.channel(i); } |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 81 | |
| 82 | private: |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 83 | ChannelBuffer<int16_t> low_; |
| 84 | ChannelBuffer<int16_t> high_; |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 85 | }; |
| 86 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 87 | AudioBuffer::AudioBuffer(int input_samples_per_channel, |
| 88 | int num_input_channels, |
| 89 | int process_samples_per_channel, |
| 90 | int num_process_channels, |
| 91 | int output_samples_per_channel) |
| 92 | : input_samples_per_channel_(input_samples_per_channel), |
| 93 | num_input_channels_(num_input_channels), |
| 94 | proc_samples_per_channel_(process_samples_per_channel), |
| 95 | num_proc_channels_(num_process_channels), |
| 96 | output_samples_per_channel_(output_samples_per_channel), |
| 97 | samples_per_split_channel_(proc_samples_per_channel_), |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 98 | num_mixed_channels_(0), |
| 99 | num_mixed_low_pass_channels_(0), |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 100 | reference_copied_(false), |
| 101 | activity_(AudioFrame::kVadUnknown), |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 102 | data_(NULL), |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 103 | keyboard_data_(NULL), |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 104 | channels_(new ChannelBuffer<int16_t>(proc_samples_per_channel_, |
| 105 | num_proc_channels_)) { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 106 | assert(input_samples_per_channel_ > 0); |
| 107 | assert(proc_samples_per_channel_ > 0); |
| 108 | assert(output_samples_per_channel_ > 0); |
| 109 | assert(num_input_channels_ > 0 && num_input_channels_ <= 2); |
| 110 | assert(num_proc_channels_ <= num_input_channels); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 111 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 112 | if (num_input_channels_ == 2 && num_proc_channels_ == 1) { |
| 113 | input_buffer_.reset(new ChannelBuffer<float>(input_samples_per_channel_, |
| 114 | num_proc_channels_)); |
| 115 | } |
| 116 | |
| 117 | if (input_samples_per_channel_ != proc_samples_per_channel_ || |
| 118 | output_samples_per_channel_ != proc_samples_per_channel_) { |
| 119 | // Create an intermediate buffer for resampling. |
| 120 | process_buffer_.reset(new ChannelBuffer<float>(proc_samples_per_channel_, |
| 121 | num_proc_channels_)); |
| 122 | } |
| 123 | |
| 124 | if (input_samples_per_channel_ != proc_samples_per_channel_) { |
| 125 | input_resamplers_.reserve(num_proc_channels_); |
| 126 | for (int i = 0; i < num_proc_channels_; ++i) { |
| 127 | input_resamplers_.push_back( |
| 128 | new PushSincResampler(input_samples_per_channel_, |
| 129 | proc_samples_per_channel_)); |
| 130 | } |
| 131 | } |
| 132 | |
| 133 | if (output_samples_per_channel_ != proc_samples_per_channel_) { |
| 134 | output_resamplers_.reserve(num_proc_channels_); |
| 135 | for (int i = 0; i < num_proc_channels_; ++i) { |
| 136 | output_resamplers_.push_back( |
| 137 | new PushSincResampler(proc_samples_per_channel_, |
| 138 | output_samples_per_channel_)); |
| 139 | } |
| 140 | } |
| 141 | |
| 142 | if (proc_samples_per_channel_ == kSamplesPer32kHzChannel) { |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 143 | samples_per_split_channel_ = kSamplesPer16kHzChannel; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 144 | split_channels_.reset(new SplitChannelBuffer(samples_per_split_channel_, |
| 145 | num_proc_channels_)); |
| 146 | filter_states_.reset(new SplitFilterStates[num_proc_channels_]); |
| 147 | } |
| 148 | } |
| 149 | |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 150 | AudioBuffer::~AudioBuffer() {} |
| 151 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 152 | void AudioBuffer::CopyFrom(const float* const* data, |
| 153 | int samples_per_channel, |
| 154 | AudioProcessing::ChannelLayout layout) { |
| 155 | assert(samples_per_channel == input_samples_per_channel_); |
| 156 | assert(ChannelsFromLayout(layout) == num_input_channels_); |
| 157 | InitForNewData(); |
| 158 | |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 159 | if (HasKeyboardChannel(layout)) { |
| 160 | keyboard_data_ = data[KeyboardChannelIndex(layout)]; |
| 161 | } |
| 162 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 163 | // Downmix. |
| 164 | const float* const* data_ptr = data; |
| 165 | if (num_input_channels_ == 2 && num_proc_channels_ == 1) { |
| 166 | StereoToMono(data[0], |
| 167 | data[1], |
| 168 | input_buffer_->channel(0), |
| 169 | input_samples_per_channel_); |
| 170 | data_ptr = input_buffer_->channels(); |
| 171 | } |
| 172 | |
| 173 | // Resample. |
| 174 | if (input_samples_per_channel_ != proc_samples_per_channel_) { |
| 175 | for (int i = 0; i < num_proc_channels_; ++i) { |
| 176 | input_resamplers_[i]->Resample(data_ptr[i], |
| 177 | input_samples_per_channel_, |
| 178 | process_buffer_->channel(i), |
| 179 | proc_samples_per_channel_); |
| 180 | } |
| 181 | data_ptr = process_buffer_->channels(); |
| 182 | } |
| 183 | |
| 184 | // Convert to int16. |
| 185 | for (int i = 0; i < num_proc_channels_; ++i) { |
| 186 | ScaleAndRoundToInt16(data_ptr[i], proc_samples_per_channel_, |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 187 | channels_->channel(i)); |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 188 | } |
| 189 | } |
| 190 | |
| 191 | void AudioBuffer::CopyTo(int samples_per_channel, |
| 192 | AudioProcessing::ChannelLayout layout, |
| 193 | float* const* data) { |
| 194 | assert(samples_per_channel == output_samples_per_channel_); |
| 195 | assert(ChannelsFromLayout(layout) == num_proc_channels_); |
| 196 | |
| 197 | // Convert to float. |
| 198 | float* const* data_ptr = data; |
| 199 | if (output_samples_per_channel_ != proc_samples_per_channel_) { |
| 200 | // Convert to an intermediate buffer for subsequent resampling. |
| 201 | data_ptr = process_buffer_->channels(); |
| 202 | } |
| 203 | for (int i = 0; i < num_proc_channels_; ++i) { |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 204 | ScaleToFloat(channels_->channel(i), proc_samples_per_channel_, data_ptr[i]); |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | // Resample. |
| 208 | if (output_samples_per_channel_ != proc_samples_per_channel_) { |
| 209 | for (int i = 0; i < num_proc_channels_; ++i) { |
| 210 | output_resamplers_[i]->Resample(data_ptr[i], |
| 211 | proc_samples_per_channel_, |
| 212 | data[i], |
| 213 | output_samples_per_channel_); |
| 214 | } |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 215 | } |
| 216 | } |
| 217 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 218 | void AudioBuffer::InitForNewData() { |
andrew@webrtc.org | 3c5112c | 2014-03-04 20:58:13 +0000 | [diff] [blame] | 219 | data_ = NULL; |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 220 | keyboard_data_ = NULL; |
andrew@webrtc.org | 3c5112c | 2014-03-04 20:58:13 +0000 | [diff] [blame] | 221 | num_mixed_channels_ = 0; |
| 222 | num_mixed_low_pass_channels_ = 0; |
| 223 | reference_copied_ = false; |
| 224 | activity_ = AudioFrame::kVadUnknown; |
andrew@webrtc.org | 3c5112c | 2014-03-04 20:58:13 +0000 | [diff] [blame] | 225 | } |
| 226 | |
andrew@webrtc.org | c2e6438 | 2014-04-30 16:44:13 +0000 | [diff] [blame] | 227 | const int16_t* AudioBuffer::data(int channel) const { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 228 | assert(channel >= 0 && channel < num_proc_channels_); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 229 | if (data_ != NULL) { |
kwiberg@webrtc.org | 8b4f539 | 2014-05-08 07:10:11 +0000 | [diff] [blame] | 230 | assert(channel == 0 && num_proc_channels_ == 1); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 231 | return data_; |
| 232 | } |
| 233 | |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 234 | return channels_->channel(channel); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 235 | } |
| 236 | |
andrew@webrtc.org | c2e6438 | 2014-04-30 16:44:13 +0000 | [diff] [blame] | 237 | int16_t* AudioBuffer::data(int channel) { |
| 238 | const AudioBuffer* t = this; |
| 239 | return const_cast<int16_t*>(t->data(channel)); |
| 240 | } |
| 241 | |
| 242 | const int16_t* AudioBuffer::low_pass_split_data(int channel) const { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 243 | assert(channel >= 0 && channel < num_proc_channels_); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 244 | if (split_channels_.get() == NULL) { |
| 245 | return data(channel); |
| 246 | } |
| 247 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 248 | return split_channels_->low_channel(channel); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 249 | } |
| 250 | |
andrew@webrtc.org | c2e6438 | 2014-04-30 16:44:13 +0000 | [diff] [blame] | 251 | int16_t* AudioBuffer::low_pass_split_data(int channel) { |
| 252 | const AudioBuffer* t = this; |
| 253 | return const_cast<int16_t*>(t->low_pass_split_data(channel)); |
| 254 | } |
| 255 | |
| 256 | const int16_t* AudioBuffer::high_pass_split_data(int channel) const { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 257 | assert(channel >= 0 && channel < num_proc_channels_); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 258 | if (split_channels_.get() == NULL) { |
| 259 | return NULL; |
| 260 | } |
| 261 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 262 | return split_channels_->high_channel(channel); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 263 | } |
| 264 | |
andrew@webrtc.org | c2e6438 | 2014-04-30 16:44:13 +0000 | [diff] [blame] | 265 | int16_t* AudioBuffer::high_pass_split_data(int channel) { |
| 266 | const AudioBuffer* t = this; |
| 267 | return const_cast<int16_t*>(t->high_pass_split_data(channel)); |
| 268 | } |
| 269 | |
| 270 | const int16_t* AudioBuffer::mixed_data(int channel) const { |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 271 | assert(channel >= 0 && channel < num_mixed_channels_); |
| 272 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 273 | return mixed_channels_->channel(channel); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 274 | } |
| 275 | |
andrew@webrtc.org | c2e6438 | 2014-04-30 16:44:13 +0000 | [diff] [blame] | 276 | const int16_t* AudioBuffer::mixed_low_pass_data(int channel) const { |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 277 | assert(channel >= 0 && channel < num_mixed_low_pass_channels_); |
| 278 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 279 | return mixed_low_pass_channels_->channel(channel); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 280 | } |
| 281 | |
andrew@webrtc.org | c2e6438 | 2014-04-30 16:44:13 +0000 | [diff] [blame] | 282 | const int16_t* AudioBuffer::low_pass_reference(int channel) const { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 283 | assert(channel >= 0 && channel < num_proc_channels_); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 284 | if (!reference_copied_) { |
| 285 | return NULL; |
| 286 | } |
| 287 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 288 | return low_pass_reference_channels_->channel(channel); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 289 | } |
| 290 | |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 291 | const float* AudioBuffer::keyboard_data() const { |
| 292 | return keyboard_data_; |
| 293 | } |
| 294 | |
andrew@webrtc.org | c2e6438 | 2014-04-30 16:44:13 +0000 | [diff] [blame] | 295 | SplitFilterStates* AudioBuffer::filter_states(int channel) { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 296 | assert(channel >= 0 && channel < num_proc_channels_); |
| 297 | return &filter_states_[channel]; |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | void AudioBuffer::set_activity(AudioFrame::VADActivity activity) { |
| 301 | activity_ = activity; |
| 302 | } |
| 303 | |
| 304 | AudioFrame::VADActivity AudioBuffer::activity() const { |
| 305 | return activity_; |
| 306 | } |
| 307 | |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 308 | int AudioBuffer::num_channels() const { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 309 | return num_proc_channels_; |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 310 | } |
| 311 | |
| 312 | int AudioBuffer::samples_per_channel() const { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 313 | return proc_samples_per_channel_; |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 314 | } |
| 315 | |
| 316 | int AudioBuffer::samples_per_split_channel() const { |
| 317 | return samples_per_split_channel_; |
| 318 | } |
| 319 | |
andrew@webrtc.org | fbf2568 | 2014-04-24 18:28:56 +0000 | [diff] [blame] | 320 | int AudioBuffer::samples_per_keyboard_channel() const { |
| 321 | // We don't resample the keyboard channel. |
| 322 | return input_samples_per_channel_; |
| 323 | } |
| 324 | |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 325 | // TODO(andrew): Do deinterleaving and mixing in one step? |
| 326 | void AudioBuffer::DeinterleaveFrom(AudioFrame* frame) { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 327 | assert(proc_samples_per_channel_ == input_samples_per_channel_); |
| 328 | assert(num_proc_channels_ == num_input_channels_); |
| 329 | assert(frame->num_channels_ == num_proc_channels_); |
| 330 | assert(frame->samples_per_channel_ == proc_samples_per_channel_); |
| 331 | InitForNewData(); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 332 | activity_ = frame->vad_activity_; |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 333 | |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 334 | if (num_proc_channels_ == 1) { |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 335 | // We can get away with a pointer assignment in this case. |
| 336 | data_ = frame->data_; |
| 337 | return; |
| 338 | } |
| 339 | |
| 340 | int16_t* interleaved = frame->data_; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 341 | for (int i = 0; i < num_proc_channels_; i++) { |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 342 | int16_t* deinterleaved = channels_->channel(i); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 343 | int interleaved_idx = i; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 344 | for (int j = 0; j < proc_samples_per_channel_; j++) { |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 345 | deinterleaved[j] = interleaved[interleaved_idx]; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 346 | interleaved_idx += num_proc_channels_; |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 347 | } |
| 348 | } |
| 349 | } |
| 350 | |
| 351 | void AudioBuffer::InterleaveTo(AudioFrame* frame, bool data_changed) const { |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 352 | assert(proc_samples_per_channel_ == output_samples_per_channel_); |
| 353 | assert(num_proc_channels_ == num_input_channels_); |
| 354 | assert(frame->num_channels_ == num_proc_channels_); |
| 355 | assert(frame->samples_per_channel_ == proc_samples_per_channel_); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 356 | frame->vad_activity_ = activity_; |
| 357 | |
| 358 | if (!data_changed) { |
| 359 | return; |
| 360 | } |
| 361 | |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 362 | if (num_proc_channels_ == 1) { |
kwiberg@webrtc.org | 8b4f539 | 2014-05-08 07:10:11 +0000 | [diff] [blame] | 363 | assert(data_ == frame->data_); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 364 | return; |
| 365 | } |
| 366 | |
| 367 | int16_t* interleaved = frame->data_; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 368 | for (int i = 0; i < num_proc_channels_; i++) { |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 369 | int16_t* deinterleaved = channels_->channel(i); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 370 | int interleaved_idx = i; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 371 | for (int j = 0; j < proc_samples_per_channel_; j++) { |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 372 | interleaved[interleaved_idx] = deinterleaved[j]; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 373 | interleaved_idx += num_proc_channels_; |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 374 | } |
| 375 | } |
| 376 | } |
| 377 | |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 378 | void AudioBuffer::CopyAndMix(int num_mixed_channels) { |
| 379 | // We currently only support the stereo to mono case. |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 380 | assert(num_proc_channels_ == 2); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 381 | assert(num_mixed_channels == 1); |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 382 | if (!mixed_channels_.get()) { |
| 383 | mixed_channels_.reset( |
| 384 | new ChannelBuffer<int16_t>(proc_samples_per_channel_, |
| 385 | num_mixed_channels)); |
| 386 | } |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 387 | |
mflodman@webrtc.org | 409cf2a | 2014-05-14 09:39:56 +0000 | [diff] [blame] | 388 | StereoToMono(channels_->channel(0), |
| 389 | channels_->channel(1), |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 390 | mixed_channels_->channel(0), |
| 391 | proc_samples_per_channel_); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 392 | |
| 393 | num_mixed_channels_ = num_mixed_channels; |
| 394 | } |
| 395 | |
| 396 | void AudioBuffer::CopyAndMixLowPass(int num_mixed_channels) { |
| 397 | // We currently only support the stereo to mono case. |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 398 | assert(num_proc_channels_ == 2); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 399 | assert(num_mixed_channels == 1); |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 400 | if (!mixed_low_pass_channels_.get()) { |
| 401 | mixed_low_pass_channels_.reset( |
| 402 | new ChannelBuffer<int16_t>(samples_per_split_channel_, |
| 403 | num_mixed_channels)); |
| 404 | } |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 405 | |
| 406 | StereoToMono(low_pass_split_data(0), |
| 407 | low_pass_split_data(1), |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 408 | mixed_low_pass_channels_->channel(0), |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 409 | samples_per_split_channel_); |
| 410 | |
| 411 | num_mixed_low_pass_channels_ = num_mixed_channels; |
| 412 | } |
| 413 | |
| 414 | void AudioBuffer::CopyLowPassToReference() { |
| 415 | reference_copied_ = true; |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 416 | if (!low_pass_reference_channels_.get()) { |
| 417 | low_pass_reference_channels_.reset( |
| 418 | new ChannelBuffer<int16_t>(samples_per_split_channel_, |
| 419 | num_proc_channels_)); |
| 420 | } |
| 421 | for (int i = 0; i < num_proc_channels_; i++) { |
| 422 | low_pass_reference_channels_->CopyFrom(low_pass_split_data(i), i); |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 423 | } |
| 424 | } |
andrew@webrtc.org | 2e24460 | 2014-04-22 21:00:04 +0000 | [diff] [blame] | 425 | |
andrew@webrtc.org | a7b57da | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 426 | } // namespace webrtc |