Remove media::VideoFrame from media::VideoCaptureDevice::Client interface

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 "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 99 matching lines @@
   return frame;
 }
 
 void VideoFrame::ReadPixelsFromNativeTexture(const SkBitmap& pixels) {
   DCHECK_EQ(format_, NATIVE_TEXTURE);
   if (!read_pixels_cb_.is_null())
     read_pixels_cb_.Run(pixels);
 }
 
 // static
-scoped_refptr<VideoFrame> VideoFrame::WrapExternalSharedMemory(
+scoped_refptr<VideoFrame> VideoFrame::WrapExternalPackedMemory(
     Format format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     uint8* data,
     size_t data_size,
     base::SharedMemoryHandle handle,
     base::TimeDelta timestamp,
     const base::Closure& no_longer_needed_cb) {
   if (data_size < AllocationSize(format, coded_size))
@@ skipping 117 matching lines @@
 }
 
 static inline size_t RoundUp(size_t value, size_t alignment) {
   // Check that |alignment| is a power of 2.
   DCHECK((alignment + (alignment - 1)) == (alignment | (alignment - 1)));
   return ((value + (alignment - 1)) & ~(alignment-1));
 }
 
 // static
 size_t VideoFrame::AllocationSize(Format format, const gfx::Size& coded_size) {
+  size_t total = 0;
+  for (size_t i = 0; i < NumPlanes(format); ++i)
+    total += PlaneAllocationSize(format, i, coded_size);
+  return total;
+}
+
+// static
+size_t VideoFrame::PlaneAllocationSize(Format format,
+                                       size_t plane,
+                                       const gfx::Size& coded_size) {
+  const size_t area =
+      RoundUp(coded_size.width(), 2) * RoundUp(coded_size.height(), 2);
   switch (format) {
     case VideoFrame::YV12:
     case VideoFrame::I420: {
-      const size_t rounded_size =
-          RoundUp(coded_size.width(), 2) * RoundUp(coded_size.height(), 2);
-      return rounded_size * 3 / 2;
+      switch (plane) {
+        case VideoFrame::kYPlane:
+          return area;
+        case VideoFrame::kUPlane:
+        case VideoFrame::kVPlane:
+          return area / 4;
+        default:
+          break;
+      }
     }
     case VideoFrame::YV12A: {
-      const size_t rounded_size =
-          RoundUp(coded_size.width(), 2) * RoundUp(coded_size.height(), 2);
-      return rounded_size * 5 / 2;
+      switch (plane) {
+        case VideoFrame::kYPlane:
+        case VideoFrame::kAPlane:
+          return area;
+        case VideoFrame::kUPlane:
+        case VideoFrame::kVPlane:
+          return area / 4;
+        default:
+          break;
+      }
     }
     case VideoFrame::YV16: {
-      const size_t rounded_size =
-          RoundUp(coded_size.width(), 2) * RoundUp(coded_size.height(), 2);
-      return rounded_size * 2;
+      switch (plane) {
+        case VideoFrame::kYPlane:
+          return area;
+        case VideoFrame::kUPlane:
+        case VideoFrame::kVPlane:
+          return area / 2;
+        default:
+          break;
+      }
     }
     case VideoFrame::UNKNOWN:
     case VideoFrame::NATIVE_TEXTURE:
     case VideoFrame::HISTOGRAM_MAX:
 #if defined(GOOGLE_TV)
     case VideoFrame::HOLE:
 #endif
       break;
   }
-  NOTREACHED() << "Unsupported video frame format: " << format;
+  NOTREACHED() << "Unsupported video frame format/plane: "
+               << format << "/" << plane;
   return 0;
 }
 
 // Release data allocated by AllocateYUV().
 static void ReleaseData(uint8* data) {
   DCHECK(data);
   base::AlignedFree(data);
 }
 
 void VideoFrame::AllocateYUV() {
@@ skipping 171 matching lines @@
     : mailbox_(mailbox),
       sync_point_(sync_point),
       release_callback_(release_callback) {}
 
 VideoFrame::MailboxHolder::~MailboxHolder() {
   if (!release_callback_.is_null())
     release_callback_.Run(sync_point_);
 }
 
 }  // namespace media