Use suffixed {uint,int}{8,16,32,64}_t types.

talk/media/base/videocapturer.cc

 /*
  * libjingle
  * Copyright 2010 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 40 matching lines @@
 // user. When all frontends to this consider removing the black frame business.
 const int kNumBlackFramesOnMute = 30;
 
 // MessageHandler constants.
 enum {
   MSG_DO_PAUSE = 0,
   MSG_DO_UNPAUSE,
   MSG_STATE_CHANGE
 };
 
-static const int64 kMaxDistance = ~(static_cast<int64>(1) << 63);
+static const int64_t kMaxDistance = ~(static_cast<int64_t>(1) << 63);
 #ifdef LINUX
 static const int kYU12Penalty = 16;  // Needs to be higher than MJPG index.
 #endif
 static const int kDefaultScreencastFps = 5;
 typedef rtc::TypedMessageData<CaptureState> StateChangeParams;
 
 // Limit stats data collections to ~20 seconds of 30fps data before dropping
 // old data in case stats aren't reset for long periods of time.
 static const size_t kMaxAccumulatorSize = 600;
 
 }  // namespace
 
 /////////////////////////////////////////////////////////////////////
 // Implementation of struct CapturedFrame
 /////////////////////////////////////////////////////////////////////
 CapturedFrame::CapturedFrame()
     : width(0),
       height(0),
       fourcc(0),
       pixel_width(0),
       pixel_height(0),
       time_stamp(0),
       data_size(0),
       rotation(0),
       data(NULL) {}
 
 // TODO(fbarchard): Remove this function once lmimediaengine stops using it.
-bool CapturedFrame::GetDataSize(uint32* size) const {
+bool CapturedFrame::GetDataSize(uint32_t* size) const {
   if (!size || data_size == CapturedFrame::kUnknownDataSize) {
     return false;
   }
   *size = data_size;
   return true;
 }
 
 webrtc::VideoRotation CapturedFrame::GetRotation() const {
   ASSERT(rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270);
   return static_cast<webrtc::VideoRotation>(rotation);
@@ skipping 168 matching lines @@
 bool VideoCapturer::GetBestCaptureFormat(const VideoFormat& format,
                                          VideoFormat* best_format) {
   // TODO(fbarchard): Directly support max_format.
   UpdateFilteredSupportedFormats();
   const std::vector<VideoFormat>* supported_formats = GetSupportedFormats();
 
   if (supported_formats->empty()) {
     return false;
   }
   LOG(LS_INFO) << " Capture Requested " << format.ToString();
-  int64 best_distance = kMaxDistance;
+  int64_t best_distance = kMaxDistance;
   std::vector<VideoFormat>::const_iterator best = supported_formats->end();
   std::vector<VideoFormat>::const_iterator i;
   for (i = supported_formats->begin(); i != supported_formats->end(); ++i) {
-    int64 distance = GetFormatDistance(format, *i);
+    int64_t distance = GetFormatDistance(format, *i);
     // TODO(fbarchard): Reduce to LS_VERBOSE if/when camera capture is
     // relatively bug free.
     LOG(LS_INFO) << " Supported " << i->ToString() << " distance " << distance;
     if (distance < best_distance) {
       best_distance = distance;
       best = i;
     }
   }
   if (supported_formats->end() == best) {
     LOG(LS_ERROR) << " No acceptable camera format found";
@@ skipping 61 matching lines @@
     } else {
       --black_frame_count_down_;
     }
   }
 
   if (SignalVideoFrame.is_empty()) {
     return;
   }
 
   // Use a temporary buffer to scale
-  rtc::scoped_ptr<uint8[]> scale_buffer;
+  rtc::scoped_ptr<uint8_t[]> scale_buffer;
 
   if (IsScreencast()) {
     int scaled_width, scaled_height;
     if (screencast_max_pixels_ > 0) {
       ComputeScaleMaxPixels(captured_frame->width, captured_frame->height,
           screencast_max_pixels_, &scaled_width, &scaled_height);
     } else {
       int desired_screencast_fps = capture_format_.get() ?
           VideoFormat::IntervalToFps(capture_format_->interval) :
           kDefaultScreencastFps;
       ComputeScale(captured_frame->width, captured_frame->height,
                    desired_screencast_fps, &scaled_width, &scaled_height);
     }
 
     if (FOURCC_ARGB == captured_frame->fourcc &&
         (scaled_width != captured_frame->width ||
         scaled_height != captured_frame->height)) {
       if (scaled_width != scaled_width_ || scaled_height != scaled_height_) {
         LOG(LS_INFO) << "Scaling Screencast from "
                      << captured_frame->width << "x"
                      << captured_frame->height << " to "
                      << scaled_width << "x" << scaled_height;
         scaled_width_ = scaled_width;
         scaled_height_ = scaled_height;
       }
       CapturedFrame* modified_frame =
           const_cast<CapturedFrame*>(captured_frame);
       const int modified_frame_size = scaled_width * scaled_height * 4;
-      scale_buffer.reset(new uint8[modified_frame_size]);
+      scale_buffer.reset(new uint8_t[modified_frame_size]);
       // Compute new width such that width * height is less than maximum but
       // maintains original captured frame aspect ratio.
       // Round down width to multiple of 4 so odd width won't round up beyond
       // maximum, and so chroma channel is even width to simplify spatial
       // resampling.
-      libyuv::ARGBScale(reinterpret_cast<const uint8*>(captured_frame->data),
+      libyuv::ARGBScale(reinterpret_cast<const uint8_t*>(captured_frame->data),
                         captured_frame->width * 4, captured_frame->width,
-                        captured_frame->height,
-                        scale_buffer.get(),
+                        captured_frame->height, scale_buffer.get(),
                         scaled_width * 4, scaled_width, scaled_height,
                         libyuv::kFilterBilinear);
       modified_frame->width = scaled_width;
       modified_frame->height = scaled_height;
       modified_frame->data_size = scaled_width * 4 * scaled_height;
       modified_frame->data = scale_buffer.get();
     }
   }
 
   const int kYuy2Bpp = 2;
   const int kArgbBpp = 4;
   // TODO(fbarchard): Make a helper function to adjust pixels to square.
   // TODO(fbarchard): Hook up experiment to scaling.
   // TODO(fbarchard): Avoid scale and convert if muted.
   // Temporary buffer is scoped here so it will persist until i420_frame.Init()
   // makes a copy of the frame, converting to I420.
-  rtc::scoped_ptr<uint8[]> temp_buffer;
+  rtc::scoped_ptr<uint8_t[]> temp_buffer;
   // YUY2 can be scaled vertically using an ARGB scaler.  Aspect ratio is only
   // a problem on OSX.  OSX always converts webcams to YUY2 or UYVY.
   bool can_scale =
       FOURCC_YUY2 == CanonicalFourCC(captured_frame->fourcc) ||
       FOURCC_UYVY == CanonicalFourCC(captured_frame->fourcc);
 
   // If pixels are not square, optionally use vertical scaling to make them
   // square.  Square pixels simplify the rest of the pipeline, including
   // effects and rendering.
   if (can_scale && square_pixel_aspect_ratio_ &&
@@ skipping 13 matching lines @@
                    << captured_frame->width << "x"
                    << captured_frame->height << " to "
                    << scaled_width << "x" << scaled_height
                    << " for PAR "
                    << captured_frame->pixel_width << "x"
                    << captured_frame->pixel_height;
       scaled_width_ = scaled_width;
       scaled_height_ = scaled_height;
     }
     const int modified_frame_size = scaled_width * scaled_height * kYuy2Bpp;
-    uint8* temp_buffer_data;
+    uint8_t* temp_buffer_data;
     // Pixels are wide and short; Increasing height. Requires temporary buffer.
     if (scaled_height > captured_frame->height) {
-      temp_buffer.reset(new uint8[modified_frame_size]);
+      temp_buffer.reset(new uint8_t[modified_frame_size]);
       temp_buffer_data = temp_buffer.get();
     } else {
       // Pixels are narrow and tall; Decreasing height. Scale will be done
       // in place.
-      temp_buffer_data = reinterpret_cast<uint8*>(captured_frame->data);
+      temp_buffer_data = reinterpret_cast<uint8_t*>(captured_frame->data);
     }
 
     // Use ARGBScaler to vertically scale the YUY2 image, adjusting for 16 bpp.
-    libyuv::ARGBScale(reinterpret_cast<const uint8*>(captured_frame->data),
+    libyuv::ARGBScale(reinterpret_cast<const uint8_t*>(captured_frame->data),
                       captured_frame->width * kYuy2Bpp,  // Stride for YUY2.
                       captured_frame->width * kYuy2Bpp / kArgbBpp,  // Width.
-                      abs(captured_frame->height),  // Height.
+                      abs(captured_frame->height),                  // Height.
                       temp_buffer_data,
-                      scaled_width * kYuy2Bpp,  // Stride for YUY2.
+                      scaled_width * kYuy2Bpp,             // Stride for YUY2.
                       scaled_width * kYuy2Bpp / kArgbBpp,  // Width.
-                      abs(scaled_height),  // New height.
+                      abs(scaled_height),                  // New height.
                       libyuv::kFilterBilinear);
     modified_frame->width = scaled_width;
     modified_frame->height = scaled_height;
     modified_frame->pixel_width = 1;
     modified_frame->pixel_height = 1;
     modified_frame->data_size = modified_frame_size;
     modified_frame->data = temp_buffer_data;
   }
 
   // Size to crop captured frame to.  This adjusts the captured frames
@@ skipping 99 matching lines @@
   }
 }
 
 // Get the distance between the supported and desired formats.
 // Prioritization is done according to this algorithm:
 // 1) Width closeness. If not same, we prefer wider.
 // 2) Height closeness. If not same, we prefer higher.
 // 3) Framerate closeness. If not same, we prefer faster.
 // 4) Compression. If desired format has a specific fourcc, we need exact match;
 //                otherwise, we use preference.
-int64 VideoCapturer::GetFormatDistance(const VideoFormat& desired,
-                                       const VideoFormat& supported) {
-  int64 distance = kMaxDistance;
+int64_t VideoCapturer::GetFormatDistance(const VideoFormat& desired,
+                                         const VideoFormat& supported) {
+  int64_t distance = kMaxDistance;
 
   // Check fourcc.
-  uint32 supported_fourcc = CanonicalFourCC(supported.fourcc);
-  int64 delta_fourcc = kMaxDistance;
+  uint32_t supported_fourcc = CanonicalFourCC(supported.fourcc);
+  int64_t delta_fourcc = kMaxDistance;
   if (FOURCC_ANY == desired.fourcc) {
     // Any fourcc is OK for the desired. Use preference to find best fourcc.
-    std::vector<uint32> preferred_fourccs;
+    std::vector<uint32_t> preferred_fourccs;
     if (!GetPreferredFourccs(&preferred_fourccs)) {
       return distance;
     }
 
     for (size_t i = 0; i < preferred_fourccs.size(); ++i) {
       if (supported_fourcc == CanonicalFourCC(preferred_fourccs[i])) {
         delta_fourcc = i;
 #ifdef LINUX
         // For HD avoid YU12 which is a software conversion and has 2 bugs
         // b/7326348 b/6960899.  Reenable when fixed.
@@ skipping 10 matching lines @@
   }
 
   if (kMaxDistance == delta_fourcc) {
     // Failed to match fourcc.
     return distance;
   }
 
   // Check resolution and fps.
   int desired_width = desired.width;
   int desired_height = desired.height;
-  int64 delta_w = supported.width - desired_width;
+  int64_t delta_w = supported.width - desired_width;
   float supported_fps = VideoFormat::IntervalToFpsFloat(supported.interval);
   float delta_fps =
       supported_fps - VideoFormat::IntervalToFpsFloat(desired.interval);
   // Check height of supported height compared to height we would like it to be.
-  int64 aspect_h =
-      desired_width ? supported.width * desired_height / desired_width
-                    : desired_height;
-  int64 delta_h = supported.height - aspect_h;
+  int64_t aspect_h = desired_width
+                         ? supported.width * desired_height / desired_width
+                         : desired_height;
+  int64_t delta_h = supported.height - aspect_h;
 
   distance = 0;
   // Set high penalty if the supported format is lower than the desired format.
   // 3x means we would prefer down to down to 3/4, than up to double.
   // But we'd prefer up to double than down to 1/2.  This is conservative,
   // strongly avoiding going down in resolution, similar to
   // the old method, but not completely ruling it out in extreme situations.
   // It also ignores framerate, which is often very low at high resolutions.
   // TODO(fbarchard): Improve logic to use weighted factors.
   static const int kDownPenalty = -3;
   if (delta_w < 0) {
     delta_w = delta_w * kDownPenalty;
   }
   if (delta_h < 0) {
     delta_h = delta_h * kDownPenalty;
   }
   // Require camera fps to be at least 80% of what is requested if resolution
   // matches.
   // Require camera fps to be at least 96% of what is requested, or higher,
   // if resolution differs. 96% allows for slight variations in fps. e.g. 29.97
   if (delta_fps < 0) {
     float min_desirable_fps = delta_w ?
     VideoFormat::IntervalToFpsFloat(desired.interval) * 28.f / 30.f :
     VideoFormat::IntervalToFpsFloat(desired.interval) * 23.f / 30.f;
     delta_fps = -delta_fps;
     if (supported_fps < min_desirable_fps) {
-      distance |= static_cast<int64>(1) << 62;
+      distance |= static_cast<int64_t>(1) << 62;
     } else {
-      distance |= static_cast<int64>(1) << 15;
+      distance |= static_cast<int64_t>(1) << 15;
     }
   }
-  int64 idelta_fps = static_cast<int>(delta_fps);
+  int64_t idelta_fps = static_cast<int>(delta_fps);
 
   // 12 bits for width and height and 8 bits for fps and fourcc.
   distance |=
       (delta_w << 28) | (delta_h << 16) | (idelta_fps << 8) | delta_fourcc;
 
   return distance;
 }
 
 void VideoCapturer::UpdateFilteredSupportedFormats() {
   filtered_supported_formats_.clear();
@@ skipping 48 matching lines @@
 void VideoCapturer::GetVariableSnapshot(
     const rtc::RollingAccumulator<T>& data,
     VariableInfo<T>* stats) {
   stats->max_val = data.ComputeMax();
   stats->mean = data.ComputeMean();
   stats->min_val = data.ComputeMin();
   stats->variance = data.ComputeVariance();
 }
 
 }  // namespace cricket