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

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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 99 matching lines @@
     const std::map<uint32_t, RtpState>& suspended_ssrcs)
     : transport_adapter_(config.send_transport),
       encoded_frame_proxy_(config.post_encode_callback),
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
       module_process_thread_(module_process_thread),
       channel_group_(channel_group),
       channel_id_(channel_id),
       use_config_bitrate_(true),
       stats_proxy_(Clock::GetRealTimeClock(), config) {
-  DCHECK(!config_.rtp.ssrcs.empty());
-  CHECK(channel_group->CreateSendChannel(channel_id_, 0, &transport_adapter_,
-                                         num_cpu_cores, config_.rtp.ssrcs));
+  RTC_DCHECK(!config_.rtp.ssrcs.empty());
+  RTC_CHECK(channel_group->CreateSendChannel(
+      channel_id_, 0, &transport_adapter_, num_cpu_cores, config_.rtp.ssrcs));
   vie_channel_ = channel_group_->GetChannel(channel_id_);
   vie_encoder_ = channel_group_->GetEncoder(channel_id_);
 
   for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
     const std::string& extension = config_.rtp.extensions[i].name;
     int id = config_.rtp.extensions[i].id;
     // One-byte-extension local identifiers are in the range 1-14 inclusive.
-    DCHECK_GE(id, 1);
-    DCHECK_LE(id, 14);
+    RTC_DCHECK_GE(id, 1);
+    RTC_DCHECK_LE(id, 14);
     if (extension == RtpExtension::kTOffset) {
-      CHECK_EQ(0, vie_channel_->SetSendTimestampOffsetStatus(true, id));
+      RTC_CHECK_EQ(0, vie_channel_->SetSendTimestampOffsetStatus(true, id));
     } else if (extension == RtpExtension::kAbsSendTime) {
-      CHECK_EQ(0, vie_channel_->SetSendAbsoluteSendTimeStatus(true, id));
+      RTC_CHECK_EQ(0, vie_channel_->SetSendAbsoluteSendTimeStatus(true, id));
     } else if (extension == RtpExtension::kVideoRotation) {
-      CHECK_EQ(0, vie_channel_->SetSendVideoRotationStatus(true, id));
+      RTC_CHECK_EQ(0, vie_channel_->SetSendVideoRotationStatus(true, id));
     } else if (extension == RtpExtension::kTransportSequenceNumber) {
-      CHECK_EQ(0, vie_channel_->SetSendTransportSequenceNumber(true, id));
+      RTC_CHECK_EQ(0, vie_channel_->SetSendTransportSequenceNumber(true, id));
     } else {
       RTC_NOTREACHED() << "Registering unsupported RTP extension.";
     }
   }
 
   // TODO(pbos): Consider configuring REMB in Call.
   channel_group_->SetChannelRembStatus(true, false, vie_channel_);
 
   // Enable NACK, FEC or both.
   const bool enable_protection_nack = config_.rtp.nack.rtp_history_ms > 0;
   const bool enable_protection_fec = config_.rtp.fec.red_payload_type != -1;
   // TODO(changbin): Should set RTX for RED mapping in RTP sender in future.
   vie_channel_->SetProtectionMode(enable_protection_nack, enable_protection_fec,
                                   config_.rtp.fec.red_payload_type,
                                   config_.rtp.fec.ulpfec_payload_type);
   vie_encoder_->UpdateProtectionMethod(enable_protection_nack,
                                        enable_protection_fec);
 
   ConfigureSsrcs();
 
   vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str());
 
   input_.reset(new internal::VideoCaptureInput(
       module_process_thread_, vie_encoder_, config_.local_renderer,
       &stats_proxy_, this));
 
   // 28 to match packet overhead in ModuleRtpRtcpImpl.
-  DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28));
+  RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28));
   vie_channel_->SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
 
-  DCHECK(config.encoder_settings.encoder != nullptr);
-  DCHECK_GE(config.encoder_settings.payload_type, 0);
-  DCHECK_LE(config.encoder_settings.payload_type, 127);
-  CHECK_EQ(0, vie_encoder_->RegisterExternalEncoder(
-                  config.encoder_settings.encoder,
-                  config.encoder_settings.payload_type,
-                  config.encoder_settings.internal_source));
+  RTC_DCHECK(config.encoder_settings.encoder != nullptr);
+  RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
+  RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
+  RTC_CHECK_EQ(0, vie_encoder_->RegisterExternalEncoder(
+                      config.encoder_settings.encoder,
+                      config.encoder_settings.payload_type,
+                      config.encoder_settings.internal_source));
 
