content/common/gpu/client/gl_helper_scaling.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_COMMON_GPU_CLIENT_GL_HELPER_SCALING_H_
   6 #define CONTENT_COMMON_GPU_CLIENT_GL_HELPER_SCALING_H_
   7
   8 #include <deque>
   9 #include <map>
  10 #include <vector>
  11
  12 #include "content/common/gpu/client/gl_helper.h"
  13 #include "ui/gfx/rect.h"
  14 #include "ui/gfx/size.h"
  15
  16 namespace content {
  17
  18 class ShaderProgram;
  19 class ScalerImpl;
  20 class GLHelperTest;
  21
  22 // Implements GPU texture scaling methods.
  23 // Note that you should probably not use this class directly.
  24 // See gl_helper.cc::CreateScaler instead.
  25 class CONTENT_EXPORT GLHelperScaling {
  26  public:
  27   enum ShaderType {
  28     SHADER_BILINEAR,
  29     SHADER_BILINEAR2,
  30     SHADER_BILINEAR3,
  31     SHADER_BILINEAR4,
  32     SHADER_BILINEAR2X2,
  33     SHADER_BICUBIC_UPSCALE,
  34     SHADER_BICUBIC_HALF_1D,
  35     SHADER_PLANAR,
  36     SHADER_YUV_MRT_PASS1,
  37     SHADER_YUV_MRT_PASS2,
  38   };
  39
  40   // Similar to ScalerInterface, but can generate multiple outputs.
  41   // Used for YUV conversion in gl_helper.c
  42   class CONTENT_EXPORT ShaderInterface {
  43    public:
  44     ShaderInterface() {}
  45     virtual ~ShaderInterface() {}
  46     // Note that the src_texture will have the min/mag filter set to GL_LINEAR
  47     // and wrap_s/t set to CLAMP_TO_EDGE in this call.
  48     virtual void Execute(GLuint source_texture,
  49                          const std::vector<GLuint>& dest_textures) = 0;
  50   };
  51
  52   typedef std::pair<ShaderType, bool> ShaderProgramKeyType;
  53
  54   GLHelperScaling(gpu::gles2::GLES2Interface* gl,
  55                   GLHelper* helper);
  56   ~GLHelperScaling();
  57   void InitBuffer();
  58
  59   GLHelper::ScalerInterface* CreateScaler(
  60       GLHelper::ScalerQuality quality,
  61       gfx::Size src_size,
  62       gfx::Rect src_subrect,
  63       const gfx::Size& dst_size,
  64       bool vertically_flip_texture,
  65       bool swizzle);
  66
  67   GLHelper::ScalerInterface* CreatePlanarScaler(
  68       const gfx::Size& src_size,
  69       const gfx::Rect& src_subrect,
  70       const gfx::Size& dst_size,
  71       bool vertically_flip_texture,
  72       bool swizzle,
  73       const float color_weights[4]);
  74
  75   ShaderInterface* CreateYuvMrtShader(
  76       const gfx::Size& src_size,
  77       const gfx::Rect& src_subrect,
  78       const gfx::Size& dst_size,
  79       bool vertically_flip_texture,
  80       bool swizzle,
  81       ShaderType shader);
  82
  83  private:
  84   // A ScaleOp represents a pass in a scaler pipeline, in one dimension.
  85   // Note that when quality is GOOD, multiple scaler passes will be
  86   // combined into one operation for increased performance.
  87   // Exposed in the header file for testing purposes.
  88   struct ScaleOp {
  89     ScaleOp(int factor, bool x, int size)
  90         : scale_factor(factor), scale_x(x), scale_size(size) {
  91     }
  92
  93     // Calculate a set of ScaleOp needed to convert an image of size
  94     // |src| into an image of size |dst|. If |scale_x| is true, then
  95     // the calculations are for the X axis of the image, otherwise Y.
  96     // If |allow3| is true, we can use a SHADER_BILINEAR3 to replace
  97     // a scale up and scale down with a 3-tap bilinear scale.
  98     // The calculated ScaleOps are added to |ops|.
  99     static void AddOps(int src,
 100                        int dst,
 101                        bool scale_x,
 102                        bool allow3,
 103                        std::deque<ScaleOp>* ops) {
 104       int num_downscales = 0;
 105       if (allow3 && dst * 3 >= src && dst * 2 < src) {
 106         // Technically, this should be a scale up and then a
 107         // scale down, but it makes the optimization code more
 108         // complicated.
 109         ops->push_back(ScaleOp(3, scale_x, dst));
 110         return;
 111       }
 112       while ((dst << num_downscales) < src) {
 113         num_downscales++;
 114       }
 115       if ((dst << num_downscales) != src) {
 116         ops->push_back(ScaleOp(0, scale_x, dst << num_downscales));
 117       }
 118       while (num_downscales) {
 119         num_downscales--;
 120         ops->push_back(ScaleOp(2, scale_x, dst << num_downscales));
 121       }
 122     }
 123
 124     // Update |size| to its new size. Before calling this function
 125     // |size| should be the size of the input image. After calling it,
 126     // |size| will be the size of the image after this particular
 127     // scaling operation.
 128     void UpdateSize(gfx::Size* subrect) {
 129       if (scale_x) {
 130         subrect->set_width(scale_size);
 131       } else {
 132         subrect->set_height(scale_size);
 133       }
 134     }
 135
 136     // A scale factor of 0 means upscale
 137     // 2 means 50% scale
 138     // 3 means 33% scale, etc.
 139     int scale_factor;
 140     bool scale_x;  // Otherwise y
 141     int scale_size;  // Size to scale to.
 142   };
 143
 144   // Full specification for a single scaling stage.
 145   struct ScalerStage {
 146     ScalerStage(ShaderType shader_,
 147                 gfx::Size src_size_,
 148                 gfx::Rect src_subrect_,
 149                 gfx::Size dst_size_,
 150                 bool scale_x_,
 151                 bool vertically_flip_texture_,
 152                 bool swizzle_);
 153     ShaderType shader;
 154     gfx::Size src_size;
 155     gfx::Rect src_subrect;
 156     gfx::Size dst_size;
 157     bool scale_x;
 158     bool vertically_flip_texture;
 159     bool swizzle;
 160   };
 161
 162   // Compute a vector of scaler stages for a particular
 163   // set of input/output parameters.
 164   void ComputeScalerStages(GLHelper::ScalerQuality quality,
 165                            const gfx::Size& src_size,
 166                            const gfx::Rect& src_subrect,
 167                            const gfx::Size& dst_size,
 168                            bool vertically_flip_texture,
 169                            bool swizzle,
 170                            std::vector<ScalerStage> *scaler_stages);
 171
 172   // Take two queues of ScaleOp structs and generate a
 173   // vector of scaler stages. This is the second half of
 174   // ComputeScalerStages.
 175   void ConvertScalerOpsToScalerStages(
 176       GLHelper::ScalerQuality quality,
 177       gfx::Size src_size,
 178       gfx::Rect src_subrect,
 179       const gfx::Size& dst_size,
 180       bool vertically_flip_texture,
 181       bool swizzle,
 182       std::deque<GLHelperScaling::ScaleOp>* x_ops,
 183       std::deque<GLHelperScaling::ScaleOp>* y_ops,
 184       std::vector<ScalerStage> *scaler_stages);
 185
 186
 187   scoped_refptr<ShaderProgram> GetShaderProgram(ShaderType type, bool swizzle);
 188
 189   // Interleaved array of 2-dimentional vertex positions (x, y) and
 190   // 2-dimentional texture coordinates (s, t).
 191   static const GLfloat kVertexAttributes[];
 192
 193   gpu::gles2::GLES2Interface* gl_;
 194   GLHelper* helper_;
 195
 196   // The buffer that holds the vertices and the texture coordinates data for
 197   // drawing a quad.
 198   ScopedBuffer vertex_attributes_buffer_;
 199
 200   std::map<ShaderProgramKeyType,
 201            scoped_refptr<ShaderProgram> > shader_programs_;
 202
 203   friend class ShaderProgram;
 204   friend class ScalerImpl;
 205   friend class GLHelperTest;
 206   DISALLOW_COPY_AND_ASSIGN(GLHelperScaling);
 207 };
 208
 209
 210 }  // namespace content
 211
 212 #endif  // CONTENT_COMMON_GPU_CLIENT_GL_HELPER_SCALING_H_