Avoid clicks when muting/unmuting a voe::Channel.

webrtc/voice_engine/channel.h

 /*
  *  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 251 matching lines @@
 
   // VoEExternalMediaProcessing
   int RegisterExternalMediaProcessing(ProcessingTypes type,
                                       VoEMediaProcess& processObject);
   int DeRegisterExternalMediaProcessing(ProcessingTypes type);
   int SetExternalMixing(bool enabled);
 
   // VoEVolumeControl
   int GetSpeechOutputLevel(uint32_t& level) const;
   int GetSpeechOutputLevelFullRange(uint32_t& level) const;
-  int SetMute(bool enable);
-  bool Mute() const;
+  int SetInputMute(bool enable);

[peah-webrtc, 2016/03/23 15:57:04]

What is motivates the name change to InputMute? Can there be an OutputMute? I
think that it should be fine to continue naming it Mute. To me this name-change
makes the purpose of the function less intuitive. A channel should only be muted
or not muted, I would not be able to tell how an InputMuted channel behaves.

[the sun, 2016/03/23 21:30:53]

The voe::Channel is duplex. SetMute() could mean to mute either the input or the
output. The functions on the VoEVolumeControl interface (to which this class is
tightly tied) calling these functions are called SetInputMute() and
GetInputMute().

[peah-webrtc, 2016/03/24 07:04:54]

Yes, I saw the other InputMute function but this change, or naming does not make
sense to me, in particular since there is no OutputMute. Most likely it is
because I don't yet know the voe code but could you please explain what the
difference between an input and output mute would be. And also, as the
voe::Channel is duplex, how you determine which is the input and which is the
output.

[the sun, 2016/03/24 09:33:15]

Input mute = mute the microphone
Output mute = mute the speaker

The reason I changed it was that I needed to look through the code to make sure
"mute" was only used for muting the input. Why would there be the distinction
between "input mute" in VoEVolume, and just "mute" in voe::Channel? I figure it
makes sense to be consistent.
The voe::Channel can be an input, and output or both at the same time. There's
no determining. Yes, we want to get rid of this behavior.

+  bool InputMute() const;
   int SetOutputVolumePan(float left, float right);
   int GetOutputVolumePan(float& left, float& right) const;
   int SetChannelOutputVolumeScaling(float scaling);
   int GetChannelOutputVolumeScaling(float& scaling) const;
 
   // VoENetEqStats
   int GetNetworkStatistics(NetworkStatistics& stats);
   void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const;
 
   // VoEVideoSync
@@ skipping 245 matching lines @@
   Transport* _transportPtr;  // WebRtc socket or external transport
   RMSLevel rms_level_;
   std::unique_ptr<AudioProcessing> rx_audioproc_;  // far end AudioProcessing
   VoERxVadCallback* _rxVadObserverPtr;
   int32_t _oldVadDecision;
   int32_t _sendFrameType;  // Send data is voice, 1-voice, 0-otherwise
   // VoEBase
   bool _externalMixing;
   bool _mixFileWithMicrophone;
   // VoEVolumeControl
-  bool _mute;
-  float _panLeft;
-  float _panRight;
-  float _outputGain;
+  bool input_mute_ GUARDED_BY(volume_settings_critsect_);
+  bool cached_input_mute_;  // Only accessed from PrepareEncodeAndSend().
+  float _panLeft GUARDED_BY(volume_settings_critsect_);
+  float _panRight GUARDED_BY(volume_settings_critsect_);
+  float _outputGain GUARDED_BY(volume_settings_critsect_);
   // VoeRTP_RTCP
   uint32_t _lastLocalTimeStamp;
   int8_t _lastPayloadType;
   bool _includeAudioLevelIndication;
   // VoENetwork
   AudioFrame::SpeechType _outputSpeechType;
   // VoEVideoSync
   rtc::CriticalSection video_sync_lock_;
   uint32_t _average_jitter_buffer_delay_us GUARDED_BY(video_sync_lock_);
   uint32_t _previousTimestamp;
@@ skipping 14 matching lines @@
   PacketRouter* packet_router_ = nullptr;
   std::unique_ptr<TransportFeedbackProxy> feedback_observer_proxy_;
   std::unique_ptr<TransportSequenceNumberProxy> seq_num_allocator_proxy_;
   std::unique_ptr<RtpPacketSenderProxy> rtp_packet_sender_proxy_;
 };
 
 }  // namespace voe
 }  // namespace webrtc
 
 #endif  // WEBRTC_VOICE_ENGINE_CHANNEL_H_