-  CHECK(ReconfigureVideoEncoder(encoder_config));
+  RTC_CHECK(ReconfigureVideoEncoder(encoder_config));
 
   vie_channel_->RegisterSendSideDelayObserver(&stats_proxy_);
   vie_encoder_->RegisterSendStatisticsProxy(&stats_proxy_);
 
   vie_encoder_->RegisterPreEncodeCallback(config_.pre_encode_callback);
   if (config_.post_encode_callback)
     vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
 
   if (config_.suspend_below_min_bitrate) {
     vie_encoder_->SuspendBelowMinBitrate();
@@ skipping 55 matching lines @@
   vie_channel_->StopSend();
   vie_channel_->StopReceive();
   transport_adapter_.Disable();
 }
 
 bool VideoSendStream::ReconfigureVideoEncoder(
     const VideoEncoderConfig& config) {
   TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder");
   LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString();
   const std::vector<VideoStream>& streams = config.streams;
-  DCHECK(!streams.empty());
-  DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
+  RTC_DCHECK(!streams.empty());
+  RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
   if (config_.encoder_settings.payload_name == "VP8") {
     video_codec.codecType = kVideoCodecVP8;
   } else if (config_.encoder_settings.payload_name == "VP9") {
     video_codec.codecType = kVideoCodecVP9;
   } else if (config_.encoder_settings.payload_name == "H264") {
     video_codec.codecType = kVideoCodecH264;
   } else {
@@ skipping 38 matching lines @@
     video_codec.codecSpecific.VP9.numberOfTemporalLayers =
         static_cast<unsigned char>(
             streams.back().temporal_layer_thresholds_bps.size() + 1);
   } else if (video_codec.codecType == kVideoCodecH264) {
     if (config.encoder_specific_settings != nullptr) {
       video_codec.codecSpecific.H264 = *reinterpret_cast<const VideoCodecH264*>(
                                            config.encoder_specific_settings);
     }
   } else {
     // TODO(pbos): Support encoder_settings codec-agnostically.
-    DCHECK(config.encoder_specific_settings == nullptr)
+    RTC_DCHECK(config.encoder_specific_settings == nullptr)
         << "Encoder-specific settings for codec type not wired up.";
   }
 
   strncpy(video_codec.plName,
           config_.encoder_settings.payload_name.c_str(),
           kPayloadNameSize - 1);
   video_codec.plName[kPayloadNameSize - 1] = '\0';
   video_codec.plType = config_.encoder_settings.payload_type;
   video_codec.numberOfSimulcastStreams =
       static_cast<unsigned char>(streams.size());
   video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;
-  DCHECK_LE(streams.size(), static_cast<size_t>(kMaxSimulcastStreams));
+  RTC_DCHECK_LE(streams.size(), static_cast<size_t>(kMaxSimulcastStreams));
   for (size_t i = 0; i < streams.size(); ++i) {
     SimulcastStream* sim_stream = &video_codec.simulcastStream[i];
-    DCHECK_GT(streams[i].width, 0u);
-    DCHECK_GT(streams[i].height, 0u);
-    DCHECK_GT(streams[i].max_framerate, 0);
+    RTC_DCHECK_GT(streams[i].width, 0u);
+    RTC_DCHECK_GT(streams[i].height, 0u);
+    RTC_DCHECK_GT(streams[i].max_framerate, 0);
     // Different framerates not supported per stream at the moment.
-    DCHECK_EQ(streams[i].max_framerate, streams[0].max_framerate);
-    DCHECK_GE(streams[i].min_bitrate_bps, 0);
-    DCHECK_GE(streams[i].target_bitrate_bps, streams[i].min_bitrate_bps);
-    DCHECK_GE(streams[i].max_bitrate_bps, streams[i].target_bitrate_bps);
-    DCHECK_GE(streams[i].max_qp, 0);
+    RTC_DCHECK_EQ(streams[i].max_framerate, streams[0].max_framerate);
+    RTC_DCHECK_GE(streams[i].min_bitrate_bps, 0);
+    RTC_DCHECK_GE(streams[i].target_bitrate_bps, streams[i].min_bitrate_bps);
+    RTC_DCHECK_GE(streams[i].max_bitrate_bps, streams[i].target_bitrate_bps);
+    RTC_DCHECK_GE(streams[i].max_qp, 0);
 
     sim_stream->width = static_cast<unsigned short>(streams[i].width);
     sim_stream->height = static_cast<unsigned short>(streams[i].height);
     sim_stream->minBitrate = streams[i].min_bitrate_bps / 1000;
     sim_stream->targetBitrate = streams[i].target_bitrate_bps / 1000;
     sim_stream->maxBitrate = streams[i].max_bitrate_bps / 1000;
     sim_stream->qpMax = streams[i].max_qp;
     sim_stream->numberOfTemporalLayers = static_cast<unsigned char>(
         streams[i].temporal_layer_thresholds_bps.size() + 1);
 
     video_codec.width = std::max(video_codec.width,
                                  static_cast<unsigned short>(streams[i].width));
     video_codec.height = std::max(
         video_codec.height, static_cast<unsigned short>(streams[i].height));
     video_codec.minBitrate =
         std::min(video_codec.minBitrate,
                  static_cast<unsigned int>(streams[i].min_bitrate_bps / 1000));
     video_codec.maxBitrate += streams[i].max_bitrate_bps / 1000;
     video_codec.qpMax = std::max(video_codec.qpMax,
                                  static_cast<unsigned int>(streams[i].max_qp));
   }
 
   // Set to zero to not update the bitrate controller from ViEEncoder, as
   // the bitrate controller is already set from Call.
   video_codec.startBitrate = 0;
 
-  DCHECK_GT(streams[0].max_framerate, 0);
+  RTC_DCHECK_GT(streams[0].max_framerate, 0);
   video_codec.maxFramerate = streams[0].max_framerate;
 
   if (!SetSendCodec(video_codec))
     return false;
 
   // Clear stats for disabled layers.
   for (size_t i = video_codec.numberOfSimulcastStreams;
        i < config_.rtp.ssrcs.size(); ++i) {
     stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
   }
 
-  DCHECK_GE(config.min_transmit_bitrate_bps, 0);
+  RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
   vie_encoder_->SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000);
 
   encoder_config_ = config;
   use_config_bitrate_ = false;
   return true;
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   return vie_channel_->ReceivedRTCPPacket(packet, length) == 0;
 }
