Refactored YUV test.

client/deps/glbench/src/yuv2rgb_1.glslf

 /*
  * Copyright 2010, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 36 matching lines @@
  */
 uniform float imageWidth;
 uniform float imageHeight;
 
 /*
  * This is the texture sampler where the greyscale Y'UV420p image is
  * accessed.
  */
 uniform sampler2D textureSampler;
 
+#if defined (USE_UNIFORM_MATRIX)
+uniform mat4 conversion;
+#endif
+
 varying vec4 v1;
 
 /**
  * This fetches an individual Y pixel from the image, given the current
  * texture coordinates (which range from 0 to 1 on the source texture
  * image).  They are mapped to the portion of the image that contains
  * the Y component.
  *
  * @param position This is the position of the main image that we're
  *        trying to render, in parametric coordinates.
  */
 float getYPixel(vec2 position) {
-  position.y = position.y * 2.0 / 3.0 + 1.0 / 3.0;
+  position.y = 1. - (position.y * 2.0 / 3.0 + 1.0 / 3.0);
   return texture2D(textureSampler, position).x;
 }
 
 /**
  * This does the crazy work of calculating the planar position (the
  * position in the byte stream of the image) of the U or V pixel, and
  * then converting that back to x and y coordinates, so that we can
  * account for the fact that V is appended to U in the image, and the
  * complications that causes (see below for a diagram).
  *
  * @param position This is the position of the main image that we're
  *        trying to render, in pixels.
  *
  * @param planarOffset This is an offset to add to the planar address
  *        we calculate so that we can find the U image after the V
  *        image.
  */
 vec2 mapCommon(vec2 position, float planarOffset) {
   planarOffset += imageWidth * floor(position.y / 2.0) / 2.0 +
                   floor((imageWidth - 1.0 - position.x) / 2.0);
   float x = floor(imageWidth - 1.0 - floor(mod(planarOffset, imageWidth)));
   float y = floor(planarOffset / imageWidth);
-  return vec2((x + 0.5) / imageWidth, (y + 0.5) / (1.5 * imageHeight));
+  return vec2((x + 0.5) / imageWidth, 1. - (y + 0.5) / (1.5 * imageHeight));
 }
 
 /**
  * This is a helper function for mapping pixel locations to a texture
  * coordinate for the U plane.
  *
  * @param position This is the position of the main image that we're
  *        trying to render, in pixels.
  */
 vec2 mapU(vec2 position) {
@@ skipping 99 matching lines @@
    */
   float uChannel = texture2D(textureSampler, mapU(pixelPosition)).x;
   float vChannel = texture2D(textureSampler, mapV(pixelPosition)).x;
 
   /*
    * This does the colorspace conversion from Y'UV to RGB as a matrix
    * multiply.  It also does the offset of the U and V channels from
    * [0,1] to [-.5,.5] as part of the transform.
    */
   vec4 channels = vec4(yChannel, uChannel, vChannel, 1.0);
+#if !defined(USE_UNIFORM_MATRIX)
   mat4 conversion = mat4( 1.0,    1.0,    1.0,   0.0,
                           0.0,   -0.344,  1.772, 0.0,
                           1.402, -0.714,  0.0,   0.0,
                          -0.701,  0.529, -0.886, 1.0);
+#endif
 
   gl_FragColor = conversion * channels;
 }