Reduce LS_INFO spam from voice_engine/.

webrtc/voice_engine/channel.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 187 matching lines @@
                  "Channel::InFrameType(frame_type=%d)", frame_type);
 
     CriticalSectionScoped cs(&_callbackCritSect);
     _sendFrameType = (frame_type == kAudioFrameSpeech);
     return 0;
 }
 
 int32_t
 Channel::OnRxVadDetected(int vadDecision)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-                 "Channel::OnRxVadDetected(vadDecision=%d)", vadDecision);
-
     CriticalSectionScoped cs(&_callbackCritSect);
     if (_rxVadObserverPtr)
     {
         _rxVadObserverPtr->OnRxVad(_channelId, vadDecision);
     }
 
     return 0;
 }
 
 int
@@ skipping 197 matching lines @@
   }
   header.payload_type_frequency =
       rtp_payload_registry_->GetPayloadTypeFrequency(header.payloadType);
   if (header.payload_type_frequency < 0)
     return false;
   return ReceivePacket(rtp_packet, rtp_packet_length, header, false);
 }
 
 int32_t Channel::GetAudioFrame(int32_t id, AudioFrame* audioFrame)
 {
-    WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetAudioFrame(id=%d)", id);
-
     if (event_log_) {
       unsigned int ssrc;
       RTC_CHECK_EQ(GetLocalSSRC(ssrc), 0);
       event_log_->LogAudioPlayout(ssrc);
     }
     // Get 10ms raw PCM data from the ACM (mixer limits output frequency)
     if (audio_coding_->PlayoutData10Ms(audioFrame->sample_rate_hz_,
                                        audioFrame) == -1)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice,
@@ skipping 884 matching lines @@
             VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
             "SetVADStatus() failed to set VAD");
         return -1;
     }
     return 0;
 }
 
 int32_t
 Channel::GetVADStatus(bool& enabledVAD, ACMVADMode& mode, bool& disabledDTX)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetVADStatus");
     if (audio_coding_->VAD(&disabledDTX, &enabledVAD, &mode) != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
             "GetVADStatus() failed to get VAD status");
         return -1;
     }
     disabledDTX = !disabledDTX;
     return 0;
 }
@@ skipping 86 matching lines @@
                 "SetRecPayloadType() ACM registration failed - 1");
             return -1;
         }
     }
     return 0;
 }
 
 int32_t
 Channel::GetRecPayloadType(CodecInst& codec)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetRecPayloadType()");
     int8_t payloadType(-1);
     if (rtp_payload_registry_->ReceivePayloadType(
         codec.plname,
         codec.plfreq,
         codec.channels,
         (codec.rate < 0) ? 0 : codec.rate,
         &payloadType) != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
             "GetRecPayloadType() failed to retrieve RX payload type");
         return -1;
     }
     codec.pltype = payloadType;
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetRecPayloadType() => pltype=%d", codec.pltype);
     return 0;
 }
 
 int32_t
 Channel::SetSendCNPayloadType(int type, PayloadFrequencies frequency)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::SetSendCNPayloadType()");
 
     CodecInst codec;
