aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [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 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 11 | #include "webrtc/modules/audio_mixer/audio_mixer_impl.h" |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 12 | |
| 13 | #include <algorithm> |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 14 | #include <functional> |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 15 | #include <utility> |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 16 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 17 | #include "webrtc/base/thread_annotations.h" |
aleloi | 5bcc00e | 2016-08-15 03:01:31 -0700 | [diff] [blame] | 18 | #include "webrtc/modules/audio_mixer/audio_frame_manipulator.h" |
| 19 | #include "webrtc/modules/audio_mixer/audio_mixer_defines.h" |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 20 | #include "webrtc/modules/audio_processing/include/audio_processing.h" |
| 21 | #include "webrtc/modules/utility/include/audio_frame_operations.h" |
| 22 | #include "webrtc/system_wrappers/include/critical_section_wrapper.h" |
| 23 | #include "webrtc/system_wrappers/include/trace.h" |
| 24 | |
| 25 | namespace webrtc { |
| 26 | namespace { |
| 27 | |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 28 | class SourceFrame { |
| 29 | public: |
| 30 | SourceFrame(MixerAudioSource* p, AudioFrame* a, bool m, bool was_mixed_before) |
| 31 | : audio_source_(p), |
| 32 | audio_frame_(a), |
| 33 | muted_(m), |
| 34 | was_mixed_before_(was_mixed_before) { |
| 35 | if (!muted_) { |
aleloi | 5bcc00e | 2016-08-15 03:01:31 -0700 | [diff] [blame] | 36 | energy_ = NewMixerCalculateEnergy(*a); |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 37 | } |
| 38 | } |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 39 | |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 40 | // a.shouldMixBefore(b) is used to select mixer participants. |
| 41 | bool shouldMixBefore(const SourceFrame& other) const { |
| 42 | if (muted_ != other.muted_) { |
| 43 | return other.muted_; |
| 44 | } |
| 45 | |
| 46 | auto our_activity = audio_frame_->vad_activity_; |
| 47 | auto other_activity = other.audio_frame_->vad_activity_; |
| 48 | |
| 49 | if (our_activity != other_activity) { |
| 50 | return our_activity == AudioFrame::kVadActive; |
| 51 | } |
| 52 | |
| 53 | return energy_ > other.energy_; |
| 54 | } |
| 55 | |
| 56 | MixerAudioSource* audio_source_; |
| 57 | AudioFrame* audio_frame_; |
| 58 | bool muted_; |
| 59 | uint32_t energy_; |
| 60 | bool was_mixed_before_; |
| 61 | }; |
terelius | ea4c141 | 2016-07-29 01:36:14 -0700 | [diff] [blame] | 62 | |
aleloi | 4496809 | 2016-08-08 10:18:58 -0700 | [diff] [blame] | 63 | // Remixes a frame between stereo and mono. |
| 64 | void RemixFrame(AudioFrame* frame, size_t number_of_channels) { |
| 65 | RTC_DCHECK(number_of_channels == 1 || number_of_channels == 2); |
| 66 | if (frame->num_channels_ == 1 && number_of_channels == 2) { |
| 67 | AudioFrameOperations::MonoToStereo(frame); |
| 68 | } else if (frame->num_channels_ == 2 && number_of_channels == 1) { |
| 69 | AudioFrameOperations::StereoToMono(frame); |
| 70 | } |
| 71 | } |
| 72 | |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 73 | // Mix |frame| into |mixed_frame|, with saturation protection and upmixing. |
| 74 | // These effects are applied to |frame| itself prior to mixing. Assumes that |
| 75 | // |mixed_frame| always has at least as many channels as |frame|. Supports |
| 76 | // stereo at most. |
| 77 | // |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 78 | void MixFrames(AudioFrame* mixed_frame, AudioFrame* frame, bool use_limiter) { |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 79 | RTC_DCHECK_GE(mixed_frame->num_channels_, frame->num_channels_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 80 | if (use_limiter) { |
| 81 | // Divide by two to avoid saturation in the mixing. |
| 82 | // This is only meaningful if the limiter will be used. |
| 83 | *frame >>= 1; |
| 84 | } |
aleloi | 4496809 | 2016-08-08 10:18:58 -0700 | [diff] [blame] | 85 | RTC_DCHECK_EQ(frame->num_channels_, mixed_frame->num_channels_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 86 | *mixed_frame += *frame; |
| 87 | } |
| 88 | |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 89 | } // namespace |
| 90 | |
| 91 | MixerAudioSource::MixerAudioSource() : _mixHistory(new NewMixHistory()) {} |
| 92 | |
| 93 | MixerAudioSource::~MixerAudioSource() { |
| 94 | delete _mixHistory; |
| 95 | } |
| 96 | |
| 97 | bool MixerAudioSource::IsMixed() const { |
| 98 | return _mixHistory->IsMixed(); |
| 99 | } |
| 100 | |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 101 | NewMixHistory::NewMixHistory() : is_mixed_(0) {} |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 102 | |
| 103 | NewMixHistory::~NewMixHistory() {} |
| 104 | |
| 105 | bool NewMixHistory::IsMixed() const { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 106 | return is_mixed_; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | bool NewMixHistory::WasMixed() const { |
| 110 | // Was mixed is the same as is mixed depending on perspective. This function |
| 111 | // is for the perspective of NewAudioConferenceMixerImpl. |
| 112 | return IsMixed(); |
| 113 | } |
| 114 | |
| 115 | int32_t NewMixHistory::SetIsMixed(const bool mixed) { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 116 | is_mixed_ = mixed; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 117 | return 0; |
| 118 | } |
| 119 | |
| 120 | void NewMixHistory::ResetMixedStatus() { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 121 | is_mixed_ = false; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 122 | } |
| 123 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 124 | std::unique_ptr<AudioMixer> AudioMixer::Create(int id) { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 125 | return AudioMixerImpl::Create(id); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 126 | } |
| 127 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 128 | AudioMixerImpl::AudioMixerImpl(int id, std::unique_ptr<AudioProcessing> limiter) |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 129 | : id_(id), |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 130 | audio_source_list_(), |
| 131 | additional_audio_source_list_(), |
| 132 | num_mixed_audio_sources_(0), |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 133 | use_limiter_(true), |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 134 | time_stamp_(0), |
| 135 | limiter_(std::move(limiter)) { |
| 136 | SetOutputFrequency(kDefaultFrequency); |
aleloi | 8b2233f | 2016-07-28 06:24:14 -0700 | [diff] [blame] | 137 | thread_checker_.DetachFromThread(); |
aleloi | a0db81f | 2016-07-28 06:36:22 -0700 | [diff] [blame] | 138 | } |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 139 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 140 | AudioMixerImpl::~AudioMixerImpl() {} |
aleloi | 70f866c | 2016-08-16 02:15:49 -0700 | [diff] [blame] | 141 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 142 | std::unique_ptr<AudioMixer> AudioMixerImpl::Create(int id) { |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 143 | Config config; |
| 144 | config.Set<ExperimentalAgc>(new ExperimentalAgc(false)); |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 145 | std::unique_ptr<AudioProcessing> limiter(AudioProcessing::Create(config)); |
| 146 | if (!limiter.get()) |
| 147 | return nullptr; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 148 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 149 | if (limiter->gain_control()->set_mode(GainControl::kFixedDigital) != |
| 150 | limiter->kNoError) |
| 151 | return nullptr; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 152 | |
| 153 | // We smoothly limit the mixed frame to -7 dbFS. -6 would correspond to the |
| 154 | // divide-by-2 but -7 is used instead to give a bit of headroom since the |
| 155 | // AGC is not a hard limiter. |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 156 | if (limiter->gain_control()->set_target_level_dbfs(7) != limiter->kNoError) |
| 157 | return nullptr; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 158 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 159 | if (limiter->gain_control()->set_compression_gain_db(0) != limiter->kNoError) |
| 160 | return nullptr; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 161 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 162 | if (limiter->gain_control()->enable_limiter(true) != limiter->kNoError) |
| 163 | return nullptr; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 164 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 165 | if (limiter->gain_control()->Enable(true) != limiter->kNoError) |
| 166 | return nullptr; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 167 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 168 | return std::unique_ptr<AudioMixer>( |
| 169 | new AudioMixerImpl(id, std::move(limiter))); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 170 | } |
| 171 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 172 | void AudioMixerImpl::Mix(int sample_rate, |
| 173 | size_t number_of_channels, |
| 174 | AudioFrame* audio_frame_for_mixing) { |
aleloi | 4496809 | 2016-08-08 10:18:58 -0700 | [diff] [blame] | 175 | RTC_DCHECK(number_of_channels == 1 || number_of_channels == 2); |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 176 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 177 | std::map<int, MixerAudioSource*> mixedAudioSourcesMap; |
| 178 | |
| 179 | if (sample_rate != kNbInHz && sample_rate != kWbInHz && |
| 180 | sample_rate != kSwbInHz && sample_rate != kFbInHz) { |
| 181 | WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_, |
| 182 | "Invalid frequency: %d", sample_rate); |
| 183 | RTC_NOTREACHED(); |
| 184 | return; |
| 185 | } |
| 186 | |
| 187 | if (OutputFrequency() != sample_rate) { |
| 188 | SetOutputFrequency(static_cast<Frequency>(sample_rate)); |
| 189 | } |
| 190 | |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 191 | AudioFrameList mixList; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 192 | AudioFrameList additionalFramesList; |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 193 | int num_mixed_audio_sources; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 194 | { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 195 | rtc::CritScope lock(&crit_); |
aleloi | 30be5d7 | 2016-08-24 01:38:44 -0700 | [diff] [blame] | 196 | mixList = UpdateToMix(kMaximumAmountOfMixedAudioSources); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 197 | GetAdditionalAudio(&additionalFramesList); |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 198 | num_mixed_audio_sources = static_cast<int>(num_mixed_audio_sources_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 199 | } |
| 200 | |
aleloi | 4496809 | 2016-08-08 10:18:58 -0700 | [diff] [blame] | 201 | for (FrameAndMuteInfo& frame_and_mute : mixList) { |
| 202 | RemixFrame(frame_and_mute.frame, number_of_channels); |
| 203 | } |
| 204 | for (FrameAndMuteInfo& frame_and_mute : additionalFramesList) { |
| 205 | RemixFrame(frame_and_mute.frame, number_of_channels); |
| 206 | } |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 207 | |
| 208 | audio_frame_for_mixing->UpdateFrame( |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 209 | -1, time_stamp_, NULL, 0, output_frequency_, AudioFrame::kNormalSpeech, |
aleloi | 4496809 | 2016-08-08 10:18:58 -0700 | [diff] [blame] | 210 | AudioFrame::kVadPassive, number_of_channels); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 211 | |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 212 | time_stamp_ += static_cast<uint32_t>(sample_size_); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 213 | |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 214 | use_limiter_ = num_mixed_audio_sources > 1; |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 215 | |
| 216 | // We only use the limiter if it supports the output sample rate and |
| 217 | // we're actually mixing multiple streams. |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 218 | MixFromList(audio_frame_for_mixing, mixList, id_, use_limiter_); |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 219 | MixAnonomouslyFromList(audio_frame_for_mixing, additionalFramesList); |
| 220 | if (audio_frame_for_mixing->samples_per_channel_ == 0) { |
| 221 | // Nothing was mixed, set the audio samples to silence. |
| 222 | audio_frame_for_mixing->samples_per_channel_ = sample_size_; |
| 223 | audio_frame_for_mixing->Mute(); |
| 224 | } else { |
| 225 | // Only call the limiter if we have something to mix. |
| 226 | LimitMixedAudio(audio_frame_for_mixing); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 227 | } |
aleloi | 616df1e | 2016-08-24 01:17:12 -0700 | [diff] [blame] | 228 | |
| 229 | // Pass the final result to the level indicator. |
| 230 | audio_level_.ComputeLevel(*audio_frame_for_mixing); |
| 231 | |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 232 | return; |
| 233 | } |
| 234 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 235 | int32_t AudioMixerImpl::SetOutputFrequency(const Frequency& frequency) { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 236 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 237 | output_frequency_ = frequency; |
| 238 | sample_size_ = |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 239 | static_cast<size_t>((output_frequency_ * kFrameDurationInMs) / 1000); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 240 | |
| 241 | return 0; |
| 242 | } |
| 243 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 244 | AudioMixer::Frequency AudioMixerImpl::OutputFrequency() const { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 245 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 246 | return output_frequency_; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 247 | } |
| 248 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 249 | int32_t AudioMixerImpl::SetMixabilityStatus(MixerAudioSource* audio_source, |
| 250 | bool mixable) { |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 251 | if (!mixable) { |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 252 | // Anonymous audio sources are in a separate list. Make sure that the |
| 253 | // audio source is in the _audioSourceList if it is being mixed. |
| 254 | SetAnonymousMixabilityStatus(audio_source, false); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 255 | } |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 256 | { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 257 | rtc::CritScope lock(&crit_); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 258 | const bool isMixed = IsAudioSourceInList(*audio_source, audio_source_list_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 259 | // API must be called with a new state. |
| 260 | if (!(mixable ^ isMixed)) { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 261 | WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_, |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 262 | "Mixable is aready %s", isMixed ? "ON" : "off"); |
| 263 | return -1; |
| 264 | } |
| 265 | bool success = false; |
| 266 | if (mixable) { |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 267 | success = AddAudioSourceToList(audio_source, &audio_source_list_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 268 | } else { |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 269 | success = RemoveAudioSourceFromList(audio_source, &audio_source_list_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 270 | } |
| 271 | if (!success) { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 272 | WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_, |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 273 | "failed to %s audio_source", mixable ? "add" : "remove"); |
| 274 | RTC_NOTREACHED(); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 275 | return -1; |
| 276 | } |
| 277 | |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 278 | size_t numMixedNonAnonymous = audio_source_list_.size(); |
| 279 | if (numMixedNonAnonymous > kMaximumAmountOfMixedAudioSources) { |
| 280 | numMixedNonAnonymous = kMaximumAmountOfMixedAudioSources; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 281 | } |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 282 | num_mixed_audio_sources_ = |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 283 | numMixedNonAnonymous + additional_audio_source_list_.size(); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 284 | } |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 285 | return 0; |
| 286 | } |
| 287 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 288 | bool AudioMixerImpl::MixabilityStatus( |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 289 | const MixerAudioSource& audio_source) const { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 290 | rtc::CritScope lock(&crit_); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 291 | return IsAudioSourceInList(audio_source, audio_source_list_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 292 | } |
| 293 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 294 | int32_t AudioMixerImpl::SetAnonymousMixabilityStatus( |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 295 | MixerAudioSource* audio_source, |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 296 | bool anonymous) { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 297 | rtc::CritScope lock(&crit_); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 298 | if (IsAudioSourceInList(*audio_source, additional_audio_source_list_)) { |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 299 | if (anonymous) { |
| 300 | return 0; |
| 301 | } |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 302 | if (!RemoveAudioSourceFromList(audio_source, |
| 303 | &additional_audio_source_list_)) { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 304 | WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_, |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 305 | "unable to remove audio_source from anonymous list"); |
| 306 | RTC_NOTREACHED(); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 307 | return -1; |
| 308 | } |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 309 | return AddAudioSourceToList(audio_source, &audio_source_list_) ? 0 : -1; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 310 | } |
| 311 | if (!anonymous) { |
| 312 | return 0; |
| 313 | } |
| 314 | const bool mixable = |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 315 | RemoveAudioSourceFromList(audio_source, &audio_source_list_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 316 | if (!mixable) { |
| 317 | WEBRTC_TRACE( |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 318 | kTraceWarning, kTraceAudioMixerServer, id_, |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 319 | "audio_source must be registered before turning it into anonymous"); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 320 | // Setting anonymous status is only possible if MixerAudioSource is |
| 321 | // already registered. |
| 322 | return -1; |
| 323 | } |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 324 | return AddAudioSourceToList(audio_source, &additional_audio_source_list_) |
| 325 | ? 0 |
| 326 | : -1; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 327 | } |
| 328 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 329 | bool AudioMixerImpl::AnonymousMixabilityStatus( |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 330 | const MixerAudioSource& audio_source) const { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 331 | rtc::CritScope lock(&crit_); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 332 | return IsAudioSourceInList(audio_source, additional_audio_source_list_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 333 | } |
| 334 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 335 | AudioFrameList AudioMixerImpl::UpdateToMix(size_t maxAudioFrameCounter) const { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 336 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 337 | AudioFrameList result; |
| 338 | std::vector<SourceFrame> audioSourceMixingDataList; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 339 | |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 340 | // Get audio source audio and put it in the struct vector. |
| 341 | for (MixerAudioSource* audio_source : audio_source_list_) { |
| 342 | auto audio_frame_with_info = audio_source->GetAudioFrameWithMuted( |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 343 | id_, static_cast<int>(output_frequency_)); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 344 | |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 345 | auto audio_frame_info = audio_frame_with_info.audio_frame_info; |
| 346 | AudioFrame* audio_source_audio_frame = audio_frame_with_info.audio_frame; |
| 347 | |
| 348 | if (audio_frame_info == MixerAudioSource::AudioFrameInfo::kError) { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 349 | WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_, |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 350 | "failed to GetAudioFrameWithMuted() from participant"); |
terelius | ea4c141 | 2016-07-29 01:36:14 -0700 | [diff] [blame] | 351 | continue; |
| 352 | } |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 353 | audioSourceMixingDataList.emplace_back( |
| 354 | audio_source, audio_source_audio_frame, |
| 355 | audio_frame_info == MixerAudioSource::AudioFrameInfo::kMuted, |
| 356 | audio_source->_mixHistory->WasMixed()); |
| 357 | } |
| 358 | |
| 359 | // Sort frames by sorting function. |
| 360 | std::sort(audioSourceMixingDataList.begin(), audioSourceMixingDataList.end(), |
| 361 | std::mem_fn(&SourceFrame::shouldMixBefore)); |
| 362 | |
| 363 | // Go through list in order and put things in mixList. |
| 364 | for (SourceFrame& p : audioSourceMixingDataList) { |
| 365 | // Filter muted. |
| 366 | if (p.muted_) { |
| 367 | p.audio_source_->_mixHistory->SetIsMixed(false); |
| 368 | continue; |
terelius | ea4c141 | 2016-07-29 01:36:14 -0700 | [diff] [blame] | 369 | } |
aleloi | 2942e24 | 2016-07-29 01:23:49 -0700 | [diff] [blame] | 370 | |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 371 | // Add frame to result vector for mixing. |
| 372 | bool is_mixed = false; |
| 373 | if (maxAudioFrameCounter > 0) { |
| 374 | --maxAudioFrameCounter; |
| 375 | if (!p.was_mixed_before_) { |
aleloi | 5bcc00e | 2016-08-15 03:01:31 -0700 | [diff] [blame] | 376 | NewMixerRampIn(p.audio_frame_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 377 | } |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 378 | result.emplace_back(p.audio_frame_, false); |
| 379 | is_mixed = true; |
terelius | ea4c141 | 2016-07-29 01:36:14 -0700 | [diff] [blame] | 380 | } |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 381 | |
| 382 | // Ramp out unmuted. |
| 383 | if (p.was_mixed_before_ && !is_mixed) { |
aleloi | 5bcc00e | 2016-08-15 03:01:31 -0700 | [diff] [blame] | 384 | NewMixerRampOut(p.audio_frame_); |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 385 | result.emplace_back(p.audio_frame_, false); |
terelius | ea4c141 | 2016-07-29 01:36:14 -0700 | [diff] [blame] | 386 | } |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 387 | |
| 388 | p.audio_source_->_mixHistory->SetIsMixed(is_mixed); |
terelius | ea4c141 | 2016-07-29 01:36:14 -0700 | [diff] [blame] | 389 | } |
aleloi | f388257 | 2016-07-29 02:12:41 -0700 | [diff] [blame] | 390 | return result; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 391 | } |
| 392 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 393 | void AudioMixerImpl::GetAdditionalAudio( |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 394 | AudioFrameList* additionalFramesList) const { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 395 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 396 | WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_, |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 397 | "GetAdditionalAudio(additionalFramesList)"); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 398 | // The GetAudioFrameWithMuted() callback may result in the audio source being |
aleloi | a0db81f | 2016-07-28 06:36:22 -0700 | [diff] [blame] | 399 | // removed from additionalAudioFramesList_. If that happens it will |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 400 | // invalidate any iterators. Create a copy of the audio sources list such |
aleloi | a0db81f | 2016-07-28 06:36:22 -0700 | [diff] [blame] | 401 | // that the list of participants can be traversed safely. |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 402 | MixerAudioSourceList additionalAudioSourceList; |
| 403 | additionalAudioSourceList.insert(additionalAudioSourceList.begin(), |
| 404 | additional_audio_source_list_.begin(), |
| 405 | additional_audio_source_list_.end()); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 406 | |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 407 | for (MixerAudioSourceList::const_iterator audio_source = |
| 408 | additionalAudioSourceList.begin(); |
| 409 | audio_source != additionalAudioSourceList.end(); ++audio_source) { |
aleloi | a0db81f | 2016-07-28 06:36:22 -0700 | [diff] [blame] | 410 | auto audio_frame_with_info = |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 411 | (*audio_source)->GetAudioFrameWithMuted(id_, output_frequency_); |
aleloi | a0db81f | 2016-07-28 06:36:22 -0700 | [diff] [blame] | 412 | auto ret = audio_frame_with_info.audio_frame_info; |
| 413 | AudioFrame* audio_frame = audio_frame_with_info.audio_frame; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 414 | if (ret == MixerAudioSource::AudioFrameInfo::kError) { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 415 | WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_, |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 416 | "failed to GetAudioFrameWithMuted() from audio_source"); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 417 | continue; |
| 418 | } |
aleloi | a0db81f | 2016-07-28 06:36:22 -0700 | [diff] [blame] | 419 | if (audio_frame->samples_per_channel_ == 0) { |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 420 | // Empty frame. Don't use it. |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 421 | continue; |
| 422 | } |
| 423 | additionalFramesList->push_back(FrameAndMuteInfo( |
aleloi | a0db81f | 2016-07-28 06:36:22 -0700 | [diff] [blame] | 424 | audio_frame, ret == MixerAudioSource::AudioFrameInfo::kMuted)); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 425 | } |
| 426 | } |
| 427 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 428 | bool AudioMixerImpl::IsAudioSourceInList( |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 429 | const MixerAudioSource& audio_source, |
| 430 | const MixerAudioSourceList& audioSourceList) const { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 431 | WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_, |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 432 | "IsAudioSourceInList(audio_source,audioSourceList)"); |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 433 | return std::find(audioSourceList.begin(), audioSourceList.end(), |
| 434 | &audio_source) != audioSourceList.end(); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 435 | } |
| 436 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 437 | bool AudioMixerImpl::AddAudioSourceToList( |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 438 | MixerAudioSource* audio_source, |
| 439 | MixerAudioSourceList* audioSourceList) const { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 440 | WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_, |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 441 | "AddAudioSourceToList(audio_source, audioSourceList)"); |
| 442 | audioSourceList->push_back(audio_source); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 443 | // Make sure that the mixed status is correct for new MixerAudioSource. |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 444 | audio_source->_mixHistory->ResetMixedStatus(); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 445 | return true; |
| 446 | } |
| 447 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 448 | bool AudioMixerImpl::RemoveAudioSourceFromList( |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 449 | MixerAudioSource* audio_source, |
| 450 | MixerAudioSourceList* audioSourceList) const { |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 451 | WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_, |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 452 | "RemoveAudioSourceFromList(audio_source, audioSourceList)"); |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 453 | auto iter = |
| 454 | std::find(audioSourceList->begin(), audioSourceList->end(), audio_source); |
| 455 | if (iter != audioSourceList->end()) { |
| 456 | audioSourceList->erase(iter); |
| 457 | // AudioSource is no longer mixed, reset to default. |
| 458 | audio_source->_mixHistory->ResetMixedStatus(); |
| 459 | return true; |
| 460 | } else { |
| 461 | return false; |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 462 | } |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 463 | } |
| 464 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 465 | int32_t AudioMixerImpl::MixFromList(AudioFrame* mixedAudio, |
| 466 | const AudioFrameList& audioFrameList, |
| 467 | int32_t id, |
| 468 | bool use_limiter) { |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 469 | WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id, |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 470 | "MixFromList(mixedAudio, audioFrameList)"); |
| 471 | if (audioFrameList.empty()) |
| 472 | return 0; |
| 473 | |
| 474 | uint32_t position = 0; |
| 475 | |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 476 | if (audioFrameList.size() == 1) { |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 477 | mixedAudio->timestamp_ = audioFrameList.front().frame->timestamp_; |
| 478 | mixedAudio->elapsed_time_ms_ = |
| 479 | audioFrameList.front().frame->elapsed_time_ms_; |
| 480 | } else { |
| 481 | // TODO(wu): Issue 3390. |
| 482 | // Audio frame timestamp is only supported in one channel case. |
| 483 | mixedAudio->timestamp_ = 0; |
| 484 | mixedAudio->elapsed_time_ms_ = -1; |
| 485 | } |
| 486 | |
| 487 | for (AudioFrameList::const_iterator iter = audioFrameList.begin(); |
| 488 | iter != audioFrameList.end(); ++iter) { |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 489 | if (!iter->muted) { |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 490 | MixFrames(mixedAudio, iter->frame, use_limiter); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 491 | } |
| 492 | |
| 493 | position++; |
| 494 | } |
| 495 | |
| 496 | return 0; |
| 497 | } |
| 498 | |
| 499 | // TODO(andrew): consolidate this function with MixFromList. |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 500 | int32_t AudioMixerImpl::MixAnonomouslyFromList( |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 501 | AudioFrame* mixedAudio, |
| 502 | const AudioFrameList& audioFrameList) const { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 503 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 504 | WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_, |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 505 | "MixAnonomouslyFromList(mixedAudio, audioFrameList)"); |
| 506 | |
| 507 | if (audioFrameList.empty()) |
| 508 | return 0; |
| 509 | |
| 510 | for (AudioFrameList::const_iterator iter = audioFrameList.begin(); |
| 511 | iter != audioFrameList.end(); ++iter) { |
| 512 | if (!iter->muted) { |
| 513 | MixFrames(mixedAudio, iter->frame, use_limiter_); |
| 514 | } |
| 515 | } |
| 516 | return 0; |
| 517 | } |
| 518 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 519 | bool AudioMixerImpl::LimitMixedAudio(AudioFrame* mixedAudio) const { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 520 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 521 | if (!use_limiter_) { |
| 522 | return true; |
| 523 | } |
| 524 | |
| 525 | // Smoothly limit the mixed frame. |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 526 | const int error = limiter_->ProcessStream(mixedAudio); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 527 | |
| 528 | // And now we can safely restore the level. This procedure results in |
| 529 | // some loss of resolution, deemed acceptable. |
| 530 | // |
| 531 | // It's possible to apply the gain in the AGC (with a target level of 0 dbFS |
| 532 | // and compression gain of 6 dB). However, in the transition frame when this |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 533 | // is enabled (moving from one to two audio sources) it has the potential to |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 534 | // create discontinuities in the mixed frame. |
| 535 | // |
| 536 | // Instead we double the frame (with addition since left-shifting a |
| 537 | // negative value is undefined). |
| 538 | *mixedAudio += *mixedAudio; |
| 539 | |
aleloi | 6382a19 | 2016-08-08 10:25:04 -0700 | [diff] [blame] | 540 | if (error != limiter_->kNoError) { |
| 541 | WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_, |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 542 | "Error from AudioProcessing: %d", error); |
aleloi | 09f4510 | 2016-07-28 03:52:15 -0700 | [diff] [blame] | 543 | RTC_NOTREACHED(); |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 544 | return false; |
| 545 | } |
| 546 | return true; |
| 547 | } |
aleloi | 616df1e | 2016-08-24 01:17:12 -0700 | [diff] [blame] | 548 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 549 | int AudioMixerImpl::GetOutputAudioLevel() { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 550 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | 616df1e | 2016-08-24 01:17:12 -0700 | [diff] [blame] | 551 | const int level = audio_level_.Level(); |
| 552 | WEBRTC_TRACE(kTraceStateInfo, kTraceAudioMixerServer, id_, |
| 553 | "GetAudioOutputLevel() => level=%d", level); |
| 554 | return level; |
| 555 | } |
| 556 | |
aleloi | 5d167d6 | 2016-08-24 02:20:54 -0700 | [diff] [blame] | 557 | int AudioMixerImpl::GetOutputAudioLevelFullRange() { |
aleloi | 311525e | 2016-09-07 06:13:12 -0700 | [diff] [blame^] | 558 | RTC_DCHECK_RUN_ON(&thread_checker_); |
aleloi | 616df1e | 2016-08-24 01:17:12 -0700 | [diff] [blame] | 559 | const int level = audio_level_.LevelFullRange(); |
| 560 | WEBRTC_TRACE(kTraceStateInfo, kTraceAudioMixerServer, id_, |
| 561 | "GetAudioOutputLevelFullRange() => level=%d", level); |
| 562 | return level; |
| 563 | } |
aleloi | 77ad394 | 2016-07-04 06:33:02 -0700 | [diff] [blame] | 564 | } // namespace webrtc |