Propagate muted info from VoE Channel to AudioConferenceMixer

webrtc/modules/audio_conference_mixer/include/audio_conference_mixer_defines.h

 /*
  *  Copyright (c) 2011 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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_CONFERENCE_MIXER_INCLUDE_AUDIO_CONFERENCE_MIXER_DEFINES_H_
 #define WEBRTC_MODULES_AUDIO_CONFERENCE_MIXER_INCLUDE_AUDIO_CONFERENCE_MIXER_DEFINES_H_
 
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 class MixHistory;
 
 // A callback class that all mixer participants must inherit from/implement.
 class MixerParticipant
 {
 public:
     // The implementation of this function should update audioFrame with new
     // audio every time it's called.
     //
     // If it returns -1, the frame will not be added to the mix.
     virtual int32_t GetAudioFrame(int32_t id,
                                   AudioFrame* audioFrame) = 0;

[kwiberg-webrtc, 2016/05/17 11:00:28]

You need to add a default implementation of this one too. Until you do,
subclasses arent't allowed to stop implementing it.

You could take the implementation that this patch set puts in Channel. Or, even
better if it works, just have an implementation that calls CHECK(false). It
should work, since we assumed there were no out-of-tree callers...

[hlundin-webrtc, 2016/05/17 12:47:34]

Done. I removed the implementation of this one in VoE Channel, since it was only
there to avoid abstract class problems.

 
+    // The implementation of this function should update audio_frame with new
+    // audio every time it's called. The implementation must set the value of
+    // |*muted| to either true or false. If set to true, the audio samples in
+    // audio_frame will not be used; instead, they will be implicitly
+    // interpreted as being all zero.
+    //
+    // If it returns -1, the frame will not be added to the mix.

[kwiberg-webrtc, 2016/05/17 11:00:27]

Mmmmm... maybe take the time to de-stone-age the return value while you're at
it. Such as by having the function return a bool that says whether the frame
should be added to the mix or not. Returning 0 and -1 when it's not even for
error signalling is... inventive.

Or even better, return a

  struct GotAudioFrame { bool muted; bool add_to_mix; };

It'll probably add a line or two to the callers, but it'll be easy to see what's
happening.

[hlundin-webrtc, 2016/05/17 12:47:34]

Per offline discussion, I implemented this as an enum class.

+    virtual int32_t GetAudioFrameWithMuted(int32_t id,
+                                           AudioFrame* audio_frame,
+                                           bool* muted) {
+      *muted = false;
+      return GetAudioFrame(id, audio_frame);
+    }
+
     // Returns true if the participant was mixed this mix iteration.
     bool IsMixed() const;
 
     // This function specifies the sampling frequency needed for the AudioFrame
     // for future GetAudioFrame(..) calls.
     virtual int32_t NeededFrequency(int32_t id) const = 0;
 
     MixHistory* _mixHistory;
 protected:
     MixerParticipant();
@@ skipping 10 matching lines @@
                                const AudioFrame& generalAudioFrame,
                                const AudioFrame** uniqueAudioFrames,
                                const uint32_t size) = 0;
 protected:
     AudioMixerOutputReceiver() {}
     virtual ~AudioMixerOutputReceiver() {}
 };
 }  // namespace webrtc
 
 #endif // WEBRTC_MODULES_AUDIO_CONFERENCE_MIXER_INCLUDE_AUDIO_CONFERENCE_MIXER_DEFINES_H_