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

webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc

 /*
  *  Copyright (c) 2015 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 17 matching lines @@
 inline CFDictionaryRef CreateCFDictionary(CFTypeRef* keys,
                                           CFTypeRef* values,
                                           size_t size) {
   return CFDictionaryCreate(kCFAllocatorDefault, keys, values, size,
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 // Copies characters from a CFStringRef into a std::string.
 std::string CFStringToString(const CFStringRef cf_string) {
-  DCHECK(cf_string);
+  RTC_DCHECK(cf_string);
   std::string std_string;
   // Get the size needed for UTF8 plus terminating character.
   size_t buffer_size =
       CFStringGetMaximumSizeForEncoding(CFStringGetLength(cf_string),
                                         kCFStringEncodingUTF8) +
       1;
   rtc::scoped_ptr<char[]> buffer(new char[buffer_size]);
   if (CFStringGetCString(cf_string, buffer.get(), buffer_size,
                          kCFStringEncodingUTF8)) {
     // Copy over the characters.
@@ skipping 67 matching lines @@
   int32_t height;
   int64_t render_time_ms;
   uint32_t timestamp;
 };
 
 // We receive I420Frames as input, but we need to feed CVPixelBuffers into the
 // encoder. This performs the copy and format conversion.
 // TODO(tkchin): See if encoder will accept i420 frames and compare performance.
 bool CopyVideoFrameToPixelBuffer(const webrtc::VideoFrame& frame,
                                  CVPixelBufferRef pixel_buffer) {
-  DCHECK(pixel_buffer);
-  DCHECK(CVPixelBufferGetPixelFormatType(pixel_buffer) ==
-         kCVPixelFormatType_420YpCbCr8BiPlanarFullRange);
-  DCHECK(CVPixelBufferGetHeightOfPlane(pixel_buffer, 0) ==
-         static_cast<size_t>(frame.height()));
-  DCHECK(CVPixelBufferGetWidthOfPlane(pixel_buffer, 0) ==
-         static_cast<size_t>(frame.width()));
+  RTC_DCHECK(pixel_buffer);
+  RTC_DCHECK(CVPixelBufferGetPixelFormatType(pixel_buffer) ==
+             kCVPixelFormatType_420YpCbCr8BiPlanarFullRange);
+  RTC_DCHECK(CVPixelBufferGetHeightOfPlane(pixel_buffer, 0) ==
+             static_cast<size_t>(frame.height()));
+  RTC_DCHECK(CVPixelBufferGetWidthOfPlane(pixel_buffer, 0) ==
+             static_cast<size_t>(frame.width()));
 
   CVReturn cvRet = CVPixelBufferLockBaseAddress(pixel_buffer, 0);
   if (cvRet != kCVReturnSuccess) {
     LOG(LS_ERROR) << "Failed to lock base address: " << cvRet;
     return false;
   }
   uint8* dst_y = reinterpret_cast<uint8*>(
       CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 0));
   int dst_stride_y = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 0);
   uint8* dst_uv = reinterpret_cast<uint8*>(
@@ skipping 74 matching lines @@
     : callback_(nullptr), compression_session_(nullptr) {
 }
 
 H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
   DestroyCompressionSession();
 }
 
 int H264VideoToolboxEncoder::InitEncode(const VideoCodec* codec_settings,
                                         int number_of_cores,
                                         size_t max_payload_size) {
-  DCHECK(codec_settings);
-  DCHECK_EQ(codec_settings->codecType, kVideoCodecH264);
+  RTC_DCHECK(codec_settings);
+  RTC_DCHECK_EQ(codec_settings->codecType, kVideoCodecH264);
   // TODO(tkchin): We may need to enforce width/height dimension restrictions
   // to match what the encoder supports.
   width_ = codec_settings->width;
   height_ = codec_settings->height;
   // We can only set average bitrate on the HW encoder.
   bitrate_ = codec_settings->startBitrate * 1000;
 
   // TODO(tkchin): Try setting payload size via
   // kVTCompressionPropertyKey_MaxH264SliceBytes.
 
@@ skipping 20 matching lines @@
       VTCompressionSessionGetPixelBufferPool(compression_session_);
   CVPixelBufferRef pixel_buffer = nullptr;
   CVReturn ret = CVPixelBufferPoolCreatePixelBuffer(nullptr, pixel_buffer_pool,
                                                     &pixel_buffer);
   if (ret != kCVReturnSuccess) {
     LOG(LS_ERROR) << "Failed to create pixel buffer: " << ret;
     // We probably want to drop frames here, since failure probably means
     // that the pool is empty.
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
-  DCHECK(pixel_buffer);
+  RTC_DCHECK(pixel_buffer);
   if (!internal::CopyVideoFrameToPixelBuffer(input_image, pixel_buffer)) {
     LOG(LS_ERROR) << "Failed to copy frame data.";
     CVBufferRelease(pixel_buffer);
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   // Check if we need a keyframe.
   bool is_keyframe_required = false;
   if (frame_types) {
     for (auto frame_type : *frame_types) {
@@ skipping 110 matching lines @@
   }
   if (status != noErr) {
     LOG(LS_ERROR) << "Failed to create compression session: " << status;
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   ConfigureCompressionSession();
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void H264VideoToolboxEncoder::ConfigureCompressionSession() {
-  DCHECK(compression_session_);
+  RTC_DCHECK(compression_session_);
   internal::SetVTSessionProperty(compression_session_,
                                  kVTCompressionPropertyKey_RealTime, true);
   internal::SetVTSessionProperty(compression_session_,
                                  kVTCompressionPropertyKey_ProfileLevel,
                                  kVTProfileLevel_H264_Baseline_AutoLevel);
   internal::SetVTSessionProperty(
       compression_session_, kVTCompressionPropertyKey_AverageBitRate, bitrate_);
   internal::SetVTSessionProperty(compression_session_,
                                  kVTCompressionPropertyKey_AllowFrameReordering,
                                  false);
@@ skipping 18 matching lines @@
   if (compression_session_) {
     VTCompressionSessionInvalidate(compression_session_);
     CFRelease(compression_session_);
     compression_session_ = nullptr;
   }
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)