Switch to standard integer types in media/.

media/filters/vpx_video_decoder.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/filters/vpx_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 93 matching lines @@
       public base::trace_event::MemoryDumpProvider {
  public:
   MemoryPool();
 
   // Callback that will be called by libvpx when it needs a frame buffer.
   // Parameters:
   // |user_priv|  Private data passed to libvpx (pointer to memory pool).
   // |min_size|   Minimum size needed by libvpx to decompress the next frame.
   // |fb|         Pointer to the frame buffer to update.
   // Returns 0 on success. Returns < 0 on failure.
-  static int32 GetVP9FrameBuffer(void* user_priv, size_t min_size,
-                                 vpx_codec_frame_buffer* fb);
+  static int32_t GetVP9FrameBuffer(void* user_priv,
+                                   size_t min_size,
+                                   vpx_codec_frame_buffer* fb);
 
   // Callback that will be called by libvpx when the frame buffer is no longer
   // being used by libvpx. Parameters:
   // |user_priv|  Private data passed to libvpx (pointer to memory pool).
   // |fb|         Pointer to the frame buffer that's being released.
-  static int32 ReleaseVP9FrameBuffer(void* user_priv,
-                                     vpx_codec_frame_buffer* fb);
+  static int32_t ReleaseVP9FrameBuffer(void* user_priv,
+                                       vpx_codec_frame_buffer* fb);
 
   // Generates a "no_longer_needed" closure that holds a reference to this pool.
   base::Closure CreateFrameCallback(void* fb_priv_data);
 
   // base::MemoryDumpProvider.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
   int NumberOfFrameBuffersInUseByDecoder() const;
   int NumberOfFrameBuffersInUseByDecoderAndVideoFrame() const;
 
  private:
   friend class base::RefCountedThreadSafe<VpxVideoDecoder::MemoryPool>;
   ~MemoryPool() override;
 
   // Reference counted frame buffers used for VP9 decoding. Reference counting
   // is done manually because both chromium and libvpx has to release this
   // before a buffer can be re-used.
   struct VP9FrameBuffer {
     VP9FrameBuffer() : ref_cnt(0) {}
-    std::vector<uint8> data;
-    uint32 ref_cnt;
+    std::vector<uint8_t> data;
+    uint32_t ref_cnt;
   };
 
   // Gets the next available frame buffer for use by libvpx.
   VP9FrameBuffer* GetFreeFrameBuffer(size_t min_size);
 
   // Method that gets called when a VideoFrame that references this pool gets
   // destroyed.
   void OnVideoFrameDestroyed(VP9FrameBuffer* frame_buffer);
 
   // Frame buffers to be used by libvpx for VP9 Decoding.
@@ skipping 31 matching lines @@
     // Create a new frame buffer.
     frame_buffers_.push_back(new VP9FrameBuffer());
   }
 
   // Resize the frame buffer if necessary.
   if (frame_buffers_[i]->data.size() < min_size)
     frame_buffers_[i]->data.resize(min_size);
   return frame_buffers_[i];
 }
 