@@ skipping 391 matching lines @@
     return 0;
 }
 
 int Channel::StopPlayingFileLocally()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StopPlayingFileLocally()");
 
     if (!channel_state_.Get().output_file_playing)
     {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_OPERATION, kTraceWarning,
-            "StopPlayingFileLocally() isnot playing");
         return 0;
     }
 
     {
         CriticalSectionScoped cs(&_fileCritSect);
 
         if (_outputFilePlayerPtr->StopPlayingFile() != 0)
         {
             _engineStatisticsPtr->SetLastError(
                 VE_STOP_RECORDING_FAILED, kTraceError,
@@ skipping 15 matching lines @@
             "StopPlayingFile() failed to stop participant from playing as"
             "file in the mixer");
         return -1;
     }
 
     return 0;
 }
 
 int Channel::IsPlayingFileLocally() const
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::IsPlayingFileLocally()");
-
     return channel_state_.Get().output_file_playing;
 }
 
 int Channel::RegisterFilePlayingToMixer()
 {
     // Return success for not registering for file playing to mixer if:
     // 1. playing file before playout is started on that channel.
     // 2. starting playout without file playing on that channel.
     if (!channel_state_.Get().playing ||
         !channel_state_.Get().output_file_playing)
@@ skipping 163 matching lines @@
 
 int Channel::StopPlayingFileAsMicrophone()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StopPlayingFileAsMicrophone()");
 
     CriticalSectionScoped cs(&_fileCritSect);
 
     if (!channel_state_.Get().input_file_playing)
     {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_OPERATION, kTraceWarning,
-            "StopPlayingFileAsMicrophone() isnot playing");
         return 0;
     }
 
     if (_inputFilePlayerPtr->StopPlayingFile() != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_STOP_RECORDING_FAILED, kTraceError,
             "StopPlayingFile() could not stop playing");
         return -1;
     }
     _inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
     FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
     _inputFilePlayerPtr = NULL;
     channel_state_.SetInputFilePlaying(false);
 
     return 0;
 }
 
 int Channel::IsPlayingFileAsMicrophone() const
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::IsPlayingFileAsMicrophone()");
     return channel_state_.Get().input_file_playing;
 }
 
 int Channel::StartRecordingPlayout(const char* fileName,
                                    const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StartRecordingPlayout(fileName=%s)", fileName);
 
     if (_outputFileRecording)
@@ skipping 181 matching lines @@
 {
     CriticalSectionScoped cs(&_fileCritSect);
     _mixFileWithMicrophone=mix;
 }
 
 int
 Channel::GetSpeechOutputLevel(uint32_t& level) const
 {
     int8_t currentLevel = _outputAudioLevel.Level();
     level = static_cast<int32_t> (currentLevel);
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId),
-               "GetSpeechOutputLevel() => level=%u", level);
     return 0;
 }
 
 int
 Channel::GetSpeechOutputLevelFullRange(uint32_t& level) const
 {
     int16_t currentLevel = _outputAudioLevel.LevelFullRange();
     level = static_cast<int32_t> (currentLevel);
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId),
-               "GetSpeechOutputLevelFullRange() => level=%u", level);
     return 0;
 }
 
 int
 Channel::SetMute(bool enable)
 {
     CriticalSectionScoped cs(&volume_settings_critsect_);
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                "Channel::SetMute(enable=%d)", enable);
     _mute = enable;
@@ skipping 17 matching lines @@
     _panRight = right;
     return 0;
 }
 
 int
 Channel::GetOutputVolumePan(float& left, float& right) const
 {
     CriticalSectionScoped cs(&volume_settings_critsect_);
     left = _panLeft;
     right = _panRight;
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId),
-               "GetOutputVolumePan() => left=%3.2f, right=%3.2f", left, right);
     return 0;
 }
 
 int
 Channel::SetChannelOutputVolumeScaling(float scaling)
 {
     CriticalSectionScoped cs(&volume_settings_critsect_);
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                "Channel::SetChannelOutputVolumeScaling()");
     _outputGain = scaling;
     return 0;
 }
 
 int
 Channel::GetChannelOutputVolumeScaling(float& scaling) const
 {
     CriticalSectionScoped cs(&volume_settings_critsect_);
     scaling = _outputGain;
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId),
-               "GetChannelOutputVolumeScaling() => scaling=%3.2f", scaling);
     return 0;
 }
 
 int Channel::SendTelephoneEventOutband(unsigned char eventCode,
                                        int lengthMs, int attenuationDb,
                                        bool playDtmfEvent)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendTelephoneEventOutband(..., playDtmfEvent=%d)",
                playDtmfEvent);
@@ skipping 54 matching lines @@
             return -1;
         }
     }
     _sendTelephoneEventPayloadType = type;
     return 0;
 }
 
 int
 Channel::GetSendTelephoneEventPayloadType(unsigned char& type)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetSendTelephoneEventPayloadType()");
     type = _sendTelephoneEventPayloadType;
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId),
-               "GetSendTelephoneEventPayloadType() => type=%u", type);
     return 0;
 }
 
 int
 Channel::UpdateRxVadDetection(AudioFrame& audioFrame)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::UpdateRxVadDetection()");
 
     int vadDecision = 1;
