AudioConfMixer: Add muted variable to ParticipantFramePair

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.
  */
 
 #include "webrtc/modules/audio_conference_mixer/include/audio_conference_mixer_defines.h"
 #include "webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h"
 #include "webrtc/modules/audio_conference_mixer/source/audio_frame_manipulator.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 namespace {
 
-struct ParticipantFramePair {
+struct ParticipantFrameStruct {
+  ParticipantFrameStruct(MixerParticipant* p, AudioFrame* a, bool m)
+      : participant(p), audioFrame(a), muted(m) {}
   MixerParticipant* participant;
   AudioFrame* audioFrame;

[minyue-webrtc, 2016/05/17 15:27:30]

I know it is late to ask this, but would it be possible to add muted in
AudioFrame

[hlundin-webrtc, 2016/05/17 18:09:08]

We did consider that. I had discussions with solenberg@, and we concluded that
we did not want to pollute the AudioFrame with anything more; it is already
quite messy. In hindsight, after having integrated the feature into the
conference mixer, I might have changed my position.

+  bool muted;
 };
 
-typedef std::list<ParticipantFramePair*> ParticipantFramePairList;
+typedef std::list<ParticipantFrameStruct*> ParticipantFrameStructList;
 
 // Mix |frame| into |mixed_frame|, with saturation protection and upmixing.
 // These effects are applied to |frame| itself prior to mixing. Assumes that
 // |mixed_frame| always has at least as many channels as |frame|. Supports
 // stereo at most.
 //
 // TODO(andrew): consider not modifying |frame| here.
 void MixFrames(AudioFrame* mixed_frame, AudioFrame* frame, bool use_limiter) {
   assert(mixed_frame->num_channels_ >= frame->num_channels_);
   if (use_limiter) {
@@ skipping 484 matching lines @@
     AudioFrameList* rampOutList,
     std::map<int, MixerParticipant*>* mixParticipantList,
     size_t* maxAudioFrameCounter) const {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "UpdateToMix(mixList,rampOutList,mixParticipantList,%d)",
                  *maxAudioFrameCounter);
     const size_t mixListStartSize = mixList->size();
     AudioFrameList activeList;
     // Struct needed by the passive lists to keep track of which AudioFrame
     // belongs to which MixerParticipant.
-    ParticipantFramePairList passiveWasNotMixedList;
-    ParticipantFramePairList passiveWasMixedList;
+    ParticipantFrameStructList passiveWasNotMixedList;
+    ParticipantFrameStructList passiveWasMixedList;
     for (MixerParticipantList::const_iterator participant =
         _participantList.begin(); participant != _participantList.end();
          ++participant) {
         // Stop keeping track of passive participants if there are already
         // enough participants available (they wont be mixed anyway).
         bool mustAddToPassiveList = (*maxAudioFrameCounter >
                                     (activeList.size() +
                                      passiveWasMixedList.size() +
                                      passiveWasNotMixedList.size()));
 
@@ skipping 90 matching lines @@
                     }
                 }
             } else {
                 activeList.push_front(audioFrame);
                 (*mixParticipantList)[audioFrame->id_] = *participant;
                 assert(mixParticipantList->size() <=
                        kMaximumAmountOfMixedParticipants);
             }
         } else {
             if(wasMixed) {
-                ParticipantFramePair* pair = new ParticipantFramePair;
-                pair->audioFrame  = audioFrame;
-                pair->participant = *participant;
-                passiveWasMixedList.push_back(pair);
+                ParticipantFrameStruct* part_struct =
+                    new ParticipantFrameStruct(*participant, audioFrame, false);
+                passiveWasMixedList.push_back(part_struct);
             } else if(mustAddToPassiveList) {
                 RampIn(*audioFrame);
-                ParticipantFramePair* pair = new ParticipantFramePair;
-                pair->audioFrame  = audioFrame;
-                pair->participant = *participant;
-                passiveWasNotMixedList.push_back(pair);
+                ParticipantFrameStruct* part_struct =
+                    new ParticipantFrameStruct(*participant, audioFrame, false);
+                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
     // this information to this functions output parameters.
     for (AudioFrameList::const_iterator iter = activeList.begin();
          iter != activeList.end();
          ++iter) {
         mixList->push_back(*iter);
     }
     activeList.clear();
     // Always mix a constant number of AudioFrames. If there aren't enough
     // active participants mix passive ones. Starting with those that was mixed
     // last iteration.
-    for (ParticipantFramePairList::const_iterator
+    for (ParticipantFrameStructList::const_iterator
         iter = passiveWasMixedList.begin(); iter != passiveWasMixedList.end();
          ++iter) {
         if(mixList->size() < *maxAudioFrameCounter + mixListStartSize) {
             mixList->push_back((*iter)->audioFrame);
             (*mixParticipantList)[(*iter)->audioFrame->id_] =
                 (*iter)->participant;
             assert(mixParticipantList->size() <=
                    kMaximumAmountOfMixedParticipants);
         } else {
             _audioFramePool->PushMemory((*iter)->audioFrame);
         }
         delete *iter;
     }
     // And finally the ones that have not been mixed for a while.
-    for (ParticipantFramePairList::const_iterator iter =
+    for (ParticipantFrameStructList::const_iterator iter =
              passiveWasNotMixedList.begin();
          iter != passiveWasNotMixedList.end();
          ++iter) {
         if(mixList->size() <  *maxAudioFrameCounter + mixListStartSize) {
           mixList->push_back((*iter)->audioFrame);
             (*mixParticipantList)[(*iter)->audioFrame->id_] =
                 (*iter)->participant;
             assert(mixParticipantList->size() <=
                    kMaximumAmountOfMixedParticipants);
         } else {
@@ skipping 207 matching lines @@
 
     if(error != _limiter->kNoError) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "Error from AudioProcessing: %d", error);
         assert(false);
         return false;
     }
     return true;
 }
 }  // namespace webrtc