Audit/fix use of media::VideoFrame::coded_size()

media/base/video_frame.h

 // 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.
 
 #ifndef MEDIA_BASE_VIDEO_FRAME_H_
 #define MEDIA_BASE_VIDEO_FRAME_H_
 
 #include "base/callback.h"
 #include "base/md5.h"
 #include "base/memory/shared_memory.h"
@@ skipping 42 matching lines @@
     NATIVE_TEXTURE = 6,  // Native texture.  Pixel-format agnostic.
     YV12J = 7,  // JPEG color range version of YV12
     HISTOGRAM_MAX,  // Must always be greatest.
   };
 
   // Returns the name of a Format as a string.
   static std::string FormatToString(Format format);
 
   // Creates a new frame in system memory with given parameters. Buffers for
   // the frame are allocated but not initialized.
-  // |coded_size| is the width and height of the frame data in pixels.
-  // |visible_rect| is the visible portion of |coded_size|, after cropping (if
-  // any) is applied.
-  // |natural_size| is the width and height of the frame when the frame's aspect
-  // ratio is applied to |visible_rect|.
   static scoped_refptr<VideoFrame> CreateFrame(
       Format format,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp);
 
   // Call prior to CreateFrame to ensure validity of frame configuration. Called
   // automatically by VideoDecoderConfig::IsValidConfig().
   // TODO(scherkus): VideoDecoderConfig shouldn't call this method
   static bool IsValidConfig(Format format, const gfx::Size& coded_size,
                             const gfx::Rect& visible_rect,
                             const gfx::Size& natural_size);
 
   // CB to write pixels from the texture backing this frame into the
   // |const SkBitmap&| parameter.
   typedef base::Callback<void(const SkBitmap&)> ReadPixelsCB;
 
   // CB to be called on the mailbox backing this frame when the frame is
   // destroyed.
   typedef base::Callback<void(scoped_ptr<gpu::MailboxHolder>)> ReleaseMailboxCB;
 
   // Wraps a native texture of the given parameters with a VideoFrame.  The
   // backing of the VideoFrame is held in the mailbox held by |mailbox_holder|,
   // and |mailbox_holder_release_cb| will be called with |mailbox_holder| as the
   // argument when the VideoFrame is to be destroyed.
-  // |coded_size| is the width and height of the frame data in pixels.
-  // |visible_rect| is the visible portion of |coded_size|, after cropping (if
-  // any) is applied.
-  // |natural_size| is the width and height of the frame when the frame's aspect
-  // ratio is applied to |visible_rect|.
-
   // |read_pixels_cb| may be used to do (slow!) readbacks from the
   // texture to main memory.
   static scoped_refptr<VideoFrame> WrapNativeTexture(
       scoped_ptr<gpu::MailboxHolder> mailbox_holder,
       const ReleaseMailboxCB& mailbox_holder_release_cb,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp,
       const ReadPixelsCB& read_pixels_cb);
 
   // Read pixels from the native texture backing |*this| and write
   // them to |pixels| as BGRA.  |pixels| must point to a buffer at
-  // least as large as 4*visible_rect().width()*visible_rect().height().
+  // least as large as 4 * visible_rect().size().GetArea().
   void ReadPixelsFromNativeTexture(const SkBitmap& pixels);
 
   // Wraps packed image data residing in a memory buffer with a VideoFrame.
   // The image data resides in |data| and is assumed to be packed tightly in a
   // buffer of logical dimensions |coded_size| with the appropriate bit depth
   // and plane count as given by |format|.  The shared memory handle of the
   // backing allocation, if present, can be passed in with |handle|.  When the
   // frame is destroyed, |no_longer_needed_cb.Run()| will be called.
   static scoped_refptr<VideoFrame> WrapExternalPackedMemory(
       Format format,
@@ skipping 48 matching lines @@
   // Allocates a hole frame.
   static scoped_refptr<VideoFrame> CreateHoleFrame(const gfx::Size& size);
 #endif  // defined(VIDEO_HOLE)
 
   static size_t NumPlanes(Format format);
 
   // Returns the required allocation size for a (tightly packed) frame of the
   // given coded size and format.
   static size_t AllocationSize(Format format, const gfx::Size& coded_size);
 
+  // Returns the plane size for a plane of the given coded size and format.
+  static gfx::Size PlaneSize(Format format,
+                             size_t plane,
+                             const gfx::Size& coded_size);
+
   // Returns the required allocation size for a (tightly packed) plane of the
   // given coded size and format.
   static size_t PlaneAllocationSize(Format format,
                                     size_t plane,
                                     const gfx::Size& coded_size);
 
   Format format() const { return format_; }
 
   const gfx::Size& coded_size() const { return coded_size_; }
   const gfx::Rect& visible_rect() const { return visible_rect_; }
@@ skipping 44 matching lines @@
              base::TimeDelta timestamp,
              bool end_of_stream);
   virtual ~VideoFrame();
 
   void AllocateYUV();
 
   // Used to DCHECK() plane parameters.
   bool IsValidPlane(size_t plane) const;
 
   // Frame format.
-  Format format_;
+  const Format format_;
 
-  // Width and height of the video frame.
-  gfx::Size coded_size_;
+  // Width and height of the video frame, in pixels. This must include pixel
+  // data for the whole image; i.e. for YUV formats with subsampled chroma
+  // planes, in the case that the visible portion of the image does not line up
+  // on a sample boundary, |coded_size_| must be rounded up appropriately and
+  // the pixel data provided for the odd pixels.
+  const gfx::Size coded_size_;
 
-  // Width, height, and offsets of the visible portion of the video frame.
-  gfx::Rect visible_rect_;
+  // Width, height, and offsets of the visible portion of the video frame. Must
+  // be a subrect of |coded_size_|. Can be odd with respect to the sample
+  // boundaries, e.g. for formats with subsampled chroma.
+  const gfx::Rect visible_rect_;
 
-  // Width and height of the visible portion of the video frame with aspect
-  // ratio taken into account.
-  gfx::Size natural_size_;
+  // Width and height of the visible portion of the video frame
+  // (|visible_rect_.size()|) with aspect ratio taken into account.
+  const gfx::Size natural_size_;
 
   // Array of strides for each plane, typically greater or equal to the width
   // of the surface divided by the horizontal sampling period.  Note that
   // strides can be negative.
   int32 strides_[kMaxPlanes];
 
   // Array of data pointers to each plane.
   uint8* data_[kMaxPlanes];
 
   // Native texture mailbox, if this is a NATIVE_TEXTURE frame.
   scoped_ptr<gpu::MailboxHolder> mailbox_holder_;
   ReleaseMailboxCB mailbox_holder_release_cb_;
   ReadPixelsCB read_pixels_cb_;
 
   // Shared memory handle, if this frame was allocated from shared memory.
   base::SharedMemoryHandle shared_memory_handle_;
 
   base::Closure no_longer_needed_cb_;
 
   base::TimeDelta timestamp_;
 
   const bool end_of_stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_