Add FrameAndMuteInfo to AudioConferenceMixer

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 40 matching lines @@
 
   *mixed_frame += *frame;
 }
 
 // Return the max number of channels from a |list| composed of AudioFrames.
 size_t MaxNumChannels(const AudioFrameList* list) {
   size_t max_num_channels = 1;
   for (AudioFrameList::const_iterator iter = list->begin();
        iter != list->end();
        ++iter) {
-    max_num_channels = std::max(max_num_channels, (*iter)->num_channels_);
+    max_num_channels = std::max(max_num_channels, (*iter).frame->num_channels_);
   }
   return max_num_channels;
 }
 
 }  // namespace
 
 MixerParticipant::MixerParticipant()
     : _mixHistory(new MixHistory()) {
 }
 
@@ skipping 476 matching lines @@
         wasMixed = (*participant)->_mixHistory->WasMixed();
         AudioFrame* audioFrame = NULL;
         if(_audioFramePool->PopMemory(audioFrame) == -1) {
             WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                          "failed PopMemory() call");
             assert(false);
             return;
         }
         audioFrame->sample_rate_hz_ = _outputFrequency;
 
+        bool muted = false;
         if((*participant)->GetAudioFrame(_id, audioFrame) != 0) {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                          "failed to GetAudioFrame() from participant");
             _audioFramePool->PushMemory(audioFrame);
             continue;
         }
         if (_participantList.size() != 1) {
           // TODO(wu): Issue 3390, add support for multiple participants case.
           audioFrame->ntp_time_ms_ = -1;
         }
@@ skipping 15 matching lines @@
             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);
 
                 bool found_replace_item = false;
                 for (AudioFrameList::iterator iter = activeList.begin();
                      iter != activeList.end();
                      ++iter) {
-                    const uint32_t energy = CalculateEnergy(**iter);
+                    const uint32_t energy = CalculateEnergy(*iter->frame);
                     if(energy < lowestEnergy) {
                         replaceItem = iter;
                         lowestEnergy = energy;
                         found_replace_item = true;
                     }
                 }
                 if(found_replace_item) {
-                    AudioFrame* replaceFrame = *replaceItem;
+                    FrameAndMuteInfo replaceFrame = *replaceItem;
 
                     bool replaceWasMixed = false;
                     std::map<int, MixerParticipant*>::const_iterator it =
-                        mixParticipantList->find(replaceFrame->id_);
+                        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->id_);
+                    mixParticipantList->erase(replaceFrame.frame->id_);
                     activeList.erase(replaceItem);
 
-                    activeList.push_front(audioFrame);
+                    activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
                     (*mixParticipantList)[audioFrame->id_] = *participant;
                     assert(mixParticipantList->size() <=
                            kMaximumAmountOfMixedParticipants);
 
                     if (replaceWasMixed) {
-                      RampOut(*replaceFrame);
+                      RampOut(*replaceFrame.frame);
                       rampOutList->push_back(replaceFrame);
                       assert(rampOutList->size() <=
                              kMaximumAmountOfMixedParticipants);
                     } else {
-                      _audioFramePool->PushMemory(replaceFrame);
+                      _audioFramePool->PushMemory(replaceFrame.frame);
                     }
                 } else {
                     if(wasMixed) {
                         RampOut(*audioFrame);
-                        rampOutList->push_back(audioFrame);
+                        rampOutList->push_back(FrameAndMuteInfo(audioFrame,
+                                                                muted));
                         assert(rampOutList->size() <=
                                kMaximumAmountOfMixedParticipants);
                     } else {
                         _audioFramePool->PushMemory(audioFrame);
                     }
                 }
             } else {
-                activeList.push_front(audioFrame);
+                activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
                 (*mixParticipantList)[audioFrame->id_] = *participant;
                 assert(mixParticipantList->size() <=
                        kMaximumAmountOfMixedParticipants);
             }
         } else {
             if(wasMixed) {
                 ParticipantFrameStruct* part_struct =
-                    new ParticipantFrameStruct(*participant, audioFrame, false);
+                    new ParticipantFrameStruct(*participant, audioFrame, muted);
                 passiveWasMixedList.push_back(part_struct);
             } else if(mustAddToPassiveList) {
                 RampIn(*audioFrame);
                 ParticipantFrameStruct* part_struct =
-                    new ParticipantFrameStruct(*participant, audioFrame, false);
+                    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
     // 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 (ParticipantFrameStructList::const_iterator
         iter = passiveWasMixedList.begin(); iter != passiveWasMixedList.end();
          ++iter) {
         if(mixList->size() < *maxAudioFrameCounter + mixListStartSize) {
-            mixList->push_back((*iter)->audioFrame);
+            mixList->push_back(FrameAndMuteInfo((*iter)->audioFrame,
+                                                (*iter)->muted));
             (*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 (ParticipantFrameStructList::const_iterator iter =
              passiveWasNotMixedList.begin();
          iter != passiveWasNotMixedList.end();
          ++iter) {
         if(mixList->size() <  *maxAudioFrameCounter + mixListStartSize) {
-          mixList->push_back((*iter)->audioFrame);
+          mixList->push_back(FrameAndMuteInfo((*iter)->audioFrame,
+                                              (*iter)->muted));
             (*mixParticipantList)[(*iter)->audioFrame->id_] =
                 (*iter)->participant;
             assert(mixParticipantList->size() <=
                    kMaximumAmountOfMixedParticipants);
         } else {
             _audioFramePool->PushMemory((*iter)->audioFrame);
         }
         delete *iter;
     }
     assert(*maxAudioFrameCounter + mixListStartSize >= mixList->size());
@@ skipping 18 matching lines @@
          participant != additionalParticipantList.end();
          ++participant) {
         AudioFrame* audioFrame = NULL;
         if(_audioFramePool->PopMemory(audioFrame) == -1) {
             WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                          "failed PopMemory() call");
             assert(false);
             return;
         }
         audioFrame->sample_rate_hz_ = _outputFrequency;
+        bool muted = false;
         if((*participant)->GetAudioFrame(_id, audioFrame) != 0) {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                          "failed to GetAudioFrame() from participant");
             _audioFramePool->PushMemory(audioFrame);
             continue;
         }
         if(audioFrame->samples_per_channel_ == 0) {
             // Empty frame. Don't use it.
             _audioFramePool->PushMemory(audioFrame);
             continue;
         }
-        additionalFramesList->push_back(audioFrame);
+        additionalFramesList->push_back(FrameAndMuteInfo(audioFrame, muted));
     }
 }
 
 void AudioConferenceMixerImpl::UpdateMixedStatus(
     const std::map<int, MixerParticipant*>& mixedParticipantsMap) const {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "UpdateMixedStatus(mixedParticipantsMap)");
     assert(mixedParticipantsMap.size() <= kMaximumAmountOfMixedParticipants);
 
     // Loop through all participants. If they are in the mix map they
