Switch to standard integer types in remoting/.

remoting/codec/video_encoder_vpx.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/codec/video_encoder_vpx.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "remoting/base/util.h"
@@ skipping 131 matching lines @@
 
   // Set cyclic refresh (aka "top-off") only for lossy encoding.
   int aq_mode = lossless_encode ? kVp9AqModeNone : kVp9AqModeCyclicRefresh;
   ret = vpx_codec_control(codec, VP9E_SET_AQ_MODE, aq_mode);
   DCHECK_EQ(VPX_CODEC_OK, ret) << "Failed to set aq mode";
 }
 
 void FreeImageIfMismatched(bool use_i444,
                            const webrtc::DesktopSize& size,
                            scoped_ptr<vpx_image_t>* out_image,
-                           scoped_ptr<uint8[]>* out_image_buffer) {
+                           scoped_ptr<uint8_t[]>* out_image_buffer) {
   if (*out_image) {
     const vpx_img_fmt_t desired_fmt =
         use_i444 ? VPX_IMG_FMT_I444 : VPX_IMG_FMT_I420;
     if (!size.equals(webrtc::DesktopSize((*out_image)->w, (*out_image)->h)) ||
         (*out_image)->fmt != desired_fmt) {
       out_image_buffer->reset();
       out_image->reset();
     }
   }
 }
 
 void CreateImage(bool use_i444,
                  const webrtc::DesktopSize& size,
                  scoped_ptr<vpx_image_t>* out_image,
-                 scoped_ptr<uint8[]>* out_image_buffer) {
+                 scoped_ptr<uint8_t[]>* out_image_buffer) {
   DCHECK(!size.is_empty());
   DCHECK(!*out_image_buffer);
   DCHECK(!*out_image);
 
   scoped_ptr<vpx_image_t> image(new vpx_image_t());
   memset(image.get(), 0, sizeof(vpx_image_t));
 
   // libvpx seems to require both to be assigned.
   image->d_w = size.width();
   image->w = size.width();
@@ skipping 22 matching lines @@
   // if the image is not padded out to the next macroblock: crbug.com/119633.
   // Pad the Y, U and V planes' height out to compensate.
   // Assuming macroblocks are 16x16, aligning the planes' strides above also
   // macroblock aligned them.
   static_assert(kMacroBlockSize == 16, "macroblock_size_not_16");
   const int y_rows = ((image->h - 1) & ~(kMacroBlockSize-1)) + kMacroBlockSize;
   const int uv_rows = y_rows >> image->y_chroma_shift;
 
   // Allocate a YUV buffer large enough for the aligned data & padding.
   const int buffer_size = y_stride * y_rows + 2*uv_stride * uv_rows;
-  scoped_ptr<uint8[]> image_buffer(new uint8[buffer_size]);
+  scoped_ptr<uint8_t[]> image_buffer(new uint8_t[buffer_size]);
 
   // Reset image value to 128 so we just need to fill in the y plane.
   memset(image_buffer.get(), 128, buffer_size);
 
   // Fill in the information for |image_|.
   unsigned char* uchar_buffer =
       reinterpret_cast<unsigned char*>(image_buffer.get());
   image->planes[0] = uchar_buffer;
   image->planes[1] = image->planes[0] + y_stride * y_rows;
   image->planes[2] = image->planes[1] + uv_stride * uv_rows;
@@ skipping 132 matching lines @@
   // Tear down |image_| if it no longer matches the size and color settings.
   // PrepareImage() will then create a new buffer of the required dimensions if
   // |image_| is not allocated.
   FreeImageIfMismatched(lossless_color_, size, &image_, &image_buffer_);
 
   // Initialize active map.
   active_map_size_ = webrtc::DesktopSize(
       (size.width() + kMacroBlockSize - 1) / kMacroBlockSize,
       (size.height() + kMacroBlockSize - 1) / kMacroBlockSize);
   active_map_.reset(
-      new uint8[active_map_size_.width() * active_map_size_.height()]);
+      new uint8_t[active_map_size_.width() * active_map_size_.height()]);
 
   // TODO(wez): Remove this hack once VPX can handle frame size reconfiguration.
   // See https://code.google.com/p/webm/issues/detail?id=912.
   if (codec_) {
     // If the frame size has changed then force re-creation of the codec.
     if (codec_->config.enc->g_w != static_cast<unsigned int>(size.width()) ||
         codec_->config.enc->g_h != static_cast<unsigned int>(size.height())) {
       codec_.reset();
     }
   }