@@ skipping 47 matching lines @@
     }
     _rxVadObserverPtr = NULL;
     _RxVadDetection = false;
     return 0;
 }
 
 int
 Channel::VoiceActivityIndicator(int &activity)
 {
     activity = _sendFrameType;
-
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::VoiceActivityIndicator(indicator=%d)", activity);
     return 0;
 }
 
 #ifdef WEBRTC_VOICE_ENGINE_AGC
 
 int
 Channel::SetRxAgcStatus(bool enable, AgcModes mode)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::SetRxAgcStatus(enable=%d, mode=%d)",
@@ skipping 37 matching lines @@
 
     _rxAgcIsEnabled = enable;
     channel_state_.SetRxApmIsEnabled(_rxAgcIsEnabled || _rxNsIsEnabled);
 
     return 0;
 }
 
 int
 Channel::GetRxAgcStatus(bool& enabled, AgcModes& mode)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                     "Channel::GetRxAgcStatus(enable=?, mode=?)");
-
     bool enable = rx_audioproc_->gain_control()->is_enabled();
     GainControl::Mode agcMode =
         rx_audioproc_->gain_control()->mode();
 
     enabled = enable;
 
     switch (agcMode)
     {
         case GainControl::kFixedDigital:
             mode = kAgcFixedDigital;
@@ skipping 43 matching lines @@
             "SetRxAgcConfig() failed to set hard limiter to the signal");
         return -1;
     }
 
     return 0;
 }
 
 int
 Channel::GetRxAgcConfig(AgcConfig& config)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetRxAgcConfig(config=%?)");
-
     config.targetLeveldBOv =
         rx_audioproc_->gain_control()->target_level_dbfs();
     config.digitalCompressionGaindB =
         rx_audioproc_->gain_control()->compression_gain_db();
     config.limiterEnable =
         rx_audioproc_->gain_control()->is_limiter_enabled();
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId), "GetRxAgcConfig() => "
-                   "targetLeveldBOv=%u, digitalCompressionGaindB=%u,"
-                   " limiterEnable=%d",
-                   config.targetLeveldBOv,
-                   config.digitalCompressionGaindB,
-                   config.limiterEnable);
-
     return 0;
 }
 
 #endif // #ifdef WEBRTC_VOICE_ENGINE_AGC
 
 #ifdef WEBRTC_VOICE_ENGINE_NR
 
 int
 Channel::SetRxNsStatus(bool enable, NsModes mode)
 {
@@ skipping 45 matching lines @@
 
     _rxNsIsEnabled = enable;
     channel_state_.SetRxApmIsEnabled(_rxAgcIsEnabled || _rxNsIsEnabled);
 
     return 0;
 }
 
 int
 Channel::GetRxNsStatus(bool& enabled, NsModes& mode)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetRxNsStatus(enable=?, mode=?)");
