Add muted parameter to audio_frame_manipulator methods

webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 559 matching lines @@
         // TODO(henrike): this assert triggers in some test cases where SRTP is
         // used which prevents NetEQ from making a VAD. Temporarily disable this
         // assert until the problem is fixed on a higher level.
         // assert(audioFrame->vad_activity_ != AudioFrame::kVadUnknown);
         if (audioFrame->vad_activity_ == AudioFrame::kVadUnknown) {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                          "invalid VAD state from participant");
         }
 
         if(audioFrame->vad_activity_ == AudioFrame::kVadActive) {
-            if(!wasMixed) {
+            if(!wasMixed && !muted) {
                 RampIn(*audioFrame);
             }
 
             if(activeList.size() >= *maxAudioFrameCounter) {
                 // There are already more active participants than should be
                 // mixed. Only keep the ones with the highest energy.
                 AudioFrameList::iterator replaceItem;
-                uint32_t lowestEnergy = CalculateEnergy(*audioFrame);
+                uint32_t lowestEnergy =
+                    muted ? 0 : CalculateEnergy(*audioFrame);
 
                 bool found_replace_item = false;
                 for (AudioFrameList::iterator iter = activeList.begin();
                      iter != activeList.end();
                      ++iter) {
-                    const uint32_t energy = CalculateEnergy(*iter->frame);
+                    const uint32_t energy =
+                        muted ? 0 : CalculateEnergy(*iter->frame);
                     if(energy < lowestEnergy) {
                         replaceItem = iter;
                         lowestEnergy = energy;
                         found_replace_item = true;
                     }
                 }
                 if(found_replace_item) {
+                    RTC_DCHECK(!muted);  // Cannot replace with a muted frame.
                     FrameAndMuteInfo replaceFrame = *replaceItem;
 
                     bool replaceWasMixed = false;
                     std::map<int, MixerParticipant*>::const_iterator it =
                         mixParticipantList->find(replaceFrame.frame->id_);
 
                     // When a frame is pushed to |activeList| it is also pushed
                     // to mixParticipantList with the frame's id. This means
                     // that the Find call above should never fail.
                     assert(it != mixParticipantList->end());
                     replaceWasMixed = it->second->_mixHistory->WasMixed();
 
                     mixParticipantList->erase(replaceFrame.frame->id_);
                     activeList.erase(replaceItem);
 
                     activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
                     (*mixParticipantList)[audioFrame->id_] = *participant;
                     assert(mixParticipantList->size() <=
                            kMaximumAmountOfMixedParticipants);
 
                     if (replaceWasMixed) {

[hlundin-webrtc, 2016/05/17 19:29:54]

The formatting is "all over the place" in this file. In the scope of this
if-statement, 2-space indentation is used, so I stuck with that. For the rest of
my changes to this file, 4-space seems to be the rule.

[minyue-webrtc, 2016/05/18 01:34:45]

Acknowledged but it is weird

-                      RampOut(*replaceFrame.frame);
+                      if (!replaceFrame.muted) {
+                        RampOut(*replaceFrame.frame);
+                      }
                       rampOutList->push_back(replaceFrame);
                       assert(rampOutList->size() <=
                              kMaximumAmountOfMixedParticipants);
                     } else {
                       _audioFramePool->PushMemory(replaceFrame.frame);
                     }
                 } else {
                     if(wasMixed) {
-                        RampOut(*audioFrame);
+                        if (!muted) {
+                            RampOut(*audioFrame);
+                        }
                         rampOutList->push_back(FrameAndMuteInfo(audioFrame,
                                                                 muted));
                         assert(rampOutList->size() <=
                                kMaximumAmountOfMixedParticipants);
                     } else {
                         _audioFramePool->PushMemory(audioFrame);
                     }
                 }
             } else {
                 activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
                 (*mixParticipantList)[audioFrame->id_] = *participant;
                 assert(mixParticipantList->size() <=
                        kMaximumAmountOfMixedParticipants);
             }
         } else {
             if(wasMixed) {
                 ParticipantFrameStruct* part_struct =
                     new ParticipantFrameStruct(*participant, audioFrame, muted);
                 passiveWasMixedList.push_back(part_struct);
             } else if(mustAddToPassiveList) {
-                RampIn(*audioFrame);
+                if (!muted) {
+                    RampIn(*audioFrame);
+                }
                 ParticipantFrameStruct* part_struct =
                     new ParticipantFrameStruct(*participant, audioFrame, muted);
                 passiveWasNotMixedList.push_back(part_struct);
             } else {
                 _audioFramePool->PushMemory(audioFrame);
             }
         }
     }
     assert(activeList.size() <= *maxAudioFrameCounter);
     // At this point it is known which participants should be mixed. Transfer
@@ skipping 269 matching lines @@
 
     if(error != _limiter->kNoError) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "Error from AudioProcessing: %d", error);
         assert(false);
         return false;
     }
     return true;
 }
 }  // namespace webrtc