@@ skipping 66 matching lines @@
     // aligned. The conversion routines don't require even width & height,
     // so this is safe even if the source dimensions are not even.
     updated_region->IntersectWith(
         webrtc::DesktopRect::MakeWH(image_->w, image_->h));
   } else {
     CreateImage(lossless_color_, frame.size(), &image_, &image_buffer_);
     updated_region->AddRect(webrtc::DesktopRect::MakeWH(image_->w, image_->h));
   }
 
   // Convert the updated region to YUV ready for encoding.
-  const uint8* rgb_data = frame.data();
+  const uint8_t* rgb_data = frame.data();
   const int rgb_stride = frame.stride();
   const int y_stride = image_->stride[0];
   DCHECK_EQ(image_->stride[1], image_->stride[2]);
   const int uv_stride = image_->stride[1];
-  uint8* y_data = image_->planes[0];
-  uint8* u_data = image_->planes[1];
-  uint8* v_data = image_->planes[2];
+  uint8_t* y_data = image_->planes[0];
+  uint8_t* u_data = image_->planes[1];
+  uint8_t* v_data = image_->planes[2];
 
   switch (image_->fmt) {
     case VPX_IMG_FMT_I444:
       for (webrtc::DesktopRegion::Iterator r(*updated_region); !r.IsAtEnd();
            r.Advance()) {
         const webrtc::DesktopRect& rect = r.rect();
         int rgb_offset = rgb_stride * rect.top() +
                          rect.left() * kBytesPerRgbPixel;
         int yuv_offset = uv_stride * rect.top() + rect.left();
         libyuv::ARGBToI444(rgb_data + rgb_offset, rgb_stride,
@@ skipping 34 matching lines @@
   for (webrtc::DesktopRegion::Iterator r(updated_region); !r.IsAtEnd();
        r.Advance()) {
     const webrtc::DesktopRect& rect = r.rect();
     int left = rect.left() / kMacroBlockSize;
     int right = (rect.right() - 1) / kMacroBlockSize;
     int top = rect.top() / kMacroBlockSize;
     int bottom = (rect.bottom() - 1) / kMacroBlockSize;
     DCHECK_LT(right, active_map_size_.width());
     DCHECK_LT(bottom, active_map_size_.height());
 
-    uint8* map = active_map_.get() + top * active_map_size_.width();
+    uint8_t* map = active_map_.get() + top * active_map_size_.width();
     for (int y = top; y <= bottom; ++y) {
       for (int x = left; x <= right; ++x)
         map[x] = 1;
       map += active_map_size_.width();
     }
   }
 }
 
 void VideoEncoderVpx::UpdateRegionFromActiveMap(
     webrtc::DesktopRegion* updated_region) {
-  const uint8* map = active_map_.get();
+  const uint8_t* map = active_map_.get();
   for (int y = 0; y < active_map_size_.height(); ++y) {
     for (int x0 = 0; x0 < active_map_size_.width();) {
       int x1 = x0;
       for (; x1 < active_map_size_.width(); ++x1) {
         if (map[y * active_map_size_.width() + x1] == 0)
           break;
       }
       if (x1 > x0) {
         updated_region->AddRect(webrtc::DesktopRect::MakeLTRB(
             kMacroBlockSize * x0, kMacroBlockSize * y, kMacroBlockSize * x1,
             kMacroBlockSize * (y + 1)));
       }
       x0 = x1 + 1;
     }
   }
   updated_region->IntersectWith(
       webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 }
 
 }  // namespace remoting