@@ skipping 16 matching lines @@
     }
 }
 
 void AudioConferenceMixerImpl::ClearAudioFrameList(
     AudioFrameList* audioFrameList) const {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "ClearAudioFrameList(audioFrameList)");
     for (AudioFrameList::iterator iter = audioFrameList->begin();
          iter != audioFrameList->end();
          ++iter) {
-        _audioFramePool->PushMemory(*iter);
+        _audioFramePool->PushMemory(iter->frame);
     }
     audioFrameList->clear();
 }
 
 bool AudioConferenceMixerImpl::IsParticipantInList(
     const MixerParticipant& participant,
     const MixerParticipantList& participantList) const {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "IsParticipantInList(participant,participantList)");
     for (MixerParticipantList::const_iterator iter = participantList.begin();
@@ skipping 38 matching lines @@
 int32_t AudioConferenceMixerImpl::MixFromList(
     AudioFrame* mixedAudio,
     const AudioFrameList& audioFrameList) const {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "MixFromList(mixedAudio, audioFrameList)");
     if(audioFrameList.empty()) return 0;
 
     uint32_t position = 0;
 
     if (_numMixedParticipants == 1) {
-      mixedAudio->timestamp_ = audioFrameList.front()->timestamp_;
-      mixedAudio->elapsed_time_ms_ = audioFrameList.front()->elapsed_time_ms_;
+      mixedAudio->timestamp_ = audioFrameList.front().frame->timestamp_;
+      mixedAudio->elapsed_time_ms_ =
+          audioFrameList.front().frame->elapsed_time_ms_;
     } else {
       // TODO(wu): Issue 3390.
       // Audio frame timestamp is only supported in one channel case.
       mixedAudio->timestamp_ = 0;
       mixedAudio->elapsed_time_ms_ = -1;
     }
 
     for (AudioFrameList::const_iterator iter = audioFrameList.begin();
          iter != audioFrameList.end();
          ++iter) {
         if(position >= kMaximumAmountOfMixedParticipants) {
             WEBRTC_TRACE(
                 kTraceMemory,
                 kTraceAudioMixerServer,
                 _id,
                 "Trying to mix more than max amount of mixed participants:%d!",
                 kMaximumAmountOfMixedParticipants);
             // Assert and avoid crash
             assert(false);
             position = 0;
         }
-        MixFrames(mixedAudio, (*iter), use_limiter_);
+        if (!iter->muted) {
+          MixFrames(mixedAudio, iter->frame, use_limiter_);
+        }
 
         position++;
     }
 
     return 0;
 }
 
 // TODO(andrew): consolidate this function with MixFromList.
 int32_t AudioConferenceMixerImpl::MixAnonomouslyFromList(
     AudioFrame* mixedAudio,
     const AudioFrameList& audioFrameList) const {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "MixAnonomouslyFromList(mixedAudio, audioFrameList)");
 
     if(audioFrameList.empty()) return 0;
 
     for (AudioFrameList::const_iterator iter = audioFrameList.begin();
          iter != audioFrameList.end();
          ++iter) {
-        MixFrames(mixedAudio, *iter, use_limiter_);
+        if (!iter->muted) {
+            MixFrames(mixedAudio, iter->frame, use_limiter_);
+        }
     }
     return 0;
 }
 
 bool AudioConferenceMixerImpl::LimitMixedAudio(AudioFrame* mixedAudio) const {
     if (!use_limiter_) {
       return true;
     }
 
     // Smoothly limit the mixed frame.
@@ skipping 13 matching lines @@
 
     if(error != _limiter->kNoError) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "Error from AudioProcessing: %d", error);
         assert(false);
         return false;
     }
     return true;
 }
 }  // namespace webrtc