-
     bool enable =
         rx_audioproc_->noise_suppression()->is_enabled();
     NoiseSuppression::Level ncLevel =
         rx_audioproc_->noise_suppression()->level();
 
     enabled = enable;
 
     switch (ncLevel)
     {
         case NoiseSuppression::kLow:
             mode = kNsLowSuppression;
             break;
         case NoiseSuppression::kModerate:
             mode = kNsModerateSuppression;
             break;
         case NoiseSuppression::kHigh:
             mode = kNsHighSuppression;
             break;
         case NoiseSuppression::kVeryHigh:
             mode = kNsVeryHighSuppression;
             break;
     }
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId),
-               "GetRxNsStatus() => enabled=%d, mode=%d", enabled, mode);
     return 0;
 }
 
 #endif // #ifdef WEBRTC_VOICE_ENGINE_NR
 
 int
 Channel::SetLocalSSRC(unsigned int ssrc)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::SetLocalSSRC()");
     if (channel_state_.Get().sending)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_SENDING, kTraceError,
             "SetLocalSSRC() already sending");
         return -1;
     }
     _rtpRtcpModule->SetSSRC(ssrc);
     return 0;
 }
 
 int
 Channel::GetLocalSSRC(unsigned int& ssrc)
 {
     ssrc = _rtpRtcpModule->SSRC();
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId,_channelId),
-                 "GetLocalSSRC() => ssrc=%lu", ssrc);
     return 0;
 }
 
 int
 Channel::GetRemoteSSRC(unsigned int& ssrc)
 {
     ssrc = rtp_receiver_->SSRC();
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId,_channelId),
-                 "GetRemoteSSRC() => ssrc=%lu", ssrc);
     return 0;
 }
 
 int Channel::SetSendAudioLevelIndicationStatus(bool enable, unsigned char id) {
   _includeAudioLevelIndication = enable;
   return SetSendRtpHeaderExtension(enable, kRtpExtensionAudioLevel, id);
 }
 
 int Channel::SetReceiveAudioLevelIndicationStatus(bool enable,
                                                   unsigned char id) {
@@ skipping 24 matching lines @@
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetRTCPStatus()");
   _rtpRtcpModule->SetRTCPStatus(enable ? kRtcpCompound : kRtcpOff);
 }
 
 int
 Channel::GetRTCPStatus(bool& enabled)
 {
     RTCPMethod method = _rtpRtcpModule->RTCP();
     enabled = (method != kRtcpOff);
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId,_channelId),
-                 "GetRTCPStatus() => enabled=%d", enabled);
     return 0;
 }
 
 int
 Channel::SetRTCP_CNAME(const char cName[256])
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::SetRTCP_CNAME()");
     if (_rtpRtcpModule->SetCNAME(cName) != 0)
     {
@@ skipping 18 matching lines @@
     char cname[RTCP_CNAME_SIZE];
     const uint32_t remoteSSRC = rtp_receiver_->SSRC();
     if (_rtpRtcpModule->RemoteCNAME(remoteSSRC, cname) != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_CANNOT_RETRIEVE_CNAME, kTraceError,
             "GetRemoteRTCP_CNAME() failed to retrieve remote RTCP CNAME");
         return -1;
     }
     strcpy(cName, cname);
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId, _channelId),
-                 "GetRemoteRTCP_CNAME() => cName=%s", cName);
     return 0;
 }
 
 int
 Channel::GetRemoteRTCPData(
     unsigned int& NTPHigh,
     unsigned int& NTPLow,
     unsigned int& timestamp,
     unsigned int& playoutTimestamp,
     unsigned int* jitter,
@@ skipping 10 matching lines @@
             "side");
         return -1;
     }
 
     // We only utilize 12 out of 20 bytes in the sender info (ignores packet
     // and octet count)
     NTPHigh = senderInfo.NTPseconds;
     NTPLow = senderInfo.NTPfraction;
     timestamp = senderInfo.RTPtimeStamp;
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId, _channelId),
-                 "GetRemoteRTCPData() => NTPHigh=%lu, NTPLow=%lu, "
-                 "timestamp=%lu",
-                 NTPHigh, NTPLow, timestamp);
-
     // --- Locally derived information
 
     // This value is updated on each incoming RTCP packet (0 when no packet
     // has been received)
     playoutTimestamp = playout_timestamp_rtcp_;
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId, _channelId),
-                 "GetRemoteRTCPData() => playoutTimestamp=%lu",
-                 playout_timestamp_rtcp_);
-
     if (NULL != jitter || NULL != fractionLost)
     {
         // Get all RTCP receiver report blocks that have been received on this
         // channel. If we receive RTP packets from a remote source we know the
         // remote SSRC and use the report block from him.
         // Otherwise use the first report block.
         std::vector<RTCPReportBlock> remote_stats;
         if (_rtpRtcpModule->RemoteRTCPStat(&remote_stats) != 0 ||
             remote_stats.empty()) {
           WEBRTC_TRACE(kTraceWarning, kTraceVoice,
@@ skipping 13 matching lines @@
         if (it == remote_stats.end()) {
           // If we have not received any RTCP packets from this SSRC it probably
           // means that we have not received any RTP packets.
           // Use the first received report block instead.
           it = remote_stats.begin();
           remoteSSRC = it->remoteSSRC;
         }
 
         if (jitter) {
           *jitter = it->jitter;
-          WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                       VoEId(_instanceId, _channelId),
-                       "GetRemoteRTCPData() => jitter = %lu", *jitter);
         }
 
         if (fractionLost) {
           *fractionLost = it->fractionLost;
-          WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                       VoEId(_instanceId, _channelId),
-                       "GetRemoteRTCPData() => fractionLost = %lu",
-                       *fractionLost);
         }
     }
     return 0;
 }
 
 int
 Channel::SendApplicationDefinedRTCPPacket(unsigned char subType,
                                              unsigned int name,
                                              const char* data,
                                              unsigned short dataLengthInBytes)
