Switch to standard integer types in media/.

media/base/video_frame.cc

 // Copyright (c) 2012 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 "media/base/video_frame.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/bind.h"
@@ skipping 261 matching lines @@
   return new VideoFrame(format, storage, coded_size, visible_rect, natural_size,
                         mailbox_holders, mailbox_holder_release_cb, timestamp);
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalData(
     VideoPixelFormat format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
-    uint8* data,
+    uint8_t* data,
     size_t data_size,
     base::TimeDelta timestamp) {
   return WrapExternalStorage(format, STORAGE_UNOWNED_MEMORY, coded_size,
                              visible_rect, natural_size, data, data_size,
                              timestamp, base::SharedMemory::NULLHandle(), 0);
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalSharedMemory(
     VideoPixelFormat format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
-    uint8* data,
+    uint8_t* data,
     size_t data_size,
     base::SharedMemoryHandle handle,
     size_t data_offset,
     base::TimeDelta timestamp) {
   return WrapExternalStorage(format, STORAGE_SHMEM, coded_size, visible_rect,
                              natural_size, data, data_size, timestamp, handle,
                              data_offset);
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalYuvData(
     VideoPixelFormat format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
-    int32 y_stride,
-    int32 u_stride,
-    int32 v_stride,
-    uint8* y_data,
-    uint8* u_data,
-    uint8* v_data,
+    int32_t y_stride,
+    int32_t u_stride,
+    int32_t v_stride,
+    uint8_t* y_data,
+    uint8_t* u_data,
+    uint8_t* v_data,
     base::TimeDelta timestamp) {
   const StorageType storage = STORAGE_UNOWNED_MEMORY;
   if (!IsValidConfig(format, storage, coded_size, visible_rect, natural_size)) {
     DLOG(ERROR) << __FUNCTION__ << " Invalid config."
                 << ConfigToString(format, storage, coded_size, visible_rect,
                                   natural_size);
     return nullptr;
   }
 
   scoped_refptr<VideoFrame> frame(new VideoFrame(
       format, storage, coded_size, visible_rect, natural_size, timestamp));
   frame->strides_[kYPlane] = y_stride;
   frame->strides_[kUPlane] = u_stride;
   frame->strides_[kVPlane] = v_stride;
   frame->data_[kYPlane] = y_data;
   frame->data_[kUPlane] = u_data;
   frame->data_[kVPlane] = v_data;
   return frame;
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalYuvGpuMemoryBuffers(
     VideoPixelFormat format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
-    int32 y_stride,
-    int32 u_stride,
-    int32 v_stride,
-    uint8* y_data,
-    uint8* u_data,
-    uint8* v_data,
+    int32_t y_stride,
+    int32_t u_stride,
+    int32_t v_stride,
+    uint8_t* y_data,
+    uint8_t* u_data,
+    uint8_t* v_data,
     const gfx::GpuMemoryBufferHandle& y_handle,
     const gfx::GpuMemoryBufferHandle& u_handle,
     const gfx::GpuMemoryBufferHandle& v_handle,
     base::TimeDelta timestamp) {
   const StorageType storage = STORAGE_GPU_MEMORY_BUFFERS;
   if (!IsValidConfig(format, storage, coded_size, visible_rect, natural_size)) {
     DLOG(ERROR) << __FUNCTION__ << " Invalid config."
                 << ConfigToString(format, storage, coded_size, visible_rect,
                                   natural_size);
     return nullptr;
@@ skipping 143 matching lines @@
   scoped_refptr<VideoFrame> frame =
       new VideoFrame(PIXEL_FORMAT_UNKNOWN, STORAGE_UNKNOWN, gfx::Size(),
                      gfx::Rect(), gfx::Size(), kNoTimestamp());
   frame->metadata()->SetBoolean(VideoFrameMetadata::END_OF_STREAM, true);
   return frame;
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateColorFrame(
     const gfx::Size& size,
-    uint8 y, uint8 u, uint8 v,
+    uint8_t y,
+    uint8_t u,
+    uint8_t v,
     base::TimeDelta timestamp) {
   scoped_refptr<VideoFrame> frame =
       CreateFrame(PIXEL_FORMAT_YV12, size, gfx::Rect(size), size, timestamp);
   FillYUV(frame.get(), y, u, v);
   return frame;
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateBlackFrame(const gfx::Size& size) {
-  const uint8 kBlackY = 0x00;
-  const uint8 kBlackUV = 0x80;
+  const uint8_t kBlackY = 0x00;
+  const uint8_t kBlackUV = 0x80;
   const base::TimeDelta kZero;
   return CreateColorFrame(size, kBlackY, kBlackUV, kBlackUV, kZero);
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateTransparentFrame(
     const gfx::Size& size) {
-  const uint8 kBlackY = 0x00;
-  const uint8 kBlackUV = 0x00;
-  const uint8 kTransparentA = 0x00;
+  const uint8_t kBlackY = 0x00;
+  const uint8_t kBlackUV = 0x00;
+  const uint8_t kTransparentA = 0x00;
   const base::TimeDelta kZero;
   scoped_refptr<VideoFrame> frame =
       CreateFrame(PIXEL_FORMAT_YV12A, size, gfx::Rect(size), size, kZero);
   FillYUVA(frame.get(), kBlackY, kBlackUV, kBlackUV, kTransparentA);
   return frame;
 }
 
 #if defined(VIDEO_HOLE)
 // This block and other blocks wrapped around #if defined(VIDEO_HOLE) is not
 // maintained by the general compositor team. Please contact
@@ skipping 143 matching lines @@
 }
 
 int VideoFrame::row_bytes(size_t plane) const {
   return RowBytes(plane, format_, coded_size_.width());
 }
 
 int VideoFrame::rows(size_t plane) const {
   return Rows(plane, format_, coded_size_.height());
 }
 
-const uint8* VideoFrame::data(size_t plane) const {
+const uint8_t* VideoFrame::data(size_t plane) const {
   DCHECK(IsValidPlane(plane, format_));
   DCHECK(IsMappable());
   return data_[plane];
 }
 
-uint8* VideoFrame::data(size_t plane) {
+uint8_t* VideoFrame::data(size_t plane) {
   DCHECK(IsValidPlane(plane, format_));
   DCHECK(IsMappable());
   return data_[plane];
 }
 
-const uint8* VideoFrame::visible_data(size_t plane) const {
+const uint8_t* VideoFrame::visible_data(size_t plane) const {
   DCHECK(IsValidPlane(plane, format_));
   DCHECK(IsMappable());
 
   // Calculate an offset that is properly aligned for all planes.
   const gfx::Size alignment = CommonAlignment(format_);
   const gfx::Point offset(RoundDown(visible_rect_.x(), alignment.width()),
                           RoundDown(visible_rect_.y(), alignment.height()));
 
   const gfx::Size subsample = SampleSize(format_, plane);
   DCHECK(offset.x() % subsample.width() == 0);
   DCHECK(offset.y() % subsample.height() == 0);
   return data(plane) +
          stride(plane) * (offset.y() / subsample.height()) +  // Row offset.
          BytesPerElement(format_, plane) *                    // Column offset.
              (offset.x() / subsample.width());
 }
 
-uint8* VideoFrame::visible_data(size_t plane) {
-  return const_cast<uint8*>(
+uint8_t* VideoFrame::visible_data(size_t plane) {
+  return const_cast<uint8_t*>(
       static_cast<const VideoFrame*>(this)->visible_data(plane));
 }
 
 const gpu::MailboxHolder&
 VideoFrame::mailbox_holder(size_t texture_index) const {
   DCHECK(HasTextures());
   DCHECK(IsValidPlane(texture_index, format_));
   return mailbox_holders_[texture_index];
 }
 
@@ skipping 78 matching lines @@
   client->GenerateSyncToken(&release_sync_token_);
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalStorage(
     VideoPixelFormat format,
     StorageType storage_type,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
-    uint8* data,
+    uint8_t* data,
     size_t data_size,
     base::TimeDelta timestamp,
     base::SharedMemoryHandle handle,
     size_t data_offset) {
   DCHECK(IsStorageTypeMappable(storage_type));
 
   // TODO(miu): This function should support any pixel format.
   // http://crbug.com/555909
   if (format != PIXEL_FORMAT_I420) {
     DLOG(ERROR) << "Only PIXEL_FORMAT_I420 format supported: "
@@ skipping 160 matching lines @@
     data_size += height * strides_[plane];
   }
 
   // The extra line of UV being allocated is because h264 chroma MC
   // overreads by one line in some cases, see libavcodec/utils.c:
   // avcodec_align_dimensions2() and libavcodec/x86/h264_chromamc.asm:
   // put_h264_chroma_mc4_ssse3().
   DCHECK(IsValidPlane(kUPlane, format_));
   data_size += strides_[kUPlane] + kFrameSizePadding;
 
-  uint8* data = reinterpret_cast<uint8*>(
+  uint8_t* data = reinterpret_cast<uint8_t*>(
       base::AlignedAlloc(data_size, kFrameAddressAlignment));
   if (zero_initialize_memory)
     memset(data, 0, data_size);
 
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane)
     data_[plane] = data + offset[plane];
 
   AddDestructionObserver(base::Bind(&base::AlignedFree, data));
 }
 
 }  // namespace media