Add RTC_ prefix to (D)CHECKs and related macros.

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc

 /*
  *  Copyright (c) 2014 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 23 matching lines @@
   return config;
 }
 
 // Optimize the loss rate to configure Opus. Basically, optimized loss rate is
 // the input loss rate rounded down to various levels, because a robustly good
 // audio quality is achieved by lowering the packet loss down.
 // Additionally, to prevent toggling, margins are used, i.e., when jumping to
 // a loss rate from below, a higher threshold is used than jumping to the same
 // level from above.
 double OptimizePacketLossRate(double new_loss_rate, double old_loss_rate) {
-  DCHECK_GE(new_loss_rate, 0.0);
-  DCHECK_LE(new_loss_rate, 1.0);
-  DCHECK_GE(old_loss_rate, 0.0);
-  DCHECK_LE(old_loss_rate, 1.0);
+  RTC_DCHECK_GE(new_loss_rate, 0.0);
+  RTC_DCHECK_LE(new_loss_rate, 1.0);
+  RTC_DCHECK_GE(old_loss_rate, 0.0);
+  RTC_DCHECK_LE(old_loss_rate, 1.0);
   const double kPacketLossRate20 = 0.20;
   const double kPacketLossRate10 = 0.10;
   const double kPacketLossRate5 = 0.05;
   const double kPacketLossRate1 = 0.01;
   const double kLossRate20Margin = 0.02;
   const double kLossRate10Margin = 0.01;
   const double kLossRate5Margin = 0.01;
   if (new_loss_rate >=
       kPacketLossRate20 +
           kLossRate20Margin *
@@ skipping 25 matching lines @@
     return false;
   if (bitrate_bps < kMinBitrateBps || bitrate_bps > kMaxBitrateBps)
     return false;
   if (complexity < 0 || complexity > 10)
     return false;
   return true;
 }
 
 AudioEncoderOpus::AudioEncoderOpus(const Config& config)
     : packet_loss_rate_(0.0), inst_(nullptr) {
-  CHECK(RecreateEncoderInstance(config));
+  RTC_CHECK(RecreateEncoderInstance(config));
 }
 
 AudioEncoderOpus::AudioEncoderOpus(const CodecInst& codec_inst)
     : AudioEncoderOpus(CreateConfig(codec_inst)) {}
 
 AudioEncoderOpus::~AudioEncoderOpus() {
-  CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
+  RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
 }
 
 size_t AudioEncoderOpus::MaxEncodedBytes() const {
   // Calculate the number of bytes we expect the encoder to produce,
   // then multiply by two to give a wide margin for error.
   const size_t bytes_per_millisecond =
       static_cast<size_t>(config_.bitrate_bps / (1000 * 8) + 1);
   const size_t approx_encoded_bytes =
       Num10msFramesPerPacket() * 10 * bytes_per_millisecond;
   return 2 * approx_encoded_bytes;
@@ skipping 25 matching lines @@
     size_t max_encoded_bytes,
     uint8_t* encoded) {
   if (input_buffer_.empty())
     first_timestamp_in_buffer_ = rtp_timestamp;
   input_buffer_.insert(input_buffer_.end(), audio,
                        audio + SamplesPer10msFrame());
   if (input_buffer_.size() <
       (static_cast<size_t>(Num10msFramesPerPacket()) * SamplesPer10msFrame())) {
     return EncodedInfo();
   }
-  CHECK_EQ(input_buffer_.size(), static_cast<size_t>(Num10msFramesPerPacket()) *
-                                     SamplesPer10msFrame());
+  RTC_CHECK_EQ(
+      input_buffer_.size(),
+      static_cast<size_t>(Num10msFramesPerPacket()) * SamplesPer10msFrame());
   int status = WebRtcOpus_Encode(
       inst_, &input_buffer_[0],
       rtc::CheckedDivExact(input_buffer_.size(),
                            static_cast<size_t>(config_.num_channels)),
       rtc::saturated_cast<int16_t>(max_encoded_bytes), encoded);
-  CHECK_GE(status, 0);  // Fails only if fed invalid data.
+  RTC_CHECK_GE(status, 0);  // Fails only if fed invalid data.
   input_buffer_.clear();
   EncodedInfo info;
   info.encoded_bytes = static_cast<size_t>(status);
   info.encoded_timestamp = first_timestamp_in_buffer_;
   info.payload_type = config_.payload_type;
   info.send_even_if_empty = true;  // Allows Opus to send empty packets.
   info.speech = (status > 0);
   return info;
 }
 
 void AudioEncoderOpus::Reset() {
-  CHECK(RecreateEncoderInstance(config_));
+  RTC_CHECK(RecreateEncoderInstance(config_));
 }
 
 bool AudioEncoderOpus::SetFec(bool enable) {
   auto conf = config_;
   conf.fec_enabled = enable;
   return RecreateEncoderInstance(conf);
 }
 
 bool AudioEncoderOpus::SetDtx(bool enable) {
   auto conf = config_;
@@ skipping 10 matching lines @@
     case Application::kAudio:
       conf.application = AudioEncoderOpus::kAudio;
       break;
   }
   return RecreateEncoderInstance(conf);
 }
 
 void AudioEncoderOpus::SetMaxPlaybackRate(int frequency_hz) {
   auto conf = config_;
   conf.max_playback_rate_hz = frequency_hz;
-  CHECK(RecreateEncoderInstance(conf));
+  RTC_CHECK(RecreateEncoderInstance(conf));
 }
 
 void AudioEncoderOpus::SetProjectedPacketLossRate(double fraction) {
   double opt_loss_rate = OptimizePacketLossRate(fraction, packet_loss_rate_);
   if (packet_loss_rate_ != opt_loss_rate) {
     packet_loss_rate_ = opt_loss_rate;
-    CHECK_EQ(0, WebRtcOpus_SetPacketLossRate(
-                    inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
+    RTC_CHECK_EQ(
+        0, WebRtcOpus_SetPacketLossRate(
+               inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
   }
 }
 
 void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
   config_.bitrate_bps =
       std::max(std::min(bits_per_second, kMaxBitrateBps), kMinBitrateBps);
-  DCHECK(config_.IsOk());
-  CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.bitrate_bps));
+  RTC_DCHECK(config_.IsOk());
+  RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.bitrate_bps));
 }
 
 int AudioEncoderOpus::Num10msFramesPerPacket() const {
   return rtc::CheckedDivExact(config_.frame_size_ms, 10);
 }
 
 int AudioEncoderOpus::SamplesPer10msFrame() const {
   return rtc::CheckedDivExact(kSampleRateHz, 100) * config_.num_channels;
 }
 
 // If the given config is OK, recreate the Opus encoder instance with those
 // settings, save the config, and return true. Otherwise, do nothing and return
 // false.
 bool AudioEncoderOpus::RecreateEncoderInstance(const Config& config) {
   if (!config.IsOk())
     return false;
   if (inst_)
-    CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
+    RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
   input_buffer_.clear();
   input_buffer_.reserve(Num10msFramesPerPacket() * SamplesPer10msFrame());
-  CHECK_EQ(0, WebRtcOpus_EncoderCreate(&inst_, config.num_channels,
-                                       config.application));
-  CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config.bitrate_bps));
+  RTC_CHECK_EQ(0, WebRtcOpus_EncoderCreate(&inst_, config.num_channels,
+                                           config.application));
+  RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config.bitrate_bps));
   if (config.fec_enabled) {
-    CHECK_EQ(0, WebRtcOpus_EnableFec(inst_));
+    RTC_CHECK_EQ(0, WebRtcOpus_EnableFec(inst_));
   } else {
-    CHECK_EQ(0, WebRtcOpus_DisableFec(inst_));
+    RTC_CHECK_EQ(0, WebRtcOpus_DisableFec(inst_));
   }
-  CHECK_EQ(0,
-           WebRtcOpus_SetMaxPlaybackRate(inst_, config.max_playback_rate_hz));
-  CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, config.complexity));
+  RTC_CHECK_EQ(
+      0, WebRtcOpus_SetMaxPlaybackRate(inst_, config.max_playback_rate_hz));
+  RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, config.complexity));
   if (config.dtx_enabled) {
-    CHECK_EQ(0, WebRtcOpus_EnableDtx(inst_));
+    RTC_CHECK_EQ(0, WebRtcOpus_EnableDtx(inst_));
   } else {
-    CHECK_EQ(0, WebRtcOpus_DisableDtx(inst_));
+    RTC_CHECK_EQ(0, WebRtcOpus_DisableDtx(inst_));
   }
-  CHECK_EQ(0, WebRtcOpus_SetPacketLossRate(
-                  inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
+  RTC_CHECK_EQ(0,
+               WebRtcOpus_SetPacketLossRate(
+                   inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
   config_ = config;
   return true;
 }
 
 }  // namespace webrtc