V4L2VDA: Generalize EGLImage import and query driver for output formats.

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 49 matching lines @@
         case VideoFrame::I420:
         case VideoFrame::YV12A:
         case VideoFrame::NV12:
           return gfx::Size(2, 2);
 
         case VideoFrame::UNKNOWN:
 #if defined(VIDEO_HOLE)
         case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
         case VideoFrame::NATIVE_TEXTURE:
+        case VideoFrame::ARGB:
           break;
       }
   }
   NOTREACHED();
   return gfx::Size();
 }
 
 // Return the alignment for the whole frame, calculated as the max of the
 // alignment for each individual plane.
 static gfx::Size CommonAlignment(VideoFrame::Format format) {
   int max_sample_width = 0;
   int max_sample_height = 0;
   for (size_t plane = 0; plane < VideoFrame::NumPlanes(format); ++plane) {
     const gfx::Size sample_size = SampleSize(format, plane);
     max_sample_width = std::max(max_sample_width, sample_size.width());
     max_sample_height = std::max(max_sample_height, sample_size.height());
   }
   return gfx::Size(max_sample_width, max_sample_height);
 }
 
 // Returns the number of bytes per element for given |plane| and |format|. E.g.
 // 2 for the UV plane in NV12.
 static int BytesPerElement(VideoFrame::Format format, size_t plane) {
   DCHECK(VideoFrame::IsValidPlane(plane, format));
-  return (format == VideoFrame::NV12 && plane == VideoFrame::kUVPlane) ? 2 : 1;
+  if (format == VideoFrame::ARGB)
+    return 4;
+  else if (format == VideoFrame::NV12 && plane == VideoFrame::kUVPlane)
+    return 2;
+  else
+    return 1;
 }
 
 // Rounds up |coded_size| if necessary for |format|.
 static gfx::Size AdjustCodedSize(VideoFrame::Format format,
                                  const gfx::Size& coded_size) {
   const gfx::Size alignment = CommonAlignment(format);
   return gfx::Size(RoundUp(coded_size.width(), alignment.width()),
                    RoundUp(coded_size.height(), alignment.height()));
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateFrame(
     VideoFrame::Format format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     base::TimeDelta timestamp) {
-  DCHECK(format != VideoFrame::UNKNOWN &&
-         format != VideoFrame::NV12 &&
-         format != VideoFrame::NATIVE_TEXTURE);
+  switch (format) {
+    case VideoFrame::UNKNOWN:
+    case VideoFrame::NV12:
+    case VideoFrame::NATIVE_TEXTURE:
 #if defined(VIDEO_HOLE)
-  DCHECK(format != VideoFrame::HOLE);
+    case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
+    case VideoFrame::ARGB:
+      NOTIMPLEMENTED();
+      return nullptr;
+    default:
+      break;
+  }
 
   // Since we're creating a new YUV frame (and allocating memory for it
   // ourselves), we can pad the requested |coded_size| if necessary if the
   // request does not line up on sample boundaries.
   const gfx::Size new_coded_size = AdjustCodedSize(format, coded_size);
   DCHECK(IsValidConfig(format, new_coded_size, visible_rect, natural_size));
 
   scoped_refptr<VideoFrame> frame(
       new VideoFrame(format,
                      new_coded_size,
@@ skipping 24 matching lines @@
       return "HOLE";
 #endif  // defined(VIDEO_HOLE)
     case VideoFrame::YV12A:
       return "YV12A";
     case VideoFrame::YV12J:
       return "YV12J";
     case VideoFrame::NV12:
       return "NV12";
     case VideoFrame::YV24:
       return "YV24";
+    case VideoFrame::ARGB:
+      return "ARGB";
   }
   NOTREACHED() << "Invalid videoframe format provided: " << format;
   return "";
 }
 
 // static
 bool VideoFrame::IsValidConfig(VideoFrame::Format format,
                                const gfx::Size& coded_size,
                                const gfx::Rect& visible_rect,
                                const gfx::Size& natural_size) {
@@ skipping 23 matching lines @@
 #endif  // defined(VIDEO_HOLE)
       return true;
 
     case VideoFrame::YV24:
     case VideoFrame::YV12:
     case VideoFrame::YV12J:
     case VideoFrame::I420:
     case VideoFrame::YV12A:
     case VideoFrame::NV12:
     case VideoFrame::YV16:
+    case VideoFrame::ARGB:
       // Check that software-allocated buffer formats are aligned correctly and
       // not empty.
       const gfx::Size alignment = CommonAlignment(format);
       return RoundUp(visible_rect.right(), alignment.width()) <=
                  static_cast<size_t>(coded_size.width()) &&
              RoundUp(visible_rect.bottom(), alignment.height()) <=
                  static_cast<size_t>(coded_size.height()) &&
              !coded_size.IsEmpty() && !visible_rect.IsEmpty() &&
              !natural_size.IsEmpty();
   }
@@ skipping 82 matching lines @@
     Format format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     const std::vector<int> dmabuf_fds,
     base::TimeDelta timestamp,
     const base::Closure& no_longer_needed_cb) {
   if (!IsValidConfig(format, coded_size, visible_rect, natural_size))
     return NULL;
 
+  // TODO(posciak): This is not exactly correct, it's possible for one
+  // buffer to contain more than one plane.
   if (dmabuf_fds.size() != NumPlanes(format)) {
     LOG(FATAL) << "Not enough dmabuf fds provided!";
     return NULL;
   }
 
   scoped_refptr<VideoFrame> frame(
       new VideoFrame(format,
                      coded_size,
                      visible_rect,
                      natural_size,
@@ skipping 198 matching lines @@
 #endif  // defined(VIDEO_HOLE)
 
 // static
 size_t VideoFrame::NumPlanes(Format format) {
   switch (format) {
     case VideoFrame::NATIVE_TEXTURE:
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
       return 0;
+    case VideoFrame::ARGB:
+      return 1;
     case VideoFrame::NV12:
       return 2;
     case VideoFrame::YV12:
     case VideoFrame::YV16:
     case VideoFrame::I420:
     case VideoFrame::YV12J:
     case VideoFrame::YV24:
       return 3;
     case VideoFrame::YV12A:
       return 4;
@@ skipping 12 matching lines @@
     total += PlaneAllocationSize(format, i, coded_size);
   return total;
 }
 
 // static
 gfx::Size VideoFrame::PlaneSize(Format format,
                                 size_t plane,
                                 const gfx::Size& coded_size) {
   DCHECK(IsValidPlane(plane, format));
 
-  // Align to multiple-of-two size overall. This ensures that non-subsampled
-  // planes can be addressed by pixel with the same scaling as the subsampled
-  // planes.
-  const int width = RoundUp(coded_size.width(), 2);
-  const int height = RoundUp(coded_size.height(), 2);
+  int width = RoundUp(coded_size.width(), 2);

[kcwu, 2015/01/06 08:28:52]

Looks like you want to round up conditionally. Did you mean
int width = coded_size.width(); ?

[Pawel Osciak, 2015/01/06 13:09:58]

Done.

+  int height = RoundUp(coded_size.height(), 2);
+  if (format != VideoFrame::ARGB) {
+    // Align to multiple-of-two size overall. This ensures that non-subsampled
+    // planes can be addressed by pixel with the same scaling as the subsampled
+    // planes.
+    width = RoundUp(width, 2);
+    height = RoundUp(height, 2);
+  }
 
   const gfx::Size subsample = SampleSize(format, plane);
   DCHECK(width % subsample.width() == 0);
   DCHECK(height % subsample.height() == 0);
   return gfx::Size(BytesPerElement(format, plane) * width / subsample.width(),
                    height / subsample.height());
 }
 
 size_t VideoFrame::PlaneAllocationSize(Format format,
                                        size_t plane,
                                        const gfx::Size& coded_size) {
-  // VideoFrame formats are (so far) all YUV and 1 byte per sample.
   return PlaneSize(format, plane, coded_size).GetArea();
 }
 
 // static
 int VideoFrame::PlaneHorizontalBitsPerPixel(Format format, size_t plane) {
   DCHECK(IsValidPlane(plane, format));
   const int bits_per_element = 8 * BytesPerElement(format, plane);
-  const int pixels_per_element = SampleSize(format, plane).width();
-  DCHECK(bits_per_element % pixels_per_element == 0);
-  return bits_per_element / pixels_per_element;
+  const int horiz_pixels_per_element = SampleSize(format, plane).width();
+  DCHECK_EQ(bits_per_element % horiz_pixels_per_element, 0);
+  return bits_per_element / horiz_pixels_per_element;
 }
 
 // static
 int VideoFrame::PlaneBitsPerPixel(Format format, size_t plane) {
   DCHECK(IsValidPlane(plane, format));
   return PlaneHorizontalBitsPerPixel(format, plane) /
       SampleSize(format, plane).height();
 }
 
 // Release data allocated by AllocateYUV().
@@ skipping 184 matching lines @@
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane) {
     for (int row = 0; row < rows(plane); ++row) {
       base::MD5Update(context, base::StringPiece(
           reinterpret_cast<char*>(data(plane) + stride(plane) * row),
           row_bytes(plane)));
     }
   }
 }
 
 }  // namespace media