media/gpu/v4l2: pass Fourcc to Create(GL|EGL)Image

Use the Fourcc class instead of uin32_t with the GL/EGL image creation
methods. This simplifies their logic a bit.

BUG=None
TEST=Video plays properly on Hana and Kevin non-VD.

Change-Id: I50ae21d1ce34d3dba4c08bb59887d5f208b41a28
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1982348Reviewed-by: Hirokazu Honda <hiroh@chromium.org>
Commit-Queue: Alexandre Courbot <acourbot@chromium.org>
Cr-Commit-Position: refs/heads/master@{#728443}

media/gpu/v4l2/generic_v4l2_device.cc

@@ -195,7 +195,7 @@ std::vector<base::ScopedFD> GenericV4L2Device::GetDmabufsForV4L2Buffer(
   return dmabuf_fds;
 }
 
-bool GenericV4L2Device::CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) {
+bool GenericV4L2Device::CanCreateEGLImageFrom(const Fourcc fourcc) {
   static uint32_t kEGLImageDrmFmtsSupported[] = {
     DRM_FORMAT_ARGB8888,
 #if defined(ARCH_CPU_ARM_FAMILY)
@@ -207,7 +207,7 @@ bool GenericV4L2Device::CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) {
   return std::find(
              kEGLImageDrmFmtsSupported,
              kEGLImageDrmFmtsSupported + base::size(kEGLImageDrmFmtsSupported),
-             V4L2PixFmtToDrmFormat(v4l2_pixfmt)) !=
+             V4L2PixFmtToDrmFormat(fourcc.ToV4L2PixFmt())) !=
          kEGLImageDrmFmtsSupported + base::size(kEGLImageDrmFmtsSupported);
 }
 
@@ -217,20 +217,16 @@ EGLImageKHR GenericV4L2Device::CreateEGLImage(
     GLuint texture_id,
     const gfx::Size& size,
     unsigned int buffer_index,
-    uint32_t v4l2_pixfmt,
+    const Fourcc fourcc,
     std::vector<base::ScopedFD>&& dmabuf_fds) {
   DVLOGF(3);
-  if (!CanCreateEGLImageFrom(v4l2_pixfmt)) {
+
+  if (!CanCreateEGLImageFrom(fourcc)) {
     VLOGF(1) << "Unsupported V4L2 pixel format";
     return EGL_NO_IMAGE_KHR;
   }
 
-  const auto vf_format_fourcc = Fourcc::FromV4L2PixFmt(v4l2_pixfmt);
-  if (!vf_format_fourcc) {
-    VLOGF(1) << "Unrecognized pixel format " << FourccToString(v4l2_pixfmt);
-    return EGL_NO_IMAGE_KHR;
-  }
-  const VideoPixelFormat vf_format = vf_format_fourcc->ToVideoPixelFormat();
+  const VideoPixelFormat vf_format = fourcc.ToVideoPixelFormat();
   // Number of components, as opposed to the number of V4L2 planes, which is
   // just a buffer count.
   size_t num_planes = VideoFrame::NumPlanes(vf_format);
@@ -248,7 +244,7 @@ EGLImageKHR GenericV4L2Device::CreateEGLImage(
   attrs.push_back(EGL_HEIGHT);
   attrs.push_back(size.height());
   attrs.push_back(EGL_LINUX_DRM_FOURCC_EXT);
-  attrs.push_back(V4L2PixFmtToDrmFormat(v4l2_pixfmt));
+  attrs.push_back(V4L2PixFmtToDrmFormat(fourcc.ToV4L2PixFmt()));
 
   // For existing formats, if we have less buffers (V4L2 planes) than
   // components (planes), the remaining planes are stored in the last
@@ -290,16 +286,12 @@ EGLImageKHR GenericV4L2Device::CreateEGLImage(
 
 scoped_refptr<gl::GLImage> GenericV4L2Device::CreateGLImage(
     const gfx::Size& size,
-    uint32_t fourcc,
+    const Fourcc fourcc,
     std::vector<base::ScopedFD>&& dmabuf_fds) {
   DVLOGF(3);
   DCHECK(CanCreateEGLImageFrom(fourcc));
-  const auto vf_format_fourcc = Fourcc::FromV4L2PixFmt(fourcc);
-  if (!vf_format_fourcc) {
-    VLOGF(1) << "Unrecognized pixel format " << FourccToString(fourcc);
-    return nullptr;
-  }
-  const VideoPixelFormat vf_format = vf_format_fourcc->ToVideoPixelFormat();
+
+  const VideoPixelFormat vf_format = fourcc.ToVideoPixelFormat();
   size_t num_planes = VideoFrame::NumPlanes(vf_format);
   DCHECK_LE(num_planes, 3u);
   DCHECK_LE(dmabuf_fds.size(), num_planes);
@@ -344,7 +336,7 @@ scoped_refptr<gl::GLImage> GenericV4L2Device::CreateGLImage(
   }
 
   gfx::BufferFormat buffer_format = gfx::BufferFormat::BGRA_8888;
-  switch (fourcc) {
+  switch (fourcc.ToV4L2PixFmt()) {
     case DRM_FORMAT_ARGB8888:
       buffer_format = gfx::BufferFormat::BGRA_8888;
       break;

media/gpu/v4l2/generic_v4l2_device.h

@@ -43,18 +43,18 @@ class GenericV4L2Device : public V4L2Device {
       size_t num_planes,
       enum v4l2_buf_type buf_type) override;
 
-  bool CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) override;
+  bool CanCreateEGLImageFrom(const Fourcc fourcc) override;
   EGLImageKHR CreateEGLImage(EGLDisplay egl_display,
                              EGLContext egl_context,
                              GLuint texture_id,
                              const gfx::Size& size,
                              unsigned int buffer_index,
-                             uint32_t v4l2_pixfmt,
+                             const Fourcc fourcc,
                              std::vector<base::ScopedFD>&& dmabuf_fds) override;
 
   scoped_refptr<gl::GLImage> CreateGLImage(
       const gfx::Size& size,
-      uint32_t fourcc,
+      const Fourcc fourcc,
       std::vector<base::ScopedFD>&& dmabuf_fds) override;
 
   EGLBoolean DestroyEGLImage(EGLDisplay egl_display,

media/gpu/v4l2/tegra_v4l2_device.cc

@@ -216,8 +216,8 @@ std::vector<base::ScopedFD> TegraV4L2Device::GetDmabufsForV4L2Buffer(
   return dmabuf_fds;
 }
 
-bool TegraV4L2Device::CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) {
-  return v4l2_pixfmt == V4L2_PIX_FMT_NV12M;
+bool TegraV4L2Device::CanCreateEGLImageFrom(const Fourcc fourcc) {
+  return fourcc.ToV4L2PixFmt() == V4L2_PIX_FMT_NV12M;
 }
 
 EGLImageKHR TegraV4L2Device::CreateEGLImage(
@@ -226,10 +226,11 @@ EGLImageKHR TegraV4L2Device::CreateEGLImage(
     GLuint texture_id,
     const gfx::Size& /* size */,
     unsigned int buffer_index,
-    uint32_t v4l2_pixfmt,
+    const Fourcc fourcc,
     std::vector<base::ScopedFD>&& /* dmabuf_fds */) {
   DVLOGF(3);
-  if (!CanCreateEGLImageFrom(v4l2_pixfmt)) {
+
+  if (!CanCreateEGLImageFrom(fourcc)) {
     LOG(ERROR) << "Unsupported V4L2 pixel format";
     return EGL_NO_IMAGE_KHR;
   }
@@ -251,7 +252,7 @@ EGLImageKHR TegraV4L2Device::CreateEGLImage(
 }
 scoped_refptr<gl::GLImage> TegraV4L2Device::CreateGLImage(
     const gfx::Size& size,
-    uint32_t fourcc,
+    const Fourcc fourcc,
     std::vector<base::ScopedFD>&& dmabuf_fds) {
   NOTREACHED();
   return nullptr;

media/gpu/v4l2/tegra_v4l2_device.h

@@ -43,17 +43,17 @@ class TegraV4L2Device : public V4L2Device {
       int index,
       size_t num_planes,
       enum v4l2_buf_type buf_type) override;
-  bool CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) override;
+  bool CanCreateEGLImageFrom(const Fourcc fourcc) override;
   EGLImageKHR CreateEGLImage(EGLDisplay egl_display,
                              EGLContext egl_context,
                              GLuint texture_id,
                              const gfx::Size& size,
                              unsigned int buffer_index,
-                             uint32_t v4l2_pixfmt,
+                             const Fourcc fourcc,
                              std::vector<base::ScopedFD>&& dmabuf_fds) override;
   scoped_refptr<gl::GLImage> CreateGLImage(
       const gfx::Size& size,
-      uint32_t fourcc,
+      const Fourcc fourcc,
       std::vector<base::ScopedFD>&& dmabuf_fds) override;
   EGLBoolean DestroyEGLImage(EGLDisplay egl_display,
                              EGLImageKHR egl_image) override;

media/gpu/v4l2/v4l2_device.h

@@ -26,6 +26,7 @@
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_frame_layout.h"
+#include "media/gpu/chromeos/fourcc.h"
 #include "media/gpu/media_gpu_export.h"
 #include "media/gpu/v4l2/v4l2_device_poller.h"
 #include "media/video/video_decode_accelerator.h"
@@ -593,7 +594,7 @@ class MEDIA_GPU_EXPORT V4L2Device
 
   // Return true if the given V4L2 pixfmt can be used in CreateEGLImage()
   // for the current platform.
-  virtual bool CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) = 0;
+  virtual bool CanCreateEGLImageFrom(const Fourcc fourcc) = 0;
 
   // Create an EGLImage from provided |dmabuf_fds| and bind |texture_id| to it.
   // Some implementations may also require the V4L2 |buffer_index| of the buffer
@@ -608,7 +609,7 @@ class MEDIA_GPU_EXPORT V4L2Device
       GLuint texture_id,
       const gfx::Size& size,
       unsigned int buffer_index,
-      uint32_t v4l2_pixfmt,
+      const Fourcc fourcc,
       std::vector<base::ScopedFD>&& dmabuf_fds) = 0;
 
   // Create a GLImage from provided |dmabuf_fds|.
@@ -618,7 +619,7 @@ class MEDIA_GPU_EXPORT V4L2Device
   // Return the newly created GLImage.
   virtual scoped_refptr<gl::GLImage> CreateGLImage(
       const gfx::Size& size,
-      uint32_t fourcc,
+      const Fourcc fourcc,
       std::vector<base::ScopedFD>&& dmabuf_fds) = 0;
 
   // Destroys the EGLImageKHR.

media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc

@@ -495,8 +495,9 @@ bool V4L2SliceVideoDecodeAccelerator::SetupFormats() {
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   output_format_fourcc_ = base::nullopt;
   while (device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
-    if (device_->CanCreateEGLImageFrom(fmtdesc.pixelformat)) {
-      output_format_fourcc_ = Fourcc::FromV4L2PixFmt(fmtdesc.pixelformat);
+    auto fourcc = Fourcc::FromV4L2PixFmt(fmtdesc.pixelformat);
+    if (fourcc && device_->CanCreateEGLImageFrom(*fourcc)) {
+      output_format_fourcc_ = fourcc;
       break;
     }
     ++fmtdesc.index;
@@ -1471,8 +1472,8 @@ void V4L2SliceVideoDecodeAccelerator::CreateGLImageFor(
     return;
   }
 
-  scoped_refptr<gl::GLImage> gl_image = gl_image_device_->CreateGLImage(
-      size, fourcc.ToV4L2PixFmt(), std::move(dmabuf_fds));
+  scoped_refptr<gl::GLImage> gl_image =
+      gl_image_device_->CreateGLImage(size, fourcc, std::move(dmabuf_fds));
   if (!gl_image) {
     VLOGF(1) << "Could not create GLImage,"
              << " index=" << buffer_index << " texture_id=" << texture_id;

media/gpu/v4l2/v4l2_vda_helpers.cc

@@ -53,9 +53,10 @@ base::Optional<Fourcc> FindImageProcessorOutputFormat(V4L2Device* ip_device) {
             preferred_formats_first);
 
   for (uint32_t processor_output_format : processor_output_formats) {
-    if (ip_device->CanCreateEGLImageFrom(processor_output_format)) {
+    auto fourcc = Fourcc::FromV4L2PixFmt(processor_output_format);
+    if (fourcc && ip_device->CanCreateEGLImageFrom(*fourcc)) {
       DVLOGF(3) << "Image processor output format=" << processor_output_format;
-      return Fourcc::FromV4L2PixFmt(processor_output_format);
+      return fourcc;
     }
   }
 

media/gpu/v4l2/v4l2_video_decode_accelerator.cc

@@ -484,7 +484,7 @@ void V4L2VideoDecodeAccelerator::CreateEGLImageFor(
 
   EGLImageKHR egl_image = egl_image_device_->CreateEGLImage(
       egl_display_, gl_context->GetHandle(), texture_id, size, buffer_index,
-      fourcc.ToV4L2PixFmt(), std::move(dmabuf_fds));
+      fourcc, std::move(dmabuf_fds));
   if (egl_image == EGL_NO_IMAGE_KHR) {
     VLOGF(1) << "could not create EGLImageKHR,"
              << " index=" << buffer_index << " texture_id=" << texture_id;
@@ -2325,8 +2325,9 @@ bool V4L2VideoDecodeAccelerator::SetupFormats() {
   memset(&fmtdesc, 0, sizeof(fmtdesc));
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   while (device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
-    if (device_->CanCreateEGLImageFrom(fmtdesc.pixelformat)) {
-      output_format_fourcc_ = Fourcc::FromV4L2PixFmt(fmtdesc.pixelformat);
+    auto fourcc = Fourcc::FromV4L2PixFmt(fmtdesc.pixelformat);
+    if (fourcc && device_->CanCreateEGLImageFrom(*fourcc)) {
+      output_format_fourcc_ = *fourcc;
       break;
     }
     ++fmtdesc.index;