@@ skipping 21 matching lines @@
     RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc);
     if (it != suspended_ssrcs_.end())
       vie_channel_->SetRtpStateForSsrc(ssrc, it->second);
   }
 
   if (config_.rtp.rtx.ssrcs.empty()) {
     return;
   }
 
   // Set up RTX.
-  DCHECK_EQ(config_.rtp.rtx.ssrcs.size(), config_.rtp.ssrcs.size());
+  RTC_DCHECK_EQ(config_.rtp.rtx.ssrcs.size(), config_.rtp.ssrcs.size());
   for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.rtx.ssrcs[i];
     vie_channel_->SetSSRC(config_.rtp.rtx.ssrcs[i], kViEStreamTypeRtx,
                           static_cast<unsigned char>(i));
     RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc);
     if (it != suspended_ssrcs_.end())
       vie_channel_->SetRtpStateForSsrc(ssrc, it->second);
   }
 
-  DCHECK_GE(config_.rtp.rtx.payload_type, 0);
+  RTC_DCHECK_GE(config_.rtp.rtx.payload_type, 0);
   vie_channel_->SetRtxSendPayloadType(config_.rtp.rtx.payload_type,
                                       config_.encoder_settings.payload_type);
 }
 
 std::map<uint32_t, RtpState> VideoSendStream::GetRtpStates() const {
   std::map<uint32_t, RtpState> rtp_states;
   for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.ssrcs[i];
     rtp_states[ssrc] = vie_channel_->GetRtpStateForSsrc( ssrc);
   }
@@ skipping 71 matching lines @@
                                        vie_channel_->IsSendingFecEnabled());
 
   // Restart the media flow
   vie_encoder_->Restart();
 
   return true;
 }
 
 }  // namespace internal
 }  // namespace webrtc