henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | 65c7f67 | 2016-02-12 00:05:01 -0800 | [diff] [blame] | 2 | * Copyright 2011 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | 65c7f67 | 2016-02-12 00:05:01 -0800 | [diff] [blame] | 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. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "pc/currentspeakermonitor.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 12 | |
terelius | 8c011e5 | 2016-04-26 05:28:11 -0700 | [diff] [blame] | 13 | #include <vector> |
| 14 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 15 | #include "media/base/streamparams.h" |
| 16 | #include "pc/audiomonitor.h" |
| 17 | #include "rtc_base/logging.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 18 | |
| 19 | namespace cricket { |
| 20 | |
| 21 | namespace { |
| 22 | const int kMaxAudioLevel = 9; |
| 23 | // To avoid overswitching, we disable switching for a period of time after a |
| 24 | // switch is done. |
| 25 | const int kDefaultMinTimeBetweenSwitches = 1000; |
| 26 | } |
| 27 | |
buildbot@webrtc.org | ca27236 | 2014-05-08 23:10:23 +0000 | [diff] [blame] | 28 | CurrentSpeakerMonitor::CurrentSpeakerMonitor( |
deadbeef | d59daf8 | 2015-10-14 15:02:44 -0700 | [diff] [blame] | 29 | AudioSourceContext* audio_source_context) |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 30 | : started_(false), |
buildbot@webrtc.org | ca27236 | 2014-05-08 23:10:23 +0000 | [diff] [blame] | 31 | audio_source_context_(audio_source_context), |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 32 | current_speaker_ssrc_(0), |
| 33 | earliest_permitted_switch_time_(0), |
deadbeef | d59daf8 | 2015-10-14 15:02:44 -0700 | [diff] [blame] | 34 | min_time_between_switches_(kDefaultMinTimeBetweenSwitches) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 35 | |
| 36 | CurrentSpeakerMonitor::~CurrentSpeakerMonitor() { |
| 37 | Stop(); |
| 38 | } |
| 39 | |
| 40 | void CurrentSpeakerMonitor::Start() { |
| 41 | if (!started_) { |
buildbot@webrtc.org | ca27236 | 2014-05-08 23:10:23 +0000 | [diff] [blame] | 42 | audio_source_context_->SignalAudioMonitor.connect( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 43 | this, &CurrentSpeakerMonitor::OnAudioMonitor); |
buildbot@webrtc.org | ca27236 | 2014-05-08 23:10:23 +0000 | [diff] [blame] | 44 | audio_source_context_->SignalMediaStreamsUpdate.connect( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 45 | this, &CurrentSpeakerMonitor::OnMediaStreamsUpdate); |
buildbot@webrtc.org | 49a6a27 | 2014-05-21 00:24:54 +0000 | [diff] [blame] | 46 | audio_source_context_->SignalMediaStreamsReset.connect( |
| 47 | this, &CurrentSpeakerMonitor::OnMediaStreamsReset); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 48 | |
| 49 | started_ = true; |
| 50 | } |
| 51 | } |
| 52 | |
| 53 | void CurrentSpeakerMonitor::Stop() { |
| 54 | if (started_) { |
buildbot@webrtc.org | ca27236 | 2014-05-08 23:10:23 +0000 | [diff] [blame] | 55 | audio_source_context_->SignalAudioMonitor.disconnect(this); |
| 56 | audio_source_context_->SignalMediaStreamsUpdate.disconnect(this); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 57 | |
| 58 | started_ = false; |
| 59 | ssrc_to_speaking_state_map_.clear(); |
| 60 | current_speaker_ssrc_ = 0; |
| 61 | earliest_permitted_switch_time_ = 0; |
| 62 | } |
| 63 | } |
| 64 | |
| 65 | void CurrentSpeakerMonitor::set_min_time_between_switches( |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 66 | int min_time_between_switches) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 67 | min_time_between_switches_ = min_time_between_switches; |
| 68 | } |
| 69 | |
buildbot@webrtc.org | ca27236 | 2014-05-08 23:10:23 +0000 | [diff] [blame] | 70 | void CurrentSpeakerMonitor::OnAudioMonitor( |
| 71 | AudioSourceContext* audio_source_context, const AudioInfo& info) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 72 | std::map<uint32_t, int> active_ssrc_to_level_map; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 73 | cricket::AudioInfo::StreamList::const_iterator stream_list_it; |
| 74 | for (stream_list_it = info.active_streams.begin(); |
| 75 | stream_list_it != info.active_streams.end(); ++stream_list_it) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 76 | uint32_t ssrc = stream_list_it->first; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 77 | active_ssrc_to_level_map[ssrc] = stream_list_it->second; |
| 78 | |
| 79 | // It's possible we haven't yet added this source to our map. If so, |
| 80 | // add it now with a "not speaking" state. |
| 81 | if (ssrc_to_speaking_state_map_.find(ssrc) == |
| 82 | ssrc_to_speaking_state_map_.end()) { |
| 83 | ssrc_to_speaking_state_map_[ssrc] = SS_NOT_SPEAKING; |
| 84 | } |
| 85 | } |
| 86 | |
| 87 | int max_level = 0; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 88 | uint32_t loudest_speaker_ssrc = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 89 | |
| 90 | // Update the speaking states of all participants based on the new audio |
| 91 | // level information. Also retain loudest speaker. |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 92 | std::map<uint32_t, SpeakingState>::iterator state_it; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 93 | for (state_it = ssrc_to_speaking_state_map_.begin(); |
| 94 | state_it != ssrc_to_speaking_state_map_.end(); ++state_it) { |
| 95 | bool is_previous_speaker = current_speaker_ssrc_ == state_it->first; |
| 96 | |
| 97 | // This uses a state machine in order to gradually identify |
| 98 | // members as having started or stopped speaking. Matches the |
| 99 | // algorithm used by the hangouts js code. |
| 100 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 101 | std::map<uint32_t, int>::const_iterator level_it = |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 102 | active_ssrc_to_level_map.find(state_it->first); |
| 103 | // Note that the stream map only contains streams with non-zero audio |
| 104 | // levels. |
| 105 | int level = (level_it != active_ssrc_to_level_map.end()) ? |
| 106 | level_it->second : 0; |
| 107 | switch (state_it->second) { |
| 108 | case SS_NOT_SPEAKING: |
| 109 | if (level > 0) { |
| 110 | // Reset level because we don't think they're really speaking. |
| 111 | level = 0; |
| 112 | state_it->second = SS_MIGHT_BE_SPEAKING; |
| 113 | } else { |
| 114 | // State unchanged. |
| 115 | } |
| 116 | break; |
| 117 | case SS_MIGHT_BE_SPEAKING: |
| 118 | if (level > 0) { |
| 119 | state_it->second = SS_SPEAKING; |
| 120 | } else { |
| 121 | state_it->second = SS_NOT_SPEAKING; |
| 122 | } |
| 123 | break; |
| 124 | case SS_SPEAKING: |
| 125 | if (level > 0) { |
| 126 | // State unchanged. |
| 127 | } else { |
| 128 | state_it->second = SS_WAS_SPEAKING_RECENTLY1; |
| 129 | if (is_previous_speaker) { |
| 130 | // Assume this is an inter-word silence and assign him the highest |
| 131 | // volume. |
| 132 | level = kMaxAudioLevel; |
| 133 | } |
| 134 | } |
| 135 | break; |
| 136 | case SS_WAS_SPEAKING_RECENTLY1: |
| 137 | if (level > 0) { |
| 138 | state_it->second = SS_SPEAKING; |
| 139 | } else { |
| 140 | state_it->second = SS_WAS_SPEAKING_RECENTLY2; |
| 141 | if (is_previous_speaker) { |
| 142 | // Assume this is an inter-word silence and assign him the highest |
| 143 | // volume. |
| 144 | level = kMaxAudioLevel; |
| 145 | } |
| 146 | } |
| 147 | break; |
| 148 | case SS_WAS_SPEAKING_RECENTLY2: |
| 149 | if (level > 0) { |
| 150 | state_it->second = SS_SPEAKING; |
| 151 | } else { |
| 152 | state_it->second = SS_NOT_SPEAKING; |
| 153 | } |
| 154 | break; |
| 155 | } |
| 156 | |
| 157 | if (level > max_level) { |
| 158 | loudest_speaker_ssrc = state_it->first; |
| 159 | max_level = level; |
| 160 | } else if (level > 0 && level == max_level && is_previous_speaker) { |
| 161 | // Favor continuity of loudest speakers if audio levels are equal. |
| 162 | loudest_speaker_ssrc = state_it->first; |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | // We avoid over-switching by disabling switching for a period of time after |
| 167 | // a switch is done. |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 168 | int64_t now = rtc::TimeMillis(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 169 | if (earliest_permitted_switch_time_ <= now && |
| 170 | current_speaker_ssrc_ != loudest_speaker_ssrc) { |
| 171 | current_speaker_ssrc_ = loudest_speaker_ssrc; |
| 172 | LOG(LS_INFO) << "Current speaker changed to " << current_speaker_ssrc_; |
| 173 | earliest_permitted_switch_time_ = now + min_time_between_switches_; |
| 174 | SignalUpdate(this, current_speaker_ssrc_); |
| 175 | } |
| 176 | } |
| 177 | |
buildbot@webrtc.org | ca27236 | 2014-05-08 23:10:23 +0000 | [diff] [blame] | 178 | void CurrentSpeakerMonitor::OnMediaStreamsUpdate( |
deadbeef | d59daf8 | 2015-10-14 15:02:44 -0700 | [diff] [blame] | 179 | AudioSourceContext* audio_source_context, |
| 180 | const MediaStreams& added, |
| 181 | const MediaStreams& removed) { |
| 182 | if (audio_source_context == audio_source_context_) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 183 | // Update the speaking state map based on added and removed streams. |
| 184 | for (std::vector<cricket::StreamParams>::const_iterator |
buildbot@webrtc.org | 49a6a27 | 2014-05-21 00:24:54 +0000 | [diff] [blame] | 185 | it = removed.audio().begin(); it != removed.audio().end(); ++it) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 186 | ssrc_to_speaking_state_map_.erase(it->first_ssrc()); |
| 187 | } |
| 188 | |
| 189 | for (std::vector<cricket::StreamParams>::const_iterator |
buildbot@webrtc.org | 49a6a27 | 2014-05-21 00:24:54 +0000 | [diff] [blame] | 190 | it = added.audio().begin(); it != added.audio().end(); ++it) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 191 | ssrc_to_speaking_state_map_[it->first_ssrc()] = SS_NOT_SPEAKING; |
| 192 | } |
| 193 | } |
| 194 | } |
| 195 | |
buildbot@webrtc.org | 49a6a27 | 2014-05-21 00:24:54 +0000 | [diff] [blame] | 196 | void CurrentSpeakerMonitor::OnMediaStreamsReset( |
deadbeef | d59daf8 | 2015-10-14 15:02:44 -0700 | [diff] [blame] | 197 | AudioSourceContext* audio_source_context) { |
| 198 | if (audio_source_context == audio_source_context_) { |
buildbot@webrtc.org | 49a6a27 | 2014-05-21 00:24:54 +0000 | [diff] [blame] | 199 | ssrc_to_speaking_state_map_.clear(); |
| 200 | } |
| 201 | } |
| 202 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 203 | } // namespace cricket |