@@ skipping 69 matching lines @@
     ChannelStatistics stats = statistics_proxy_->GetStats();
     const int32_t playoutFrequency = audio_coding_->PlayoutFrequency();
     if (playoutFrequency > 0) {
       // Scale RTP statistics given the current playout frequency
       maxJitterMs = stats.max_jitter / (playoutFrequency / 1000);
       averageJitterMs = stats.rtcp.jitter / (playoutFrequency / 1000);
     }
 
     discardedPackets = _numberOfDiscardedPackets;
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId, _channelId),
-               "GetRTPStatistics() => averageJitterMs = %lu, maxJitterMs = %lu,"
-               " discardedPackets = %lu)",
-               averageJitterMs, maxJitterMs, discardedPackets);
     return 0;
 }
 
 int Channel::GetRemoteRTCPReportBlocks(
     std::vector<ReportBlock>* report_blocks) {
   if (report_blocks == NULL) {
     _engineStatisticsPtr->SetLastError(VE_INVALID_ARGUMENT, kTraceError,
       "GetRemoteRTCPReportBlock()s invalid report_blocks.");
     return -1;
   }
 
   // Get the report blocks from the latest received RTCP Sender or Receiver
   // Report. Each element in the vector contains the sender's SSRC and a
   // report block according to RFC 3550.
   std::vector<RTCPReportBlock> rtcp_report_blocks;
   if (_rtpRtcpModule->RemoteRTCPStat(&rtcp_report_blocks) != 0) {
-    _engineStatisticsPtr->SetLastError(VE_RTP_RTCP_MODULE_ERROR, kTraceError,
-        "GetRemoteRTCPReportBlocks() failed to read RTCP SR/RR report block.");
     return -1;
   }
 
   if (rtcp_report_blocks.empty())
     return 0;
 
   std::vector<RTCPReportBlock>::const_iterator it = rtcp_report_blocks.begin();
   for (; it != rtcp_report_blocks.end(); ++it) {
     ReportBlock report_block;
     report_block.sender_SSRC = it->remoteSSRC;
@@ skipping 25 matching lines @@
           VE_CANNOT_RETRIEVE_RTP_STAT, kTraceWarning,
           "GetRTPStatistics() failed to read RTP statistics from the "
           "RTP/RTCP module");
     }
 
     stats.fractionLost = statistics.fraction_lost;
     stats.cumulativeLost = statistics.cumulative_lost;
     stats.extendedMax = statistics.extended_max_sequence_number;
     stats.jitterSamples = statistics.jitter;
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId, _channelId),
-                 "GetRTPStatistics() => fractionLost=%lu, cumulativeLost=%lu,"
-                 " extendedMax=%lu, jitterSamples=%li)",
-                 stats.fractionLost, stats.cumulativeLost, stats.extendedMax,
-                 stats.jitterSamples);
-
     // --- RTT
     stats.rttMs = GetRTT(true);
