Support videos with JPEG color range in GPU YUV convert path.

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 1759 matching lines @@
                      quad->tex_coord_rect.y()));
   GLC(gl_, gl_->Uniform1i(y_texture_location, 1));
   GLC(gl_, gl_->Uniform1i(u_texture_location, 2));
   GLC(gl_, gl_->Uniform1i(v_texture_location, 3));
   if (use_alpha_plane)
     GLC(gl_, gl_->Uniform1i(a_texture_location, 4));
 
   // These values are magic numbers that are used in the transformation from YUV
   // to RGB color values.  They are taken from the following webpage:
   // http://www.fourcc.org/fccyvrgb.php
-  float yuv_to_rgb[9] = {1.164f, 1.164f, 1.164f, 0.0f, -.391f,
-                         2.018f, 1.596f, -.813f, 0.0f, };
-  GLC(gl_, gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb));
+  float yuv_to_rgb_rec601[9] = {

[rileya (GONE FROM CHROMIUM), 2014/05/01 23:25:09]

Is there a header these might be better off being moved to?

[piman, 2014/05/02 00:37:28]

I don't think one exists. We could create one, possibly in a follow-up.

+      1.164f, 1.164f, 1.164f, 0.0f, -.391f, 2.018f, 1.596f, -.813f, 0.0f,
+  };
+  float yuv_to_rgb_rec601_jpeg[9] = {
+      1.f, 1.f, 1.f, 0.0f, -.34414f, 1.772f, 1.402f, -.71414, 0.0f,

[fbarchard, 2014/05/02 02:39:29]

FYI I found fourcc sometimes inconsistent with other sources of format
conversion - in this case i would trust the jpeg source code more.  I dont have
that handy, so here is what Intel IPP says, and it matches your code:
Y = 0.299*R + 0.587*G + 0.114*B
Cb = -0.16874*R - 0.33126*G + 0.5*B + 128
Cr = 0.5*R - 0.41869*G - 0.08131*B + 128
R = Y + 1.402*Cr - 179,456
G = Y - 0.34414*Cb - 0.71414*Cr + 135.45984
B = Y + 1.772*Cb - 226.816

+  };
 
   // 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[3] = {-0.0625f, -0.5f, -0.5f, };
+  float yuv_adjust_rec601[3] = {
+      -0.0625f, -0.5f, -0.5f,
+  };
+
+  // Same as above, but without the head and footroom.
+  float yuv_adjust_rec601_jpeg[3] = {
+      0.0f, -0.5f, -0.5f,
+  };
+
+  float* yuv_to_rgb;
+  float* yuv_adjust;

[piman, 2014/05/02 00:37:28]

nit: initialize both.

+
+  switch (quad->color_space) {
+    case YUVVideoDrawQuad::kRec601:
+      yuv_to_rgb = yuv_to_rgb_rec601;
+      yuv_adjust = yuv_adjust_rec601;
+      break;
+    case YUVVideoDrawQuad::kRec601_Jpeg:
+      yuv_to_rgb = yuv_to_rgb_rec601_jpeg;
+      yuv_adjust = yuv_adjust_rec601_jpeg;
+      break;
+    default:

[piman, 2014/05/02 00:37:28]

nit: skip the default case, relying instead on compiler warnings, so that if one
adds an enum case they'll know they need to change this code.

+      NOTREACHED();
+  }
+
+  GLC(gl_, gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb));
   GLC(gl_, gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust));
 
   SetShaderOpacity(quad->opacity(), alpha_location);
   DrawQuadGeometry(frame, quad->quadTransform(), quad->rect, matrix_location);
 }
 
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                      const StreamVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
@@ skipping 1394 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc