Improve GL shader YUV adjustment.

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 2210 matching lines @@
   float yuv_to_rgb_rec601[9] = {
       1.164f, 1.164f, 1.164f, 0.0f, -.391f, 2.018f, 1.596f, -.813f, 0.0f,
   };
   float yuv_to_rgb_jpeg[9] = {
       1.f, 1.f, 1.f, 0.0f, -.34414f, 1.772f, 1.402f, -.71414f, 0.0f,
   };
   float yuv_to_rgb_rec709[9] = {
       1.164f, 1.164f, 1.164f, 0.0f, -0.213f, 2.112f, 1.793f, -0.533f, 0.0f,
   };
 
-  // These values map to 16, 128, and 128 respectively, and are computed
-  // as a fraction over 256 (e.g. 16 / 256 = 0.0625).
   // They are used in the YUV to RGBA conversion formula:
   //   Y - 16   : Gives 16 values of head and footroom for overshooting
   //   U - 128  : Turns unsigned U into signed U [-128,127]
   //   V - 128  : Turns unsigned V into signed V [-128,127]
   float yuv_adjust_constrained[3] = {
-      -0.0625f, -0.5f, -0.5f,
+      -16.f, -128.f, -128.f,
   };
 
   // Same as above, but without the head and footroom.
   float yuv_adjust_full[3] = {
-      0.0f, -0.5f, -0.5f,
+      0.0f, -128.f, -128.f,
   };
 
   float* yuv_to_rgb = NULL;
   float* yuv_adjust = NULL;
 
   switch (quad->color_space) {
     case YUVVideoDrawQuad::REC_601:
       yuv_to_rgb = yuv_to_rgb_rec601;
       yuv_adjust = yuv_adjust_constrained;
       break;
     case YUVVideoDrawQuad::REC_709:
       yuv_to_rgb = yuv_to_rgb_rec709;
       yuv_adjust = yuv_adjust_constrained;
       break;
     case YUVVideoDrawQuad::JPEG:
       yuv_to_rgb = yuv_to_rgb_jpeg;
       yuv_adjust = yuv_adjust_full;
       break;
   }
 
   float yuv_to_rgb_multiplied[9];
   float yuv_adjust_with_offset[3];
 
+  // Formula according to BT.601-7 section 2.5.3.
+  DCHECK_LE(8u, quad->bits_per_channel);
+  DCHECK_LE(quad->bits_per_channel, 24u);

[dcheng, 2016/07/30 01:26:37]

Would it be possible to do this check in ParamTraits / StructTraits.
Technically, I think that shifting by more than the width of the type on the LHS
is undefined behavior.

+  float adjustment_multiplier = (1 << (quad->bits_per_channel - 8)) * 1.0f /
+                                ((1 << quad->bits_per_channel) - 1);
+
   for (int i = 0; i < 9; ++i)
     yuv_to_rgb_multiplied[i] = yuv_to_rgb[i] * quad->resource_multiplier;
 
-  for (int i = 0; i < 3; ++i)
+  for (int i = 0; i < 3; ++i) {
     yuv_adjust_with_offset[i] =
-        yuv_adjust[i] / quad->resource_multiplier - quad->resource_offset;
+        yuv_adjust[i] * adjustment_multiplier / quad->resource_multiplier -
+        quad->resource_offset;
+  }
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   auto tile_rect = gfx::RectF(quad->rect);
   gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb_multiplied);
   gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust_with_offset);
 
   SetShaderOpacity(quad->shared_quad_state->opacity, alpha_location);
@@ skipping 1494 matching lines @@
         resource_provider_, contents_texture->id()));
     source_texture = source->texture_id();
   }
   gl_->CopySubTextureCHROMIUM(source_texture, destination.texture_id(), 0, 0, 0,
                               0, contents_texture->size().width(),
                               contents_texture->size().height(), GL_TRUE,
                               GL_FALSE, GL_FALSE);
 }
 
 }  // namespace cc