-int32 VpxVideoDecoder::MemoryPool::GetVP9FrameBuffer(
-    void* user_priv, size_t min_size, vpx_codec_frame_buffer* fb) {
+int32_t VpxVideoDecoder::MemoryPool::GetVP9FrameBuffer(
+    void* user_priv,
+    size_t min_size,
+    vpx_codec_frame_buffer* fb) {
   DCHECK(user_priv);
   DCHECK(fb);
 
   VpxVideoDecoder::MemoryPool* memory_pool =
       static_cast<VpxVideoDecoder::MemoryPool*>(user_priv);
 
   VP9FrameBuffer* fb_to_use = memory_pool->GetFreeFrameBuffer(min_size);
   if (fb_to_use == NULL)
     return -1;
 
   fb->data = &fb_to_use->data[0];
   fb->size = fb_to_use->data.size();
   ++fb_to_use->ref_cnt;
   ++memory_pool->in_use_by_decoder_;
 
   // Set the frame buffer's private data to point at the external frame buffer.
   fb->priv = static_cast<void*>(fb_to_use);
   return 0;
 }
 
-int32 VpxVideoDecoder::MemoryPool::ReleaseVP9FrameBuffer(
+int32_t VpxVideoDecoder::MemoryPool::ReleaseVP9FrameBuffer(
     void* user_priv,
     vpx_codec_frame_buffer* fb) {
   DCHECK(user_priv);
   DCHECK(fb);
   VP9FrameBuffer* frame_buffer = static_cast<VP9FrameBuffer*>(fb->priv);
   --frame_buffer->ref_cnt;
 
   VpxVideoDecoder::MemoryPool* memory_pool =
       static_cast<VpxVideoDecoder::MemoryPool*>(user_priv);
   --memory_pool->in_use_by_decoder_;
@@ skipping 200 matching lines @@
     delete vpx_codec_alpha_;
     vpx_codec_alpha_ = nullptr;
   }
 }
 
 bool VpxVideoDecoder::VpxDecode(const scoped_refptr<DecoderBuffer>& buffer,
                                 scoped_refptr<VideoFrame>* video_frame) {
   DCHECK(video_frame);
   DCHECK(!buffer->end_of_stream());
 
-  int64 timestamp = buffer->timestamp().InMicroseconds();
+  int64_t timestamp = buffer->timestamp().InMicroseconds();
   void* user_priv = reinterpret_cast<void*>(&timestamp);
   {
     TRACE_EVENT1("video", "vpx_codec_decode", "timestamp", timestamp);
     vpx_codec_err_t status =
         vpx_codec_decode(vpx_codec_, buffer->data(), buffer->data_size(),
                          user_priv, 0 /* deadline */);
     if (status != VPX_CODEC_OK) {
       DLOG(ERROR) << "vpx_codec_decode() error: "
                   << vpx_codec_err_to_string(status);
       return false;
@@ skipping 28 matching lines @@
   (*video_frame)
       ->metadata()
       ->SetInteger(VideoFrameMetadata::COLOR_SPACE, color_space);
 
   if (!vpx_codec_alpha_)
     return true;
 
   if (buffer->side_data_size() < 8) {
     // TODO(mcasas): Is this a warning or an error?
     DLOG(WARNING) << "Making Alpha channel opaque due to missing input";
-    const uint32 kAlphaOpaqueValue = 255;
+    const uint32_t kAlphaOpaqueValue = 255;
     libyuv::SetPlane((*video_frame)->visible_data(VideoFrame::kAPlane),
                      (*video_frame)->stride(VideoFrame::kAPlane),
                      (*video_frame)->visible_rect().width(),
                      (*video_frame)->visible_rect().height(),
                      kAlphaOpaqueValue);
     return true;
   }
 
   // First 8 bytes of side data is |side_data_id| in big endian.
-  const uint64 side_data_id = base::NetToHost64(
-      *(reinterpret_cast<const uint64*>(buffer->side_data())));
+  const uint64_t side_data_id = base::NetToHost64(
+      *(reinterpret_cast<const uint64_t*>(buffer->side_data())));
   if (side_data_id != 1)
     return true;
 
   // Try and decode buffer->side_data() minus the first 8 bytes as a full frame.
-  int64 timestamp_alpha = buffer->timestamp().InMicroseconds();
+  int64_t timestamp_alpha = buffer->timestamp().InMicroseconds();
   void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
   {
     TRACE_EVENT1("video", "vpx_codec_decode_alpha", "timestamp_alpha",
                  timestamp_alpha);
     vpx_codec_err_t status = vpx_codec_decode(
         vpx_codec_alpha_, buffer->side_data() + 8, buffer->side_data_size() - 8,
         user_priv_alpha, 0 /* deadline */);
     if (status != VPX_CODEC_OK) {
       DLOG(ERROR) << "vpx_codec_decode() failed for the alpha: "
                   << vpx_codec_error(vpx_codec_);
@@ skipping 98 matching lines @@
       (*video_frame)->visible_data(VideoFrame::kUPlane),
       (*video_frame)->stride(VideoFrame::kUPlane),
       (*video_frame)->visible_data(VideoFrame::kVPlane),
       (*video_frame)->stride(VideoFrame::kVPlane), coded_size.width(),
       coded_size.height());
 
   return true;
 }
 
 }  // namespace media