ozone: prefer YUYV format for overlay.

ui/ozone/platform/drm/gpu/drm_overlay_validator.cc

 // Copyright 2015 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 "ui/ozone/platform/drm/gpu/drm_overlay_validator.h"
 
 #include <drm_fourcc.h>
 
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
 #include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
 
 namespace ui {
 
 namespace {
 
 const size_t kMaxCacheSize = 200;
 
 bool NeedsAlphaComposition(uint32_t format) {
   switch (format) {
     case DRM_FORMAT_XRGB8888:
     case DRM_FORMAT_UYVY:
+    case DRM_FORMAT_YUYV:
       return false;
     default:
       return true;
   }
 }
 
 scoped_refptr<ScanoutBuffer> GetBufferForPageFlipTest(
     const scoped_refptr<DrmDevice>& drm_device,
     const gfx::Size& size,
     uint32_t format,
@@ skipping 19 matching lines @@
                         const gfx::RectF crop_rect) {
   if (!crop_rect.IsEmpty()) {
     return gfx::ToCeiledSize(
         gfx::SizeF(display_rect.width() / crop_rect.width(),
                    display_rect.height() / crop_rect.height()));
   }
 
   return original_size;
 }
 
 uint32_t FindOptimalBufferFormat(uint32_t original_format,

[Daniele Castagna, 2017/02/27 23:10:55]

Is any device actually using this code path?
I think this code is exercised only in unit tests.

IIUC this was intended to be used for a late buffer conversion just before page
flipping.
DS, you told me we didn't want this anymore, right?

[dshwang, 2017/02/28 02:14:28]

This code is used by both legacy page flip and nuclear page flip. see
DrmOverlayValidator::TestPageFlip()

[Daniele Castagna, 2017/02/28 02:56:08]

We're not using overlays on Intel ATM. So, this is not exercised, please correct
me if I'm wrong.

Doesn't Intel Kaby Lake support scaling on primary plane? Why do we need some
special code with a late conversion?

[dshwang, 2017/02/28 04:01:59]

Correct. production code never use it.

To test this code by chrome, additional commend line is needed
 * atomic mode setting: --enable-hardware-overlays --enable-drm-atomic
 * legacy mode setting: --enable-hardware-overlays
Yes, Kaby Lake and ApolloLake support scaling on primary plane on upstream
kernel. Intel integration team is cherry-picking relevant patches to chromeos
v4.4. As nuclear page flip is available on (near-future) v4.4, we will enable it
from ApolloLake and Kaby Lake. Skylake can support it by hardware tho.

Current code includes many experiments. If we want to remain only production
code for ApolloLake or newer, FindOptimalBufferFormat() as well as the special
code can be removed.

By the way, could you share ARM chromeos status? ARM can support native scaling
and doesn't need this code?

                                  uint32_t plane_z_order,
                                  const gfx::Rect& plane_bounds,
                                  const gfx::Rect& window_bounds,
                                  HardwareDisplayController* controller) {
   uint32_t z_order = plane_z_order;
   // If Overlay completely covers primary and isn't transparent, try to find
   // optimal format w.r.t primary plane. This guarantees that optimal format
   // would not fail page flip when plane manager/CC collapses planes.
   if (plane_bounds == window_bounds &&
       !NeedsAlphaComposition(original_format)) {
     z_order = 0;
   }
 
   // YUV is preferable format if supported.
-  if (controller->IsFormatSupported(DRM_FORMAT_UYVY, z_order)) {
-    return DRM_FORMAT_UYVY;
+  if (controller->IsFormatSupported(DRM_FORMAT_YUYV, z_order)) {
+    return DRM_FORMAT_YUYV;
   } else if (controller->IsFormatSupported(DRM_FORMAT_XRGB8888, z_order)) {
     return DRM_FORMAT_XRGB8888;
   }
 
   return original_format;
 }
 
 }  // namespace
 
 DrmOverlayValidator::OverlayHints::OverlayHints(uint32_t format,
@@ skipping 48 matching lines @@
                        overlay.display_rect, overlay.crop_rect);
     test_list.push_back(plane);
 
     if (controller->TestPageFlip(test_list)) {
       overlay.is_overlay_candidate = true;
 
       // If size scaling is needed, find an optimal format.
       if (overlay.plane_z_order && scaled_buffer_size != overlay.buffer_size) {
         uint32_t optimal_format = FindOptimalBufferFormat(
             original_format, overlay.plane_z_order, overlay.display_rect,
             window_->bounds(), controller);

[dshwang, 2017/02/28 02:14:28]

When display size and video size are different, we need late buffer conversion.
The format conversion happens only if size conversion is needed.

Note: I'll add native scaler support soon, which scaling by display controller.
After that, this code path will remain for only legacy page flip.

 
         if (original_format != optimal_format) {
           OverlayPlane original_plain = test_list.back();
           test_list.pop_back();
           scoped_refptr<ScanoutBuffer> optimal_buffer =
               GetBufferForPageFlipTest(drm, scaled_buffer_size, optimal_format,
                                        buffer_generator_, &reusable_buffers);
           DCHECK(optimal_buffer);
 
           OverlayPlane optimal_plane(optimal_buffer, overlay.plane_z_order,
@@ skipping 101 matching lines @@
 
     // Make sure we dont hold reference to buffer when caching this plane list.
     plane.buffer = nullptr;
   }
 
   DCHECK(hints_plane_list.size() == overlay_hints.size());
   overlay_hints_cache_.Put(hints_plane_list, overlay_hints);
 }
 
 }  // namespace ui