-    if (stats.rttMs == 0) {
-      WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
-                   "GetRTPStatistics() failed to get RTT");
-    } else {
-      WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-                   "GetRTPStatistics() => rttMs=%" PRId64, stats.rttMs);
-    }
 
     // --- Data counters
 
     size_t bytesSent(0);
     uint32_t packetsSent(0);
     size_t bytesReceived(0);
     uint32_t packetsReceived(0);
 
     if (statistician) {
       statistician->GetDataCounters(&bytesReceived, &packetsReceived);
     }
 
     if (_rtpRtcpModule->DataCountersRTP(&bytesSent,
                                         &packetsSent) != 0)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice,
                      VoEId(_instanceId, _channelId),
                      "GetRTPStatistics() failed to retrieve RTP datacounters =>"
                      " output will not be complete");
     }
 
     stats.bytesSent = bytesSent;
     stats.packetsSent = packetsSent;
     stats.bytesReceived = bytesReceived;
     stats.packetsReceived = packetsReceived;
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId, _channelId),
-                 "GetRTPStatistics() => bytesSent=%" PRIuS ", packetsSent=%d,"
-                 " bytesReceived=%" PRIuS ", packetsReceived=%d)",
-                 stats.bytesSent, stats.packetsSent, stats.bytesReceived,
-                 stats.packetsReceived);
-
     // --- Timestamps
     {
       CriticalSectionScoped lock(ts_stats_lock_.get());
       stats.capture_start_ntp_time_ms_ = capture_start_ntp_time_ms_;
     }
     return 0;
 }
 
 int Channel::SetREDStatus(bool enable, int redPayloadtype) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
@@ skipping 33 matching lines @@
         int8_t payloadType(0);
         if (_rtpRtcpModule->SendREDPayloadType(payloadType) != 0)
         {
             _engineStatisticsPtr->SetLastError(
                 VE_RTP_RTCP_MODULE_ERROR, kTraceError,
                 "GetREDStatus() failed to retrieve RED PT from RTP/RTCP "
                 "module");
             return -1;
         }
         redPayloadtype = payloadType;
-        WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                   VoEId(_instanceId, _channelId),
-                   "GetREDStatus() => enabled=%d, redPayloadtype=%d",
-                   enabled, redPayloadtype);
         return 0;
     }
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-                 VoEId(_instanceId, _channelId),
-                 "GetREDStatus() => enabled=%d", enabled);
     return 0;
 }
 
 int Channel::SetCodecFECStatus(bool enable) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetCodecFECStatus()");
 
   if (audio_coding_->SetCodecFEC(enable) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
         "SetCodecFECStatus() failed to set FEC state");
     return -1;
   }
   return 0;
 }
 
 bool Channel::GetCodecFECStatus() {
   bool enabled = audio_coding_->CodecFEC();
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId, _channelId),
-               "GetCodecFECStatus() => enabled=%d", enabled);
   return enabled;
 }
 
 void Channel::SetNACKStatus(bool enable, int maxNumberOfPackets) {
   // None of these functions can fail.
   _rtpRtcpModule->SetStorePacketsStatus(enable, maxNumberOfPackets);
   rtp_receive_statistics_->SetMaxReorderingThreshold(maxNumberOfPackets);
   rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff);
   if (enable)
     audio_coding_->EnableNack(maxNumberOfPackets);
