niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1 | /* |
bjornv@webrtc.org | 0c6f931 | 2012-01-30 09:39:08 +0000 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 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 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "modules/audio_processing/echo_control_mobile_impl.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 12 | |
pbos@webrtc.org | 12dc1a3 | 2013-08-05 16:22:53 +0000 | [diff] [blame] | 13 | #include <string.h> |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 14 | |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 15 | #include <cstdint> |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 16 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 17 | #include "modules/audio_processing/aecm/echo_control_mobile.h" |
| 18 | #include "modules/audio_processing/audio_buffer.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 19 | #include "modules/audio_processing/include/audio_processing.h" |
| 20 | #include "rtc_base/checks.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 21 | #include "rtc_base/constructor_magic.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 22 | |
| 23 | namespace webrtc { |
| 24 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 25 | namespace { |
Sam Zackrisson | 8c147b6 | 2018-09-28 12:40:47 +0200 | [diff] [blame] | 26 | int16_t MapSetting(EchoControlMobileImpl::RoutingMode mode) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 27 | switch (mode) { |
Sam Zackrisson | 8c147b6 | 2018-09-28 12:40:47 +0200 | [diff] [blame] | 28 | case EchoControlMobileImpl::kQuietEarpieceOrHeadset: |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 29 | return 0; |
Sam Zackrisson | 8c147b6 | 2018-09-28 12:40:47 +0200 | [diff] [blame] | 30 | case EchoControlMobileImpl::kEarpiece: |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 31 | return 1; |
Sam Zackrisson | 8c147b6 | 2018-09-28 12:40:47 +0200 | [diff] [blame] | 32 | case EchoControlMobileImpl::kLoudEarpiece: |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 33 | return 2; |
Sam Zackrisson | 8c147b6 | 2018-09-28 12:40:47 +0200 | [diff] [blame] | 34 | case EchoControlMobileImpl::kSpeakerphone: |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 35 | return 3; |
Sam Zackrisson | 8c147b6 | 2018-09-28 12:40:47 +0200 | [diff] [blame] | 36 | case EchoControlMobileImpl::kLoudSpeakerphone: |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 37 | return 4; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 38 | } |
nisse | eb4ca4e | 2017-01-12 02:24:27 -0800 | [diff] [blame] | 39 | RTC_NOTREACHED(); |
mflodman@webrtc.org | 657b2a4 | 2012-02-06 11:06:01 +0000 | [diff] [blame] | 40 | return -1; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 41 | } |
| 42 | |
peah | fa6228e | 2015-11-16 16:27:42 -0800 | [diff] [blame] | 43 | AudioProcessing::Error MapError(int err) { |
| 44 | switch (err) { |
| 45 | case AECM_UNSUPPORTED_FUNCTION_ERROR: |
| 46 | return AudioProcessing::kUnsupportedFunctionError; |
| 47 | case AECM_NULL_POINTER_ERROR: |
| 48 | return AudioProcessing::kNullPointerError; |
| 49 | case AECM_BAD_PARAMETER_ERROR: |
| 50 | return AudioProcessing::kBadParameterError; |
| 51 | case AECM_BAD_PARAMETER_WARNING: |
| 52 | return AudioProcessing::kBadStreamParameterWarning; |
| 53 | default: |
| 54 | // AECM_UNSPECIFIED_ERROR |
| 55 | // AECM_UNINITIALIZED_ERROR |
| 56 | return AudioProcessing::kUnspecifiedError; |
| 57 | } |
| 58 | } |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 59 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 60 | } // namespace |
| 61 | |
peah | 253534d | 2016-03-15 04:32:28 -0700 | [diff] [blame] | 62 | struct EchoControlMobileImpl::StreamProperties { |
| 63 | StreamProperties() = delete; |
| 64 | StreamProperties(int sample_rate_hz, |
| 65 | size_t num_reverse_channels, |
| 66 | size_t num_output_channels) |
| 67 | : sample_rate_hz(sample_rate_hz), |
| 68 | num_reverse_channels(num_reverse_channels), |
| 69 | num_output_channels(num_output_channels) {} |
| 70 | |
| 71 | int sample_rate_hz; |
| 72 | size_t num_reverse_channels; |
| 73 | size_t num_output_channels; |
| 74 | }; |
| 75 | |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 76 | class EchoControlMobileImpl::Canceller { |
| 77 | public: |
| 78 | Canceller() { |
| 79 | state_ = WebRtcAecm_Create(); |
| 80 | RTC_CHECK(state_); |
| 81 | } |
| 82 | |
| 83 | ~Canceller() { |
| 84 | RTC_DCHECK(state_); |
| 85 | WebRtcAecm_Free(state_); |
| 86 | } |
| 87 | |
| 88 | void* state() { |
| 89 | RTC_DCHECK(state_); |
| 90 | return state_; |
| 91 | } |
| 92 | |
Sam Zackrisson | c22f551 | 2018-11-05 16:10:00 +0100 | [diff] [blame] | 93 | void Initialize(int sample_rate_hz) { |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 94 | RTC_DCHECK(state_); |
| 95 | int error = WebRtcAecm_Init(state_, sample_rate_hz); |
| 96 | RTC_DCHECK_EQ(AudioProcessing::kNoError, error); |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | private: |
| 100 | void* state_; |
| 101 | RTC_DISALLOW_COPY_AND_ASSIGN(Canceller); |
| 102 | }; |
| 103 | |
Sam Zackrisson | c22f551 | 2018-11-05 16:10:00 +0100 | [diff] [blame] | 104 | EchoControlMobileImpl::EchoControlMobileImpl() |
Sam Zackrisson | 9cb0661 | 2019-11-22 17:03:48 +0100 | [diff] [blame] | 105 | : routing_mode_(kSpeakerphone), comfort_noise_enabled_(false) {} |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 106 | |
Sam Zackrisson | c22f551 | 2018-11-05 16:10:00 +0100 | [diff] [blame] | 107 | EchoControlMobileImpl::~EchoControlMobileImpl() {} |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 108 | |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 109 | void EchoControlMobileImpl::ProcessRenderAudio( |
| 110 | rtc::ArrayView<const int16_t> packed_render_audio) { |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 111 | RTC_DCHECK(stream_properties_); |
peah | fa6228e | 2015-11-16 16:27:42 -0800 | [diff] [blame] | 112 | |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 113 | size_t buffer_index = 0; |
| 114 | size_t num_frames_per_band = |
| 115 | packed_render_audio.size() / (stream_properties_->num_output_channels * |
| 116 | stream_properties_->num_reverse_channels); |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 117 | |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 118 | for (auto& canceller : cancellers_) { |
| 119 | WebRtcAecm_BufferFarend(canceller->state(), |
| 120 | &packed_render_audio[buffer_index], |
| 121 | num_frames_per_band); |
| 122 | |
| 123 | buffer_index += num_frames_per_band; |
| 124 | } |
| 125 | } |
| 126 | |
| 127 | void EchoControlMobileImpl::PackRenderAudioBuffer( |
| 128 | const AudioBuffer* audio, |
| 129 | size_t num_output_channels, |
| 130 | size_t num_channels, |
| 131 | std::vector<int16_t>* packed_buffer) { |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 132 | RTC_DCHECK_GE(AudioBuffer::kMaxSplitFrameLength, |
| 133 | audio->num_frames_per_band()); |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 134 | RTC_DCHECK_EQ(num_channels, audio->num_channels()); |
| 135 | |
| 136 | // The ordering convention must be followed to pass to the correct AECM. |
| 137 | packed_buffer->clear(); |
| 138 | int render_channel = 0; |
| 139 | for (size_t i = 0; i < num_output_channels; i++) { |
| 140 | for (size_t j = 0; j < audio->num_channels(); j++) { |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 141 | std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> data_to_buffer; |
Per Åhgren | d47941e | 2019-08-22 11:51:13 +0200 | [diff] [blame] | 142 | FloatS16ToS16(audio->split_bands_const(render_channel)[kBand0To8kHz], |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 143 | audio->num_frames_per_band(), data_to_buffer.data()); |
| 144 | |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 145 | // Buffer the samples in the render queue. |
| 146 | packed_buffer->insert( |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 147 | packed_buffer->end(), data_to_buffer.data(), |
| 148 | data_to_buffer.data() + audio->num_frames_per_band()); |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 149 | render_channel = (render_channel + 1) % audio->num_channels(); |
peah | fa6228e | 2015-11-16 16:27:42 -0800 | [diff] [blame] | 150 | } |
| 151 | } |
| 152 | } |
| 153 | |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 154 | size_t EchoControlMobileImpl::NumCancellersRequired( |
| 155 | size_t num_output_channels, |
| 156 | size_t num_reverse_channels) { |
| 157 | return num_output_channels * num_reverse_channels; |
| 158 | } |
| 159 | |
peah | 253534d | 2016-03-15 04:32:28 -0700 | [diff] [blame] | 160 | int EchoControlMobileImpl::ProcessCaptureAudio(AudioBuffer* audio, |
| 161 | int stream_delay_ms) { |
peah | 253534d | 2016-03-15 04:32:28 -0700 | [diff] [blame] | 162 | RTC_DCHECK(stream_properties_); |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 163 | RTC_DCHECK_GE(160, audio->num_frames_per_band()); |
peah | 253534d | 2016-03-15 04:32:28 -0700 | [diff] [blame] | 164 | RTC_DCHECK_EQ(audio->num_channels(), stream_properties_->num_output_channels); |
| 165 | RTC_DCHECK_GE(cancellers_.size(), stream_properties_->num_reverse_channels * |
| 166 | audio->num_channels()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 167 | |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 168 | int err = AudioProcessing::kNoError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 169 | |
| 170 | // The ordering convention must be followed to pass to the correct AECM. |
| 171 | size_t handle_index = 0; |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 172 | for (size_t capture = 0; capture < audio->num_channels(); ++capture) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 173 | // TODO(ajm): improve how this works, possibly inside AECM. |
| 174 | // This is kind of hacked up. |
Per Åhgren | a135127 | 2019-08-15 12:15:46 +0200 | [diff] [blame] | 175 | RTC_DCHECK_LT(capture, low_pass_reference_.size()); |
| 176 | const int16_t* noisy = |
| 177 | reference_copied_ ? low_pass_reference_[capture].data() : nullptr; |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 178 | |
| 179 | RTC_DCHECK_GE(AudioBuffer::kMaxSplitFrameLength, |
| 180 | audio->num_frames_per_band()); |
| 181 | |
| 182 | std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> split_bands_data; |
| 183 | int16_t* split_bands = split_bands_data.data(); |
| 184 | const int16_t* clean = split_bands_data.data(); |
Per Åhgren | d47941e | 2019-08-22 11:51:13 +0200 | [diff] [blame] | 185 | if (audio->split_bands(capture)[kBand0To8kHz]) { |
| 186 | FloatS16ToS16(audio->split_bands(capture)[kBand0To8kHz], |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 187 | audio->num_frames_per_band(), split_bands_data.data()); |
| 188 | } else { |
| 189 | clean = nullptr; |
| 190 | split_bands = nullptr; |
| 191 | } |
| 192 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 193 | if (noisy == NULL) { |
| 194 | noisy = clean; |
| 195 | clean = NULL; |
| 196 | } |
peah | 253534d | 2016-03-15 04:32:28 -0700 | [diff] [blame] | 197 | for (size_t render = 0; render < stream_properties_->num_reverse_channels; |
| 198 | ++render) { |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 199 | err = WebRtcAecm_Process(cancellers_[handle_index]->state(), noisy, clean, |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 200 | split_bands, audio->num_frames_per_band(), |
| 201 | stream_delay_ms); |
| 202 | |
| 203 | if (split_bands) { |
| 204 | S16ToFloatS16(split_bands, audio->num_frames_per_band(), |
Per Åhgren | d47941e | 2019-08-22 11:51:13 +0200 | [diff] [blame] | 205 | audio->split_bands(capture)[kBand0To8kHz]); |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 206 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 207 | |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 208 | if (err != AudioProcessing::kNoError) { |
peah | fa6228e | 2015-11-16 16:27:42 -0800 | [diff] [blame] | 209 | return MapError(err); |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 210 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 211 | |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 212 | ++handle_index; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 213 | } |
aluebs | 776593b | 2016-03-15 14:04:58 -0700 | [diff] [blame] | 214 | for (size_t band = 1u; band < audio->num_bands(); ++band) { |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 215 | memset(audio->split_bands_f(capture)[band], 0, |
aluebs | 776593b | 2016-03-15 14:04:58 -0700 | [diff] [blame] | 216 | audio->num_frames_per_band() * |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 217 | sizeof(audio->split_bands_f(capture)[band][0])); |
aluebs | 776593b | 2016-03-15 14:04:58 -0700 | [diff] [blame] | 218 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 219 | } |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 220 | return AudioProcessing::kNoError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 221 | } |
| 222 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 223 | int EchoControlMobileImpl::set_routing_mode(RoutingMode mode) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 224 | if (MapSetting(mode) == -1) { |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 225 | return AudioProcessing::kBadParameterError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 226 | } |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 227 | routing_mode_ = mode; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 228 | return Configure(); |
| 229 | } |
| 230 | |
Sam Zackrisson | 8c147b6 | 2018-09-28 12:40:47 +0200 | [diff] [blame] | 231 | EchoControlMobileImpl::RoutingMode EchoControlMobileImpl::routing_mode() const { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 232 | return routing_mode_; |
| 233 | } |
| 234 | |
| 235 | int EchoControlMobileImpl::enable_comfort_noise(bool enable) { |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 236 | comfort_noise_enabled_ = enable; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 237 | return Configure(); |
| 238 | } |
| 239 | |
| 240 | bool EchoControlMobileImpl::is_comfort_noise_enabled() const { |
| 241 | return comfort_noise_enabled_; |
| 242 | } |
| 243 | |
peah | 253534d | 2016-03-15 04:32:28 -0700 | [diff] [blame] | 244 | void EchoControlMobileImpl::Initialize(int sample_rate_hz, |
| 245 | size_t num_reverse_channels, |
| 246 | size_t num_output_channels) { |
Sam Zackrisson | 9cb0661 | 2019-11-22 17:03:48 +0100 | [diff] [blame] | 247 | low_pass_reference_.resize(num_output_channels); |
| 248 | for (auto& reference : low_pass_reference_) { |
| 249 | reference.fill(0); |
| 250 | } |
Per Åhgren | a135127 | 2019-08-15 12:15:46 +0200 | [diff] [blame] | 251 | |
peah | 253534d | 2016-03-15 04:32:28 -0700 | [diff] [blame] | 252 | stream_properties_.reset(new StreamProperties( |
| 253 | sample_rate_hz, num_reverse_channels, num_output_channels)); |
| 254 | |
Jonas Olsson | 645b027 | 2018-02-15 15:16:27 +0100 | [diff] [blame] | 255 | // AECM only supports 16 kHz or lower sample rates. |
| 256 | RTC_DCHECK_LE(stream_properties_->sample_rate_hz, |
| 257 | AudioProcessing::kSampleRate16kHz); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 258 | |
peah | a062460 | 2016-10-25 04:45:24 -0700 | [diff] [blame] | 259 | cancellers_.resize( |
| 260 | NumCancellersRequired(stream_properties_->num_output_channels, |
| 261 | stream_properties_->num_reverse_channels)); |
| 262 | |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 263 | for (auto& canceller : cancellers_) { |
| 264 | if (!canceller) { |
| 265 | canceller.reset(new Canceller()); |
| 266 | } |
Sam Zackrisson | c22f551 | 2018-11-05 16:10:00 +0100 | [diff] [blame] | 267 | canceller->Initialize(sample_rate_hz); |
peah | fa6228e | 2015-11-16 16:27:42 -0800 | [diff] [blame] | 268 | } |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 269 | Configure(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 270 | } |
| 271 | |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 272 | int EchoControlMobileImpl::Configure() { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 273 | AecmConfig config; |
| 274 | config.cngMode = comfort_noise_enabled_; |
| 275 | config.echoMode = MapSetting(routing_mode_); |
peah | bb9edbd | 2016-03-10 12:54:25 -0800 | [diff] [blame] | 276 | int error = AudioProcessing::kNoError; |
| 277 | for (auto& canceller : cancellers_) { |
| 278 | int handle_error = WebRtcAecm_set_config(canceller->state(), config); |
| 279 | if (handle_error != AudioProcessing::kNoError) { |
| 280 | error = handle_error; |
| 281 | } |
| 282 | } |
| 283 | return error; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 284 | } |
| 285 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 286 | } // namespace webrtc |