media: replace LUMINANCE_F16 by RG_88 for 9/10-bit h264 videos

cc/output/shader.cc

 // Copyright 2011 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/shader.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 2005 matching lines @@
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       uv_texture_location_(-1),
       a_texture_location_(-1),
       lut_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1),
+      ya_size_location_(-1),
+      uv_size_location_(-1),
       ya_clamp_rect_location_(-1),
       uv_clamp_rect_location_(-1),
       resource_multiplier_location_(-1),
       resource_offset_location_(-1) {}
 
 void FragmentShaderYUVVideo::SetFeatures(bool use_alpha_texture,
                                          bool use_nv12,
-                                         bool use_color_lut) {
+                                         bool use_color_lut,
+                                         HighbitTexture highbit_texture) {
   use_alpha_texture_ = use_alpha_texture;
   use_nv12_ = use_nv12;
   use_color_lut_ = use_color_lut;
+  highbit_texture_ = highbit_texture;
 }
 
 void FragmentShaderYUVVideo::Init(GLES2Interface* context,
                                   unsigned program,
                                   int* base_uniform_index) {
   static const char* uniforms[] = {
-      "y_texture",
-      "u_texture",
-      "v_texture",
-      "uv_texture",
-      "a_texture",
-      "lut_texture",
-      "resource_multiplier",
-      "resource_offset",
-      "yuv_matrix",
-      "yuv_adj",
-      "alpha",
-      "ya_clamp_rect",
-      "uv_clamp_rect",
+      "y_texture",       "u_texture",     "v_texture",
+      "uv_texture",      "a_texture",     "lut_texture",
+      "yuv_matrix",      "yuv_adj",       "resource_multiplier",
+      "resource_offset", "ya_size",       "uv_size",
+      "alpha",           "ya_clamp_rect", "uv_clamp_rect",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   y_texture_location_ = locations[0];
   if (!use_nv12_) {
     u_texture_location_ = locations[1];
     v_texture_location_ = locations[2];
   } else {
     uv_texture_location_ = locations[3];
   }
   if (use_alpha_texture_) {
     a_texture_location_ = locations[4];
   }
   if (use_color_lut_) {
     lut_texture_location_ = locations[5];
-    resource_multiplier_location_ = locations[6];
-    resource_offset_location_ = locations[7];
   } else {
-    yuv_matrix_location_ = locations[8];
-    yuv_adj_location_ = locations[9];
+    yuv_matrix_location_ = locations[6];
+    yuv_adj_location_ = locations[7];
   }
-  alpha_location_ = locations[10];
-  ya_clamp_rect_location_ = locations[11];
-  uv_clamp_rect_location_ = locations[12];
+  if (highbit_texture_ == HIGHBIT_LUMINANCE_F16) {
+    resource_multiplier_location_ = locations[8];
+    resource_offset_location_ = locations[9];
+  } else if (highbit_texture_ == HIGHBIT_RG88) {
+    resource_multiplier_location_ = locations[8];
+    ya_size_location_ = locations[10];
+    uv_size_location_ = locations[11];
+  }
+  alpha_location_ = locations[12];
+  ya_clamp_rect_location_ = locations[13];
+  uv_clamp_rect_location_ = locations[14];
 }
 
 std::string FragmentShaderYUVVideo::GetShaderString(TexCoordPrecision precision,
                                                     SamplerType sampler) const {
   std::string head = SHADER0([]() {
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_yaTexCoord;
     varying TexCoordPrecision vec2 v_uvTexCoord;
     uniform SamplerType y_texture;
     uniform float alpha;
     uniform vec4 ya_clamp_rect;
     uniform vec4 uv_clamp_rect;
   });
 
   std::string functions = "";
+  if (highbit_texture_ == HIGHBIT_RG88) {
+    head += "  uniform float resource_multiplier;\n";
+    head += "  uniform vec2 ya_size;\n";
+    head += "  uniform vec2 uv_size;\n";
+    functions += SHADER0([]() {
+      float GetFloat(SamplerType sampler, vec2 tex_coord) {
+        vec2 rg = TextureLookup(sampler, tex_coord).xy;
+        return ((rg.g * 256.0) + rg.r) * resource_multiplier;

[hubbe, 2016/10/05 18:03:25]

Instead of multiplying by resource_multiplier here, we can do it after mixing,
which saves a few multiplications. In fact, we can do it in yuv2rgb, same as we
do for half-float textures, and when we're not using a LUT, we can simply
multiply it into the YUV->RGB matrix.

[dshwang, 2016/10/07 12:35:01]

Good point! Done.

+      }
+
+      float RGTextureLookupBilinear(SamplerType sampler, vec2 tex_coord,
+                                    vec2 tex_size) {
+        vec2 snap_tex_coord =
+            (floor(tex_coord * tex_size) + vec2(0.5)) / tex_size;
+        vec2 negativeOffset =
+            -vec2(lessThan(tex_coord, snap_tex_coord)) / tex_size;
+        // |snap_tex_coord| points out middle of texel. e.g. 1.5
+        // |snap_tex_coord| is always less than or equal to |tex_coord|.
+        // When |tex_coord| points 1.6, sample |snap_tex_coord| texel and
+        // |snap_tex_coord| + 1 texel.
+        // When |tex_coord| points 1.4, sample |snap_tex_coord| texel and
+        // |snap_tex_coord| - 1 texel.
+        snap_tex_coord = snap_tex_coord + negativeOffset;
+        vec2 unit_texel = 1.0 / tex_size;
+        float s1 = GetFloat(sampler, snap_tex_coord);
+        float s2 = GetFloat(sampler, snap_tex_coord + vec2(unit_texel.x, 0.));
+        float s3 = GetFloat(sampler, snap_tex_coord + vec2(0., unit_texel.y));
+        float s4 = GetFloat(sampler, snap_tex_coord + unit_texel);
+        vec2 f = fract((tex_coord - snap_tex_coord) * tex_size);
+        return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
+      }
+
+      float GetY(vec2 ya_clamped) {
+        return RGTextureLookupBilinear(y_texture, ya_clamped, ya_size);
+      }
+    });
+  } else {
+    functions += SHADER0([]() {
+      float GetY(vec2 ya_clamped) {
+        return TextureLookup(y_texture, ya_clamped).x;
+      }
+    });
+  }
+
   if (use_nv12_) {
     head += "  uniform SamplerType uv_texture;\n";
     functions += SHADER0([]() {
       vec2 GetUV(vec2 uv_clamped) {
         return TextureLookup(uv_texture, uv_clamped).xy;
       }
     });
   } else {
     head += "  uniform SamplerType u_texture;\n";
     head += "  uniform SamplerType v_texture;\n";
-    functions += SHADER0([]() {
-      vec2 GetUV(vec2 uv_clamped) {
-        return vec2(TextureLookup(u_texture, uv_clamped).x,
-                    TextureLookup(v_texture, uv_clamped).x);
-      }
-    });
+    if (highbit_texture_ == HIGHBIT_RG88) {
+      functions += SHADER0([]() {
+        vec2 GetUV(vec2 uv_clamped) {
+          vec2 uv =
+              vec2(RGTextureLookupBilinear(u_texture, uv_clamped, uv_size),
+                   RGTextureLookupBilinear(v_texture, uv_clamped, uv_size));
+          return uv;
+        }
+      });
+    } else {
+      functions += SHADER0([]() {
+        vec2 GetUV(vec2 uv_clamped) {
+          vec2 uv = vec2(TextureLookup(u_texture, uv_clamped).x,
+                         TextureLookup(v_texture, uv_clamped).x);
+          return uv;
+        }
+      });
+    }
   }
 
   if (use_alpha_texture_) {
     head += "  uniform SamplerType a_texture;\n";
     functions += SHADER0([]() {
       float GetAlpha(vec2 ya_clamped) {
         return alpha * TextureLookup(a_texture, ya_clamped).x;
       }
     });
   } else {
     functions += SHADER0([]() {
       float GetAlpha(vec2 ya_clamped) { return alpha; }
     });
   }
 
   if (use_color_lut_) {
     head += "  uniform sampler2D lut_texture;\n";
-    head += "  uniform float resource_multiplier;\n";
-    head += "  uniform float resource_offset;\n";
     functions += SHADER0([]() {
       vec4 LUT(sampler2D sampler, vec3 pos, float size) {
         pos *= size - 1.0;
         // Select layer
         float layer = min(floor(pos.x), size - 2.0);
         // Compress the yz coordinates so they stay within
         // [0.5 .. 31.5] / 32 (assuming a LUT size of 32^3)
         pos.yz = (pos.yz + vec2(0.5)) / size;
         pos.z = (pos.z + layer) / size;
         return mix(texture2D(sampler, pos.yz),
                    texture2D(sampler, pos.yz + vec2(0, 1.0 / size)),
                    pos.x - layer);
       }
-
-      vec3 yuv2rgb(vec3 yuv) {
-        yuv = (yuv - vec3(resource_offset)) * resource_multiplier;
-        return LUT(lut_texture, yuv, 32.0).xyz;
-      }
     });
+    if (highbit_texture_ == HIGHBIT_LUMINANCE_F16) {
+      head += "  uniform float resource_multiplier;\n";
+      head += "  uniform float resource_offset;\n";
+      functions += SHADER0([]() {
+        vec3 yuv2rgb(vec3 yuv) {
+          yuv = (yuv - vec3(resource_offset)) * resource_multiplier;
+          return LUT(lut_texture, yuv, 32.0).xyz;
+        }
+      });
+    } else {
+      functions += SHADER0([]() {
+        vec3 yuv2rgb(vec3 yuv) { return LUT(lut_texture, yuv, 32.0).xyz; }
+      });
+    }
   } else {
     head += "  uniform mat3 yuv_matrix;\n";
     head += "  uniform vec3 yuv_adj;\n";
     functions += SHADER0([]() {
       vec3 yuv2rgb(vec3 yuv) { return yuv_matrix * (yuv + yuv_adj); }
     });
   }
 
   functions += SHADER0([]() {
     void main() {
       vec2 ya_clamped =
           max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));
-      float y_raw = TextureLookup(y_texture, ya_clamped).x;
+      float y_raw = GetY(ya_clamped);
       vec2 uv_clamped =
           max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       vec3 yuv = vec3(y_raw, GetUV(uv_clamped));
       gl_FragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
     }
   });
 
   return FRAGMENT_SHADER(head, functions);
 }
 
@@ skipping 73 matching lines @@
     void main() {
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = color * aa;
     }
   });
 }
 
 }  // namespace cc