@@ skipping 226 matching lines @@
     }
 
     _externalMixing = enabled;
 
     return 0;
 }
 
 int
 Channel::GetNetworkStatistics(NetworkStatistics& stats)
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetNetworkStatistics()");
     return audio_coding_->GetNetworkStatistics(&stats);
 }
 
 void Channel::GetDecodingCallStatistics(AudioDecodingCallStats* stats) const {
   audio_coding_->GetDecodingCallStatistics(stats);
 }
 
 bool Channel::GetDelayEstimate(int* jitter_buffer_delay_ms,
                                int* playout_buffer_delay_ms) const {
   CriticalSectionScoped cs(video_sync_lock_.get());
   if (_average_jitter_buffer_delay_us == 0) {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetDelayEstimate() no valid estimate.");
     return false;
   }
   *jitter_buffer_delay_ms = (_average_jitter_buffer_delay_us + 500) / 1000 +
       _recPacketDelayMs;
   *playout_buffer_delay_ms = playout_delay_ms_;
-  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-               "Channel::GetDelayEstimate()");
   return true;
 }
 
 int Channel::LeastRequiredDelayMs() const {
   return audio_coding_->LeastRequiredDelayMs();
 }
 
 int Channel::SetInitialPlayoutDelay(int delay_ms)
 {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
@@ skipping 34 matching lines @@
     {
         _engineStatisticsPtr->SetLastError(
             VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
             "SetMinimumPlayoutDelay() failed to set min playout delay");
         return -1;
     }
     return 0;
 }
 
 int Channel::GetPlayoutTimestamp(unsigned int& timestamp) {
-  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-               "Channel::GetPlayoutTimestamp()");
   uint32_t playout_timestamp_rtp = 0;
   {
     CriticalSectionScoped cs(video_sync_lock_.get());
     playout_timestamp_rtp = playout_timestamp_rtp_;
   }
   if (playout_timestamp_rtp == 0)  {
     _engineStatisticsPtr->SetLastError(
         VE_CANNOT_RETRIEVE_VALUE, kTraceError,
         "GetPlayoutTimestamp() failed to retrieve timestamp");
     return -1;
   }
   timestamp = playout_timestamp_rtp;
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
-               VoEId(_instanceId,_channelId),
-               "GetPlayoutTimestamp() => timestamp=%u", timestamp);
   return 0;
 }
 
 int Channel::SetInitTimestamp(unsigned int timestamp) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetInitTimestamp()");
   if (channel_state_.Get().sending) {
     _engineStatisticsPtr->SetLastError(VE_SENDING, kTraceError,
                                        "SetInitTimestamp() already sending");
     return -1;
@@ skipping 10 matching lines @@
         VE_SENDING, kTraceError, "SetInitSequenceNumber() already sending");
     return -1;
   }
   _rtpRtcpModule->SetSequenceNumber(sequenceNumber);
   return 0;
 }
 
 int
 Channel::GetRtpRtcp(RtpRtcp** rtpRtcpModule, RtpReceiver** rtp_receiver) const
 {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetRtpRtcp()");
     *rtpRtcpModule = _rtpRtcpModule.get();
     *rtp_receiver = rtp_receiver_.get();
     return 0;
 }
 
 // TODO(andrew): refactor Mix functions here and in transmit_mixer.cc to use
 // a shared helper.
 int32_t
 Channel::MixOrReplaceAudioWithFile(int mixingFrequency)
 {
@@ skipping 298 matching lines @@
         1000 * timestamp_diff_ms + 500) / 8;
   }
 }
 
 void
 Channel::RegisterReceiveCodecsToRTPModule()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::RegisterReceiveCodecsToRTPModule()");
 
-
     CodecInst codec;
     const uint8_t nSupportedCodecs = AudioCodingModule::NumberOfCodecs();
 
     for (int idx = 0; idx < nSupportedCodecs; idx++)
     {
         // Open up the RTP/RTCP receiver for all supported codecs
         if ((audio_coding_->Codec(idx, &codec) == -1) ||
             (rtp_receiver_->RegisterReceivePayload(
                 codec.plname,
                 codec.pltype,
                 codec.plfreq,
                 codec.channels,
                 (codec.rate < 0) ? 0 : codec.rate) == -1))
         {
-            WEBRTC_TRACE(
-                         kTraceWarning,
+            WEBRTC_TRACE(kTraceWarning,
                          kTraceVoice,
                          VoEId(_instanceId, _channelId),
                          "Channel::RegisterReceiveCodecsToRTPModule() unable"
                          " to register %s (%d/%d/%d/%d) to RTP/RTCP receiver",
                          codec.plname, codec.pltype, codec.plfreq,
                          codec.channels, codec.rate);
         }
         else
         {
-            WEBRTC_TRACE(
-                         kTraceInfo,
+            WEBRTC_TRACE(kTraceInfo,
                          kTraceVoice,
                          VoEId(_instanceId, _channelId),
                          "Channel::RegisterReceiveCodecsToRTPModule() %s "
                          "(%d/%d/%d/%d) has been added to the RTP/RTCP "
                          "receiver",
                          codec.plname, codec.pltype, codec.plfreq,
                          codec.channels, codec.rate);
         }
     }
 }
@@ skipping 112 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt)
       != 0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc