content/common/gpu/client/gl_helper.cc

   1 // Copyright (c) 2012 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 #include "content/common/gpu/client/gl_helper.h"
   6
   7 #include <queue>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "base/debug/trace_event.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/logging.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/time/time.h"
  18 #include "content/common/gpu/client/gl_helper_readback_support.h"
  19 #include "content/common/gpu/client/gl_helper_scaling.h"
  20 #include "gpu/GLES2/gl2extchromium.h"
  21 #include "gpu/command_buffer/client/context_support.h"
  22 #include "gpu/command_buffer/common/mailbox.h"
  23 #include "gpu/command_buffer/common/mailbox_holder.h"
  24 #include "media/base/video_frame.h"
  25 #include "media/base/video_util.h"
  26 #include "third_party/skia/include/core/SkRegion.h"
  27 #include "ui/gfx/rect.h"
  28 #include "ui/gfx/size.h"
  29
  30 using gpu::gles2::GLES2Interface;
  31
  32 namespace {
  33
  34 class ScopedFlush {
  35  public:
  36   explicit ScopedFlush(gpu::gles2::GLES2Interface* gl) : gl_(gl) {}
  37
  38   ~ScopedFlush() { gl_->Flush(); }
  39
  40  private:
  41   gpu::gles2::GLES2Interface* gl_;
  42
  43   DISALLOW_COPY_AND_ASSIGN(ScopedFlush);
  44 };
  45
  46 // Helper class for allocating and holding an RGBA texture of a given
  47 // size and an associated framebuffer.
  48 class TextureFrameBufferPair {
  49  public:
  50   TextureFrameBufferPair(GLES2Interface* gl, gfx::Size size)
  51       : texture_(gl), framebuffer_(gl), size_(size) {
  52     content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl, texture_);
  53     gl->TexImage2D(GL_TEXTURE_2D,
  54                    0,
  55                    GL_RGBA,
  56                    size.width(),
  57                    size.height(),
  58                    0,
  59                    GL_RGBA,
  60                    GL_UNSIGNED_BYTE,
  61                    NULL);
  62     content::ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(
  63         gl, framebuffer_);
  64     gl->FramebufferTexture2D(
  65         GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_, 0);
  66   }
  67
  68   GLuint texture() const { return texture_.id(); }
  69   GLuint framebuffer() const { return framebuffer_.id(); }
  70   gfx::Size size() const { return size_; }
  71
  72  private:
  73   content::ScopedTexture texture_;
  74   content::ScopedFramebuffer framebuffer_;
  75   gfx::Size size_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(TextureFrameBufferPair);
  78 };
  79
  80 // Helper class for holding a scaler, a texture for the output of that
  81 // scaler and an associated frame buffer. This is inteded to be used
  82 // when the output of a scaler is to be sent to a readback.
  83 class ScalerHolder {
  84  public:
  85   ScalerHolder(GLES2Interface* gl, content::GLHelper::ScalerInterface* scaler)
  86       : texture_and_framebuffer_(gl, scaler->DstSize()), scaler_(scaler) {}
  87
  88   void Scale(GLuint src_texture) {
  89     scaler_->Scale(src_texture, texture_and_framebuffer_.texture());
  90   }
  91
  92   content::GLHelper::ScalerInterface* scaler() const { return scaler_.get(); }
  93   TextureFrameBufferPair* texture_and_framebuffer() {
  94     return &texture_and_framebuffer_;
  95   }
  96   GLuint texture() const { return texture_and_framebuffer_.texture(); }
  97
  98  private:
  99   TextureFrameBufferPair texture_and_framebuffer_;
 100   scoped_ptr<content::GLHelper::ScalerInterface> scaler_;
 101
 102   DISALLOW_COPY_AND_ASSIGN(ScalerHolder);
 103 };
 104
 105 }  // namespace
 106
 107 namespace content {
 108 typedef GLHelperReadbackSupport::FormatSupport FormatSupport;
 109
 110 // Implements GLHelper::CropScaleReadbackAndCleanTexture and encapsulates
 111 // the data needed for it.
 112 class GLHelper::CopyTextureToImpl
 113     : public base::SupportsWeakPtr<GLHelper::CopyTextureToImpl> {
 114  public:
 115   CopyTextureToImpl(GLES2Interface* gl,
 116                     gpu::ContextSupport* context_support,
 117                     GLHelper* helper)
 118       : gl_(gl),
 119         context_support_(context_support),
 120         helper_(helper),
 121         flush_(gl),
 122         max_draw_buffers_(0) {
 123     const GLubyte* extensions = gl_->GetString(GL_EXTENSIONS);
 124     if (!extensions)
 125       return;
 126     std::string extensions_string =
 127         " " + std::string(reinterpret_cast<const char*>(extensions)) + " ";
 128     if (extensions_string.find(" GL_EXT_draw_buffers ") != std::string::npos) {
 129       gl_->GetIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &max_draw_buffers_);
 130     }
 131   }
 132   ~CopyTextureToImpl() { CancelRequests(); }
 133
 134   GLuint ConsumeMailboxToTexture(const gpu::Mailbox& mailbox,
 135                                  uint32 sync_point) {
 136     return helper_->ConsumeMailboxToTexture(mailbox, sync_point);
 137   }
 138
 139   void CropScaleReadbackAndCleanTexture(
 140       GLuint src_texture,
 141       const gfx::Size& src_size,
 142       const gfx::Rect& src_subrect,
 143       const gfx::Size& dst_size,
 144       unsigned char* out,
 145       const SkColorType out_color_type,
 146       const base::Callback<void(bool)>& callback,
 147       GLHelper::ScalerQuality quality);
 148
 149   void ReadbackTextureSync(GLuint texture,
 150                            const gfx::Rect& src_rect,
 151                            unsigned char* out,
 152                            SkColorType format);
 153
 154   void ReadbackTextureAsync(GLuint texture,
 155                             const gfx::Size& dst_size,
 156                             unsigned char* out,
 157                             SkColorType color_type,
 158                             const base::Callback<void(bool)>& callback);
 159
 160   // Reads back bytes from the currently bound frame buffer.
 161   // Note that dst_size is specified in bytes, not pixels.
 162   void ReadbackAsync(const gfx::Size& dst_size,
 163                      int32 bytes_per_row,     // generally dst_size.width() * 4
 164                      int32 row_stride_bytes,  // generally dst_size.width() * 4
 165                      unsigned char* out,
 166                      GLenum format,
 167                      GLenum type,
 168                      size_t bytes_per_pixel,
 169                      const base::Callback<void(bool)>& callback);
 170
 171   void ReadbackPlane(TextureFrameBufferPair* source,
 172                      const scoped_refptr<media::VideoFrame>& target,
 173                      int plane,
 174                      int size_shift,
 175                      const gfx::Rect& dst_subrect,
 176                      ReadbackSwizzle swizzle,
 177                      const base::Callback<void(bool)>& callback);
 178
 179   GLuint CopyAndScaleTexture(GLuint texture,
 180                              const gfx::Size& src_size,
 181                              const gfx::Size& dst_size,
 182                              bool vertically_flip_texture,
 183                              GLHelper::ScalerQuality quality);
 184
 185   ReadbackYUVInterface* CreateReadbackPipelineYUV(
 186       GLHelper::ScalerQuality quality,
 187       const gfx::Size& src_size,
 188       const gfx::Rect& src_subrect,
 189       const gfx::Size& dst_size,
 190       const gfx::Rect& dst_subrect,
 191       bool flip_vertically,
 192       bool use_mrt);
 193
 194   // Returns the maximum number of draw buffers available,
 195   // 0 if GL_EXT_draw_buffers is not available.
 196   GLint MaxDrawBuffers() const { return max_draw_buffers_; }
 197
 198   FormatSupport GetReadbackConfig(SkColorType color_type,
 199                                   bool can_swizzle,
 200                                   GLenum* format,
 201                                   GLenum* type,
 202                                   size_t* bytes_per_pixel);
 203
 204  private:
 205   // A single request to CropScaleReadbackAndCleanTexture.
 206   // The main thread can cancel the request, before it's handled by the helper
 207   // thread, by resetting the texture and pixels fields. Alternatively, the
 208   // thread marks that it handles the request by resetting the pixels field
 209   // (meaning it guarantees that the callback with be called).
 210   // In either case, the callback must be called exactly once, and the texture
 211   // must be deleted by the main thread gl.
 212   struct Request {
 213     Request(const gfx::Size& size_,
 214             int32 bytes_per_row_,
 215             int32 row_stride_bytes_,
 216             unsigned char* pixels_,
 217             const base::Callback<void(bool)>& callback_)
 218         : done(false),
 219           size(size_),
 220           bytes_per_row(bytes_per_row_),
 221           row_stride_bytes(row_stride_bytes_),
 222           pixels(pixels_),
 223           callback(callback_),
 224           buffer(0),
 225           query(0) {}
 226
 227     bool done;
 228     gfx::Size size;
 229     int bytes_per_row;
 230     int row_stride_bytes;
 231     unsigned char* pixels;
 232     base::Callback<void(bool)> callback;
 233     GLuint buffer;
 234     GLuint query;
 235   };
 236
 237   // A readback pipeline that also converts the data to YUV before
 238   // reading it back.
 239   class ReadbackYUVImpl : public ReadbackYUVInterface {
 240    public:
 241     ReadbackYUVImpl(GLES2Interface* gl,
 242                     CopyTextureToImpl* copy_impl,
 243                     GLHelperScaling* scaler_impl,
 244                     GLHelper::ScalerQuality quality,
 245                     const gfx::Size& src_size,
 246                     const gfx::Rect& src_subrect,
 247                     const gfx::Size& dst_size,
 248                     const gfx::Rect& dst_subrect,
 249                     bool flip_vertically,
 250                     ReadbackSwizzle swizzle);
 251
 252     virtual void ReadbackYUV(const gpu::Mailbox& mailbox,
 253                              uint32 sync_point,
 254                              const scoped_refptr<media::VideoFrame>& target,
 255                              const base::Callback<void(bool)>& callback)
 256         OVERRIDE;
 257
 258     virtual ScalerInterface* scaler() OVERRIDE { return scaler_.scaler(); }
 259
 260    private:
 261     GLES2Interface* gl_;
 262     CopyTextureToImpl* copy_impl_;
 263     gfx::Size dst_size_;
 264     gfx::Rect dst_subrect_;
 265     ReadbackSwizzle swizzle_;
 266     ScalerHolder scaler_;
 267     ScalerHolder y_;
 268     ScalerHolder u_;
 269     ScalerHolder v_;
 270
 271     DISALLOW_COPY_AND_ASSIGN(ReadbackYUVImpl);
 272   };
 273
 274   // A readback pipeline that also converts the data to YUV before
 275   // reading it back. This one uses Multiple Render Targets, which
 276   // may not be supported on all platforms.
 277   class ReadbackYUV_MRT : public ReadbackYUVInterface {
 278    public:
 279     ReadbackYUV_MRT(GLES2Interface* gl,
 280                     CopyTextureToImpl* copy_impl,
 281                     GLHelperScaling* scaler_impl,
 282                     GLHelper::ScalerQuality quality,
 283                     const gfx::Size& src_size,
 284                     const gfx::Rect& src_subrect,
 285                     const gfx::Size& dst_size,
 286                     const gfx::Rect& dst_subrect,
 287                     bool flip_vertically,
 288                     ReadbackSwizzle swizzle);
 289
 290     virtual void ReadbackYUV(const gpu::Mailbox& mailbox,
 291                              uint32 sync_point,
 292                              const scoped_refptr<media::VideoFrame>& target,
 293                              const base::Callback<void(bool)>& callback)
 294         OVERRIDE;
 295
 296     virtual ScalerInterface* scaler() OVERRIDE { return scaler_.scaler(); }
 297
 298    private:
 299     GLES2Interface* gl_;
 300     CopyTextureToImpl* copy_impl_;
 301     gfx::Size dst_size_;
 302     gfx::Rect dst_subrect_;
 303     GLHelper::ScalerQuality quality_;
 304     ReadbackSwizzle swizzle_;
 305     ScalerHolder scaler_;
 306     scoped_ptr<content::GLHelperScaling::ShaderInterface> pass1_shader_;
 307     scoped_ptr<content::GLHelperScaling::ShaderInterface> pass2_shader_;
 308     TextureFrameBufferPair y_;
 309     ScopedTexture uv_;
 310     TextureFrameBufferPair u_;
 311     TextureFrameBufferPair v_;
 312
 313     DISALLOW_COPY_AND_ASSIGN(ReadbackYUV_MRT);
 314   };
 315
 316   // Copies the block of pixels specified with |src_subrect| from |src_texture|,
 317   // scales it to |dst_size|, writes it into a texture, and returns its ID.
 318   // |src_size| is the size of |src_texture|.
 319   GLuint ScaleTexture(GLuint src_texture,
 320                       const gfx::Size& src_size,
 321                       const gfx::Rect& src_subrect,
 322                       const gfx::Size& dst_size,
 323                       bool vertically_flip_texture,
 324                       bool swizzle,
 325                       SkColorType color_type,
 326                       GLHelper::ScalerQuality quality);
 327
 328   // Converts each four consecutive pixels of the source texture into one pixel
 329   // in the result texture with each pixel channel representing the grayscale
 330   // color of one of the four original pixels:
 331   // R1G1B1A1 R2G2B2A2 R3G3B3A3 R4G4B4A4 -> X1X2X3X4
 332   // The resulting texture is still an RGBA texture (which is ~4 times narrower
 333   // than the original). If rendered directly, it wouldn't show anything useful,
 334   // but the data in it can be used to construct a grayscale image.
 335   // |encoded_texture_size| is the exact size of the resulting RGBA texture. It
 336   // is equal to src_size.width()/4 rounded upwards. Some channels in the last
 337   // pixel ((-src_size.width()) % 4) to be exact) are padding and don't contain
 338   // useful data.
 339   // If swizzle is set to true, the transformed pixels are reordered:
 340   // R1G1B1A1 R2G2B2A2 R3G3B3A3 R4G4B4A4 -> X3X2X1X4.
 341   GLuint EncodeTextureAsGrayscale(GLuint src_texture,
 342                                   const gfx::Size& src_size,
 343                                   gfx::Size* const encoded_texture_size,
 344                                   bool vertically_flip_texture,
 345                                   bool swizzle);
 346
 347   static void nullcallback(bool success) {}
 348   void ReadbackDone(Request *request, int bytes_per_pixel);
 349   void FinishRequest(Request* request, bool result);
 350   void CancelRequests();
 351
 352   static const float kRGBtoYColorWeights[];
 353   static const float kRGBtoUColorWeights[];
 354   static const float kRGBtoVColorWeights[];
 355   static const float kRGBtoGrayscaleColorWeights[];
 356
 357   GLES2Interface* gl_;
 358   gpu::ContextSupport* context_support_;
 359   GLHelper* helper_;
 360
 361   // A scoped flush that will ensure all resource deletions are flushed when
 362   // this object is destroyed. Must be declared before other Scoped* fields.
 363   ScopedFlush flush_;
 364
 365   std::queue<Request*> request_queue_;
 366   GLint max_draw_buffers_;
 367 };
 368
 369 GLHelper::ScalerInterface* GLHelper::CreateScaler(ScalerQuality quality,
 370                                                   const gfx::Size& src_size,
 371                                                   const gfx::Rect& src_subrect,
 372                                                   const gfx::Size& dst_size,
 373                                                   bool vertically_flip_texture,
 374                                                   bool swizzle) {
 375   InitScalerImpl();
 376   return scaler_impl_->CreateScaler(quality,
 377                                     src_size,
 378                                     src_subrect,
 379                                     dst_size,
 380                                     vertically_flip_texture,
 381                                     swizzle);
 382 }
 383
 384 GLuint GLHelper::CopyTextureToImpl::ScaleTexture(
 385     GLuint src_texture,
 386     const gfx::Size& src_size,
 387     const gfx::Rect& src_subrect,
 388     const gfx::Size& dst_size,
 389     bool vertically_flip_texture,
 390     bool swizzle,
 391     SkColorType color_type,
 392     GLHelper::ScalerQuality quality) {
 393   GLuint dst_texture = 0u;
 394   gl_->GenTextures(1, &dst_texture);
 395   {
 396     GLenum format = GL_RGBA, type = GL_UNSIGNED_BYTE;
 397     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
 398
 399     // Use GL_RGBA for destination/temporary texture unless we're working with
 400     // 16-bit data
 401     if (color_type == kRGB_565_SkColorType) {
 402       format = GL_RGB;
 403       type = GL_UNSIGNED_SHORT_5_6_5;
 404     }
 405
 406     gl_->TexImage2D(GL_TEXTURE_2D,
 407                     0,
 408                     format,
 409                     dst_size.width(),
 410                     dst_size.height(),
 411                     0,
 412                     format,
 413                     type,
 414                     NULL);
 415   }
 416   scoped_ptr<ScalerInterface> scaler(
 417       helper_->CreateScaler(quality,
 418                             src_size,
 419                             src_subrect,
 420                             dst_size,
 421                             vertically_flip_texture,
 422                             swizzle));
 423   scaler->Scale(src_texture, dst_texture);
 424   return dst_texture;
 425 }
 426
 427 GLuint GLHelper::CopyTextureToImpl::EncodeTextureAsGrayscale(
 428     GLuint src_texture,
 429     const gfx::Size& src_size,
 430     gfx::Size* const encoded_texture_size,
 431     bool vertically_flip_texture,
 432     bool swizzle) {
 433   GLuint dst_texture = 0u;
 434   gl_->GenTextures(1, &dst_texture);
 435   // The size of the encoded texture.
 436   *encoded_texture_size =
 437       gfx::Size((src_size.width() + 3) / 4, src_size.height());
 438   {
 439     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
 440     gl_->TexImage2D(GL_TEXTURE_2D,
 441                     0,
 442                     GL_RGBA,
 443                     encoded_texture_size->width(),
 444                     encoded_texture_size->height(),
 445                     0,
 446                     GL_RGBA,
 447                     GL_UNSIGNED_BYTE,
 448                     NULL);
 449   }
 450
 451   helper_->InitScalerImpl();
 452   scoped_ptr<ScalerInterface> grayscale_scaler(
 453       helper_->scaler_impl_.get()->CreatePlanarScaler(
 454           src_size,
 455           gfx::Rect(0, 0, (src_size.width() + 3) & ~3, src_size.height()),
 456           *encoded_texture_size,
 457           vertically_flip_texture,
 458           swizzle,
 459           kRGBtoGrayscaleColorWeights));
 460   grayscale_scaler->Scale(src_texture, dst_texture);
 461   return dst_texture;
 462 }
 463
 464 void GLHelper::CopyTextureToImpl::ReadbackAsync(
 465     const gfx::Size& dst_size,
 466     int32 bytes_per_row,
 467     int32 row_stride_bytes,
 468     unsigned char* out,
 469     GLenum format,
 470     GLenum type,
 471     size_t bytes_per_pixel,
 472     const base::Callback<void(bool)>& callback) {
 473   TRACE_EVENT0("mirror", "GLHelper::CopyTextureToImpl::ReadbackAsync");
 474   Request* request =
 475       new Request(dst_size, bytes_per_row, row_stride_bytes, out, callback);
 476   request_queue_.push(request);
 477   request->buffer = 0u;
 478
 479   gl_->GenBuffers(1, &request->buffer);
 480   gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, request->buffer);
 481   gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
 482                   bytes_per_pixel * dst_size.GetArea(),
 483                   NULL,
 484                   GL_STREAM_READ);
 485
 486   request->query = 0u;
 487   gl_->GenQueriesEXT(1, &request->query);
 488   gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, request->query);
 489   gl_->ReadPixels(0,
 490                   0,
 491                   dst_size.width(),
 492                   dst_size.height(),
 493                   format,
 494                   type,
 495                   NULL);
 496   gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM);
 497   gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
 498   context_support_->SignalQuery(
 499       request->query,
 500       base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(),
 501                  request, bytes_per_pixel));
 502 }
 503
 504 void GLHelper::CopyTextureToImpl::CropScaleReadbackAndCleanTexture(
 505     GLuint src_texture,
 506     const gfx::Size& src_size,
 507     const gfx::Rect& src_subrect,
 508     const gfx::Size& dst_size,
 509     unsigned char* out,
 510     const SkColorType out_color_type,
 511     const base::Callback<void(bool)>& callback,
 512     GLHelper::ScalerQuality quality) {
 513   GLenum format, type;
 514   size_t bytes_per_pixel;
 515   SkColorType readback_color_type = out_color_type;
 516   // Single-component textures are not supported by all GPUs, so  we implement
 517   // kAlpha_8_SkColorType support here via a special encoding (see below) using
 518   // a 32-bit texture to represent an 8-bit image.
 519   // Thus we use generic 32-bit readback in this case.
 520   if (out_color_type == kAlpha_8_SkColorType) {
 521     readback_color_type = kRGBA_8888_SkColorType;
 522   }
 523
 524   FormatSupport supported = GetReadbackConfig(
 525       readback_color_type, true, &format, &type, &bytes_per_pixel);
 526
 527   if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) {
 528     callback.Run(false);
 529     return;
 530   }
 531
 532   GLuint texture = src_texture;
 533
 534   // Scale texture if needed
 535   // Optimization: SCALER_QUALITY_FAST is just a single bilinear pass, which we
 536   // can do just as well in EncodeTextureAsGrayscale, which we will do if
 537   // out_color_type is kAlpha_8_SkColorType, so let's skip the scaling step
 538   // in that case.
 539   bool scale_texture = out_color_type != kAlpha_8_SkColorType ||
 540                        quality != GLHelper::SCALER_QUALITY_FAST;
 541   if (scale_texture) {
 542     // Don't swizzle during the scale step for kAlpha_8_SkColorType.
 543     // We will swizzle in the encode step below if needed.
 544     bool scale_swizzle = out_color_type == kAlpha_8_SkColorType
 545                              ? false
 546                              : supported == GLHelperReadbackSupport::SWIZZLE;
 547     texture =
 548         ScaleTexture(src_texture,
 549                      src_size,
 550                      src_subrect,
 551                      dst_size,
 552                      true,
 553                      scale_swizzle,
 554                      out_color_type == kAlpha_8_SkColorType ? kN32_SkColorType
 555                                                             : out_color_type,
 556                      quality);
 557     DCHECK(texture);
 558   }
 559
 560   gfx::Size readback_texture_size = dst_size;
 561   // Encode texture to grayscale if needed.
 562   if (out_color_type == kAlpha_8_SkColorType) {
 563     // Do the vertical flip here if we haven't already done it when we scaled
 564     // the texture.
 565     bool encode_as_grayscale_vertical_flip = !scale_texture;
 566     // EncodeTextureAsGrayscale by default creates a texture which should be
 567     // read back as RGBA, so need to swizzle if the readback format is BGRA.
 568     bool encode_as_grayscale_swizzle = format == GL_BGRA_EXT;
 569     GLuint tmp_texture =
 570         EncodeTextureAsGrayscale(texture,
 571                                  dst_size,
 572                                  &readback_texture_size,
 573                                  encode_as_grayscale_vertical_flip,
 574                                  encode_as_grayscale_swizzle);
 575     // If the scaled texture was created - delete it
 576     if (scale_texture)
 577       gl_->DeleteTextures(1, &texture);
 578     texture = tmp_texture;
 579     DCHECK(texture);
 580   }
 581
 582   // Readback the pixels of the resulting texture
 583   ScopedFramebuffer dst_framebuffer(gl_);
 584   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
 585                                                              dst_framebuffer);
 586   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 587   gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
 588                             GL_COLOR_ATTACHMENT0,
 589                             GL_TEXTURE_2D,
 590                             texture,
 591                             0);
 592
 593   int32 bytes_per_row = out_color_type == kAlpha_8_SkColorType
 594                             ? dst_size.width()
 595                             : dst_size.width() * bytes_per_pixel;
 596
 597   ReadbackAsync(readback_texture_size,
 598                 bytes_per_row,
 599                 bytes_per_row,
 600                 out,
 601                 format,
 602                 type,
 603                 bytes_per_pixel,
 604                 callback);
 605   gl_->DeleteTextures(1, &texture);
 606 }
 607
 608 void GLHelper::CopyTextureToImpl::ReadbackTextureSync(
 609     GLuint texture,
 610     const gfx::Rect& src_rect,
 611     unsigned char* out,
 612     SkColorType color_type) {
 613   GLenum format, type;
 614   size_t bytes_per_pixel;
 615   FormatSupport supported =
 616       GetReadbackConfig(color_type, false, &format, &type, &bytes_per_pixel);
 617   if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) {
 618     return;
 619   }
 620
 621   ScopedFramebuffer dst_framebuffer(gl_);
 622   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
 623                                                              dst_framebuffer);
 624   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 625   gl_->FramebufferTexture2D(
 626       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
 627   gl_->ReadPixels(src_rect.x(),
 628                   src_rect.y(),
 629                   src_rect.width(),
 630                   src_rect.height(),
 631                   format,
 632                   type,
 633                   out);
 634 }
 635
 636 void GLHelper::CopyTextureToImpl::ReadbackTextureAsync(
 637     GLuint texture,
 638     const gfx::Size& dst_size,
 639     unsigned char* out,
 640     SkColorType color_type,
 641     const base::Callback<void(bool)>& callback) {
 642   GLenum format, type;
 643   size_t bytes_per_pixel;
 644   FormatSupport supported =
 645       GetReadbackConfig(color_type, false, &format, &type, &bytes_per_pixel);
 646   if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) {
 647     callback.Run(false);
 648     return;
 649   }
 650
 651   ScopedFramebuffer dst_framebuffer(gl_);
 652   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
 653                                                              dst_framebuffer);
 654   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 655   gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
 656                             GL_COLOR_ATTACHMENT0,
 657                             GL_TEXTURE_2D,
 658                             texture,
 659                             0);
 660   ReadbackAsync(dst_size,
 661                 dst_size.width() * bytes_per_pixel,
 662                 dst_size.width() * bytes_per_pixel,
 663                 out,
 664                 format,
 665                 type,
 666                 bytes_per_pixel,
 667                 callback);
 668 }
 669
 670 GLuint GLHelper::CopyTextureToImpl::CopyAndScaleTexture(
 671     GLuint src_texture,
 672     const gfx::Size& src_size,
 673     const gfx::Size& dst_size,
 674     bool vertically_flip_texture,
 675     GLHelper::ScalerQuality quality) {
 676   return ScaleTexture(src_texture,
 677                       src_size,
 678                       gfx::Rect(src_size),
 679                       dst_size,
 680                       vertically_flip_texture,
 681                       false,
 682                       kRGBA_8888_SkColorType,  // GL_RGBA
 683                       quality);
 684 }
 685
 686 void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request,
 687                                                int bytes_per_pixel) {
 688   TRACE_EVENT0("mirror",
 689                "GLHelper::CopyTextureToImpl::CheckReadbackFramebufferComplete");
 690   finished_request->done = true;
 691
 692   // We process transfer requests in the order they were received, regardless
 693   // of the order we get the callbacks in.
 694   while (!request_queue_.empty()) {
 695     Request* request = request_queue_.front();
 696     if (!request->done) {
 697       break;
 698     }
 699
 700     bool result = false;
 701     if (request->buffer != 0) {
 702       gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, request->buffer);
 703       unsigned char* data = static_cast<unsigned char*>(gl_->MapBufferCHROMIUM(
 704           GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY));
 705       if (data) {
 706         result = true;
 707         if (request->bytes_per_row == request->size.width() * bytes_per_pixel &&
 708             request->bytes_per_row == request->row_stride_bytes) {
 709           memcpy(request->pixels, data,
 710                  request->size.GetArea() * bytes_per_pixel);
 711         } else {
 712           unsigned char* out = request->pixels;
 713           for (int y = 0; y < request->size.height(); y++) {
 714             memcpy(out, data, request->bytes_per_row);
 715             out += request->row_stride_bytes;
 716             data += request->size.width() * bytes_per_pixel;
 717           }
 718         }
 719         gl_->UnmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM);
 720       }
 721       gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
 722     }
 723     FinishRequest(request, result);
 724   }
 725 }
 726
 727 void GLHelper::CopyTextureToImpl::FinishRequest(Request* request, bool result) {
 728   TRACE_EVENT0("mirror", "GLHelper::CopyTextureToImpl::FinishRequest");
 729   DCHECK(request_queue_.front() == request);
 730   request_queue_.pop();
 731   request->callback.Run(result);
 732   ScopedFlush flush(gl_);
 733   if (request->query != 0) {
 734     gl_->DeleteQueriesEXT(1, &request->query);
 735     request->query = 0;
 736   }
 737   if (request->buffer != 0) {
 738     gl_->DeleteBuffers(1, &request->buffer);
 739     request->buffer = 0;
 740   }
 741   delete request;
 742 }
 743
 744 void GLHelper::CopyTextureToImpl::CancelRequests() {
 745   while (!request_queue_.empty()) {
 746     Request* request = request_queue_.front();
 747     FinishRequest(request, false);
 748   }
 749 }
 750
 751 FormatSupport GLHelper::CopyTextureToImpl::GetReadbackConfig(
 752     SkColorType color_type,
 753     bool can_swizzle,
 754     GLenum* format,
 755     GLenum* type,
 756     size_t* bytes_per_pixel) {
 757   return helper_->readback_support_->GetReadbackConfig(
 758       color_type, can_swizzle, format, type, bytes_per_pixel);
 759 }
 760
 761 GLHelper::GLHelper(GLES2Interface* gl, gpu::ContextSupport* context_support)
 762     : gl_(gl),
 763       context_support_(context_support),
 764       readback_support_(new GLHelperReadbackSupport(gl)) {}
 765
 766 GLHelper::~GLHelper() {}
 767
 768 void GLHelper::CropScaleReadbackAndCleanTexture(
 769     GLuint src_texture,
 770     const gfx::Size& src_size,
 771     const gfx::Rect& src_subrect,
 772     const gfx::Size& dst_size,
 773     unsigned char* out,
 774     const SkColorType out_color_type,
 775     const base::Callback<void(bool)>& callback,
 776     GLHelper::ScalerQuality quality) {
 777   InitCopyTextToImpl();
 778   copy_texture_to_impl_->CropScaleReadbackAndCleanTexture(src_texture,
 779                                                           src_size,
 780                                                           src_subrect,
 781                                                           dst_size,
 782                                                           out,
 783                                                           out_color_type,
 784                                                           callback,
 785                                                           quality);
 786 }
 787
 788 void GLHelper::CropScaleReadbackAndCleanMailbox(
 789     const gpu::Mailbox& src_mailbox,
 790     uint32 sync_point,
 791     const gfx::Size& src_size,
 792     const gfx::Rect& src_subrect,
 793     const gfx::Size& dst_size,
 794     unsigned char* out,
 795     const SkColorType out_color_type,
 796     const base::Callback<void(bool)>& callback,
 797     GLHelper::ScalerQuality quality) {
 798   GLuint mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_point);
 799   CropScaleReadbackAndCleanTexture(mailbox_texture,
 800                                    src_size,
 801                                    src_subrect,
 802                                    dst_size,
 803                                    out,
 804                                    out_color_type,
 805                                    callback,
 806                                    quality);
 807   gl_->DeleteTextures(1, &mailbox_texture);
 808 }
 809
 810 void GLHelper::ReadbackTextureSync(GLuint texture,
 811                                    const gfx::Rect& src_rect,
 812                                    unsigned char* out,
 813                                    SkColorType format) {
 814   InitCopyTextToImpl();
 815   copy_texture_to_impl_->ReadbackTextureSync(texture, src_rect, out, format);
 816 }
 817
 818 void GLHelper::ReadbackTextureAsync(
 819     GLuint texture,
 820     const gfx::Size& dst_size,
 821     unsigned char* out,
 822     SkColorType color_type,
 823     const base::Callback<void(bool)>& callback) {
 824   InitCopyTextToImpl();
 825   copy_texture_to_impl_->ReadbackTextureAsync(texture,
 826                                               dst_size,
 827                                               out,
 828                                               color_type,
 829                                               callback);
 830 }
 831
 832 GLuint GLHelper::CopyTexture(GLuint texture, const gfx::Size& size) {
 833   InitCopyTextToImpl();
 834   return copy_texture_to_impl_->CopyAndScaleTexture(
 835       texture, size, size, false, GLHelper::SCALER_QUALITY_FAST);
 836 }
 837
 838 GLuint GLHelper::CopyAndScaleTexture(GLuint texture,
 839                                      const gfx::Size& src_size,
 840                                      const gfx::Size& dst_size,
 841                                      bool vertically_flip_texture,
 842                                      ScalerQuality quality) {
 843   InitCopyTextToImpl();
 844   return copy_texture_to_impl_->CopyAndScaleTexture(
 845       texture, src_size, dst_size, vertically_flip_texture, quality);
 846 }
 847
 848 GLuint GLHelper::CompileShaderFromSource(const GLchar* source, GLenum type) {
 849   GLuint shader = gl_->CreateShader(type);
 850   GLint length = strlen(source);
 851   gl_->ShaderSource(shader, 1, &source, &length);
 852   gl_->CompileShader(shader);
 853   GLint compile_status = 0;
 854   gl_->GetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
 855   if (!compile_status) {
 856     GLint log_length = 0;
 857     gl_->GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
 858     if (log_length) {
 859       scoped_ptr<GLchar[]> log(new GLchar[log_length]);
 860       GLsizei returned_log_length = 0;
 861       gl_->GetShaderInfoLog(
 862           shader, log_length, &returned_log_length, log.get());
 863       LOG(ERROR) << std::string(log.get(), returned_log_length);
 864     }
 865     gl_->DeleteShader(shader);
 866     return 0;
 867   }
 868   return shader;
 869 }
 870
 871 void GLHelper::InitCopyTextToImpl() {
 872   // Lazily initialize |copy_texture_to_impl_|
 873   if (!copy_texture_to_impl_)
 874     copy_texture_to_impl_.reset(
 875         new CopyTextureToImpl(gl_, context_support_, this));
 876 }
 877
 878 void GLHelper::InitScalerImpl() {
 879   // Lazily initialize |scaler_impl_|
 880   if (!scaler_impl_)
 881     scaler_impl_.reset(new GLHelperScaling(gl_, this));
 882 }
 883
 884 GLint GLHelper::MaxDrawBuffers() {
 885   InitCopyTextToImpl();
 886   return copy_texture_to_impl_->MaxDrawBuffers();
 887 }
 888
 889 void GLHelper::CopySubBufferDamage(GLuint texture,
 890                                    GLuint previous_texture,
 891                                    const SkRegion& new_damage,
 892                                    const SkRegion& old_damage) {
 893   SkRegion region(old_damage);
 894   if (region.op(new_damage, SkRegion::kDifference_Op)) {
 895     ScopedFramebuffer dst_framebuffer(gl_);
 896     ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
 897                                                                dst_framebuffer);
 898     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 899     gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
 900                               GL_COLOR_ATTACHMENT0,
 901                               GL_TEXTURE_2D,
 902                               previous_texture,
 903                               0);
 904     for (SkRegion::Iterator it(region); !it.done(); it.next()) {
 905       const SkIRect& rect = it.rect();
 906       gl_->CopyTexSubImage2D(GL_TEXTURE_2D,
 907                              0,
 908                              rect.x(),
 909                              rect.y(),
 910                              rect.x(),
 911                              rect.y(),
 912                              rect.width(),
 913                              rect.height());
 914     }
 915     gl_->Flush();
 916   }
 917 }
 918
 919 GLuint GLHelper::CreateTexture() {
 920   GLuint texture = 0u;
 921   gl_->GenTextures(1, &texture);
 922   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 923   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 924   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 925   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 926   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 927   return texture;
 928 }
 929
 930 void GLHelper::DeleteTexture(GLuint texture_id) {
 931   gl_->DeleteTextures(1, &texture_id);
 932 }
 933
 934 uint32 GLHelper::InsertSyncPoint() { return gl_->InsertSyncPointCHROMIUM(); }
 935
 936 void GLHelper::WaitSyncPoint(uint32 sync_point) {
 937   gl_->WaitSyncPointCHROMIUM(sync_point);
 938 }
 939
 940 gpu::MailboxHolder GLHelper::ProduceMailboxHolderFromTexture(
 941     GLuint texture_id) {
 942   gpu::Mailbox mailbox;
 943   gl_->GenMailboxCHROMIUM(mailbox.name);
 944   gl_->ProduceTextureDirectCHROMIUM(texture_id, GL_TEXTURE_2D, mailbox.name);
 945   return gpu::MailboxHolder(mailbox, GL_TEXTURE_2D, InsertSyncPoint());
 946 }
 947
 948 GLuint GLHelper::ConsumeMailboxToTexture(const gpu::Mailbox& mailbox,
 949                                          uint32 sync_point) {
 950   if (mailbox.IsZero())
 951     return 0;
 952   if (sync_point)
 953     WaitSyncPoint(sync_point);
 954   GLuint texture =
 955       gl_->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
 956   return texture;
 957 }
 958
 959 void GLHelper::ResizeTexture(GLuint texture, const gfx::Size& size) {
 960   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 961   gl_->TexImage2D(GL_TEXTURE_2D,
 962                   0,
 963                   GL_RGB,
 964                   size.width(),
 965                   size.height(),
 966                   0,
 967                   GL_RGB,
 968                   GL_UNSIGNED_BYTE,
 969                   NULL);
 970 }
 971
 972 void GLHelper::CopyTextureSubImage(GLuint texture, const gfx::Rect& rect) {
 973   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 974   gl_->CopyTexSubImage2D(GL_TEXTURE_2D,
 975                          0,
 976                          rect.x(),
 977                          rect.y(),
 978                          rect.x(),
 979                          rect.y(),
 980                          rect.width(),
 981                          rect.height());
 982 }
 983
 984 void GLHelper::CopyTextureFullImage(GLuint texture, const gfx::Size& size) {
 985   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
 986   gl_->CopyTexImage2D(
 987       GL_TEXTURE_2D, 0, GL_RGB, 0, 0, size.width(), size.height(), 0);
 988 }
 989
 990 void GLHelper::Flush() {
 991   gl_->Flush();
 992 }
 993
 994 void GLHelper::CopyTextureToImpl::ReadbackPlane(
 995     TextureFrameBufferPair* source,
 996     const scoped_refptr<media::VideoFrame>& target,
 997     int plane,
 998     int size_shift,
 999     const gfx::Rect& dst_subrect,
1000     ReadbackSwizzle swizzle,
1001     const base::Callback<void(bool)>& callback) {
1002   gl_->BindFramebuffer(GL_FRAMEBUFFER, source->framebuffer());
1003   size_t offset = target->stride(plane) * (dst_subrect.y() >> size_shift) +
1004       (dst_subrect.x() >> size_shift);
1005   ReadbackAsync(source->size(),
1006                 dst_subrect.width() >> size_shift,
1007                 target->stride(plane),
1008                 target->data(plane) + offset,
1009                 (swizzle == kSwizzleBGRA) ? GL_BGRA_EXT : GL_RGBA,
1010                 GL_UNSIGNED_BYTE,
1011                 4,
1012                 callback);
1013 }
1014
1015 const float GLHelper::CopyTextureToImpl::kRGBtoYColorWeights[] = {
1016     0.257f, 0.504f, 0.098f, 0.0625f};
1017 const float GLHelper::CopyTextureToImpl::kRGBtoUColorWeights[] = {
1018     -0.148f, -0.291f, 0.439f, 0.5f};
1019 const float GLHelper::CopyTextureToImpl::kRGBtoVColorWeights[] = {
1020     0.439f, -0.368f, -0.071f, 0.5f};
1021 const float GLHelper::CopyTextureToImpl::kRGBtoGrayscaleColorWeights[] = {
1022     0.213f, 0.715f, 0.072f, 0.0f};
1023
1024 // YUV readback constructors. Initiates the main scaler pipeline and
1025 // one planar scaler for each of the Y, U and V planes.
1026 GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUVImpl(
1027     GLES2Interface* gl,
1028     CopyTextureToImpl* copy_impl,
1029     GLHelperScaling* scaler_impl,
1030     GLHelper::ScalerQuality quality,
1031     const gfx::Size& src_size,
1032     const gfx::Rect& src_subrect,
1033     const gfx::Size& dst_size,
1034     const gfx::Rect& dst_subrect,
1035     bool flip_vertically,
1036     ReadbackSwizzle swizzle)
1037     : gl_(gl),
1038       copy_impl_(copy_impl),
1039       dst_size_(dst_size),
1040       dst_subrect_(dst_subrect),
1041       swizzle_(swizzle),
1042       scaler_(gl,
1043               scaler_impl->CreateScaler(quality,
1044                                         src_size,
1045                                         src_subrect,
1046                                         dst_subrect.size(),
1047                                         flip_vertically,
1048                                         false)),
1049       y_(gl,
1050          scaler_impl->CreatePlanarScaler(
1051              dst_subrect.size(),
1052              gfx::Rect(0,
1053                        0,
1054                        (dst_subrect.width() + 3) & ~3,
1055                        dst_subrect.height()),
1056              gfx::Size((dst_subrect.width() + 3) / 4, dst_subrect.height()),
1057              false,
1058              (swizzle == kSwizzleBGRA),
1059              kRGBtoYColorWeights)),
1060       u_(gl,
1061          scaler_impl->CreatePlanarScaler(
1062              dst_subrect.size(),
1063              gfx::Rect(0,
1064                        0,
1065                        (dst_subrect.width() + 7) & ~7,
1066                        (dst_subrect.height() + 1) & ~1),
1067              gfx::Size((dst_subrect.width() + 7) / 8,
1068                        (dst_subrect.height() + 1) / 2),
1069              false,
1070              (swizzle == kSwizzleBGRA),
1071              kRGBtoUColorWeights)),
1072       v_(gl,
1073          scaler_impl->CreatePlanarScaler(
1074              dst_subrect.size(),
1075              gfx::Rect(0,
1076                        0,
1077                        (dst_subrect.width() + 7) & ~7,
1078                        (dst_subrect.height() + 1) & ~1),
1079              gfx::Size((dst_subrect.width() + 7) / 8,
1080                        (dst_subrect.height() + 1) / 2),
1081              false,
1082              (swizzle == kSwizzleBGRA),
1083              kRGBtoVColorWeights)) {
1084   DCHECK(!(dst_size.width() & 1));
1085   DCHECK(!(dst_size.height() & 1));
1086   DCHECK(!(dst_subrect.width() & 1));
1087   DCHECK(!(dst_subrect.height() & 1));
1088   DCHECK(!(dst_subrect.x() & 1));
1089   DCHECK(!(dst_subrect.y() & 1));
1090 }
1091
1092 static void CallbackKeepingVideoFrameAlive(
1093     scoped_refptr<media::VideoFrame> video_frame,
1094     const base::Callback<void(bool)>& callback,
1095     bool success) {
1096   callback.Run(success);
1097 }
1098
1099 void GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUV(
1100     const gpu::Mailbox& mailbox,
1101     uint32 sync_point,
1102     const scoped_refptr<media::VideoFrame>& target,
1103     const base::Callback<void(bool)>& callback) {
1104   GLuint mailbox_texture =
1105       copy_impl_->ConsumeMailboxToTexture(mailbox, sync_point);
1106
1107   // Scale texture to right size.
1108   scaler_.Scale(mailbox_texture);
1109   gl_->DeleteTextures(1, &mailbox_texture);
1110
1111   // Convert the scaled texture in to Y, U and V planes.
1112   y_.Scale(scaler_.texture());
1113   u_.Scale(scaler_.texture());
1114   v_.Scale(scaler_.texture());
1115
1116   if (target->coded_size() != dst_size_) {
1117     DCHECK(target->coded_size() == dst_size_);
1118     LOG(ERROR) << "ReadbackYUV size error!";
1119     callback.Run(false);
1120     return;
1121   }
1122
1123   // Read back planes, one at a time. Keep the video frame alive while doing the
1124   // readback.
1125   copy_impl_->ReadbackPlane(y_.texture_and_framebuffer(),
1126                             target,
1127                             media::VideoFrame::kYPlane,
1128                             0,
1129                             dst_subrect_,
1130                             swizzle_,
1131                             base::Bind(&nullcallback));
1132   copy_impl_->ReadbackPlane(u_.texture_and_framebuffer(),
1133                             target,
1134                             media::VideoFrame::kUPlane,
1135                             1,
1136                             dst_subrect_,
1137                             swizzle_,
1138                             base::Bind(&nullcallback));
1139   copy_impl_->ReadbackPlane(
1140       v_.texture_and_framebuffer(),
1141       target,
1142       media::VideoFrame::kVPlane,
1143       1,
1144       dst_subrect_,
1145       swizzle_,
1146       base::Bind(&CallbackKeepingVideoFrameAlive, target, callback));
1147   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
1148   media::LetterboxYUV(target.get(), dst_subrect_);
1149 }
1150
1151 // YUV readback constructors. Initiates the main scaler pipeline and
1152 // one planar scaler for each of the Y, U and V planes.
1153 GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV_MRT(
1154     GLES2Interface* gl,
1155     CopyTextureToImpl* copy_impl,
1156     GLHelperScaling* scaler_impl,
1157     GLHelper::ScalerQuality quality,
1158     const gfx::Size& src_size,
1159     const gfx::Rect& src_subrect,
1160     const gfx::Size& dst_size,
1161     const gfx::Rect& dst_subrect,
1162     bool flip_vertically,
1163     ReadbackSwizzle swizzle)
1164     : gl_(gl),
1165       copy_impl_(copy_impl),
1166       dst_size_(dst_size),
1167       dst_subrect_(dst_subrect),
1168       quality_(quality),
1169       swizzle_(swizzle),
1170       scaler_(gl,
1171               scaler_impl->CreateScaler(quality,
1172                                         src_size,
1173                                         src_subrect,
1174                                         dst_subrect.size(),
1175                                         false,
1176                                         false)),
1177       pass1_shader_(scaler_impl->CreateYuvMrtShader(
1178           dst_subrect.size(),
1179           gfx::Rect(0, 0, (dst_subrect.width() + 3) & ~3, dst_subrect.height()),
1180           gfx::Size((dst_subrect.width() + 3) / 4, dst_subrect.height()),
1181           flip_vertically,
1182           (swizzle == kSwizzleBGRA),
1183           GLHelperScaling::SHADER_YUV_MRT_PASS1)),
1184       pass2_shader_(scaler_impl->CreateYuvMrtShader(
1185           gfx::Size((dst_subrect.width() + 3) / 4, dst_subrect.height()),
1186           gfx::Rect(0,
1187                     0,
1188                     (dst_subrect.width() + 7) / 8 * 2,
1189                     dst_subrect.height()),
1190           gfx::Size((dst_subrect.width() + 7) / 8,
1191                     (dst_subrect.height() + 1) / 2),
1192           false,
1193           (swizzle == kSwizzleBGRA),
1194           GLHelperScaling::SHADER_YUV_MRT_PASS2)),
1195       y_(gl, gfx::Size((dst_subrect.width() + 3) / 4, dst_subrect.height())),
1196       uv_(gl),
1197       u_(gl,
1198          gfx::Size((dst_subrect.width() + 7) / 8,
1199                    (dst_subrect.height() + 1) / 2)),
1200       v_(gl,
1201          gfx::Size((dst_subrect.width() + 7) / 8,
1202                    (dst_subrect.height() + 1) / 2)) {
1203
1204   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl, uv_);
1205   gl->TexImage2D(GL_TEXTURE_2D,
1206                  0,
1207                  GL_RGBA,
1208                  (dst_subrect.width() + 3) / 4,
1209                  dst_subrect.height(),
1210                  0,
1211                  GL_RGBA,
1212                  GL_UNSIGNED_BYTE,
1213                  NULL);
1214
1215   DCHECK(!(dst_size.width() & 1));
1216   DCHECK(!(dst_size.height() & 1));
1217   DCHECK(!(dst_subrect.width() & 1));
1218   DCHECK(!(dst_subrect.height() & 1));
1219   DCHECK(!(dst_subrect.x() & 1));
1220   DCHECK(!(dst_subrect.y() & 1));
1221 }
1222
1223 void GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV(
1224     const gpu::Mailbox& mailbox,
1225     uint32 sync_point,
1226     const scoped_refptr<media::VideoFrame>& target,
1227     const base::Callback<void(bool)>& callback) {
1228   GLuint mailbox_texture =
1229       copy_impl_->ConsumeMailboxToTexture(mailbox, sync_point);
1230
1231   GLuint texture;
1232   if (quality_ == GLHelper::SCALER_QUALITY_FAST) {
1233     // Optimization: SCALER_QUALITY_FAST is just a single bilinear
1234     // pass, which pass1_shader_ can do just as well, so let's skip
1235     // the actual scaling in that case.
1236     texture = mailbox_texture;
1237   } else {
1238     // Scale texture to right size.
1239     scaler_.Scale(mailbox_texture);
1240     texture = scaler_.texture();
1241   }
1242
1243   std::vector<GLuint> outputs(2);
1244   // Convert the scaled texture in to Y, U and V planes.
1245   outputs[0] = y_.texture();
1246   outputs[1] = uv_;
1247   pass1_shader_->Execute(texture, outputs);
1248
1249   gl_->DeleteTextures(1, &mailbox_texture);
1250
1251   outputs[0] = u_.texture();
1252   outputs[1] = v_.texture();
1253   pass2_shader_->Execute(uv_, outputs);
1254
1255   if (target->coded_size() != dst_size_) {
1256     DCHECK(target->coded_size() == dst_size_);
1257     LOG(ERROR) << "ReadbackYUV size error!";
1258     callback.Run(false);
1259     return;
1260   }
1261
1262   // Read back planes, one at a time.
1263   copy_impl_->ReadbackPlane(&y_,
1264                             target,
1265                             media::VideoFrame::kYPlane,
1266                             0,
1267                             dst_subrect_,
1268                             swizzle_,
1269                             base::Bind(&nullcallback));
1270   copy_impl_->ReadbackPlane(&u_,
1271                             target,
1272                             media::VideoFrame::kUPlane,
1273                             1,
1274                             dst_subrect_,
1275                             swizzle_,
1276                             base::Bind(&nullcallback));
1277   copy_impl_->ReadbackPlane(
1278       &v_,
1279       target,
1280       media::VideoFrame::kVPlane,
1281       1,
1282       dst_subrect_,
1283       swizzle_,
1284       base::Bind(&CallbackKeepingVideoFrameAlive, target, callback));
1285   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
1286   media::LetterboxYUV(target.get(), dst_subrect_);
1287 }
1288
1289 bool GLHelper::IsReadbackConfigSupported(SkColorType color_type) {
1290   DCHECK(readback_support_.get());
1291   GLenum format, type;
1292   size_t bytes_per_pixel;
1293   FormatSupport support = readback_support_->GetReadbackConfig(
1294       color_type, false, &format, &type, &bytes_per_pixel);
1295
1296   return (support == GLHelperReadbackSupport::SUPPORTED);
1297 }
1298
1299 ReadbackYUVInterface* GLHelper::CopyTextureToImpl::CreateReadbackPipelineYUV(
1300     GLHelper::ScalerQuality quality,
1301     const gfx::Size& src_size,
1302     const gfx::Rect& src_subrect,
1303     const gfx::Size& dst_size,
1304     const gfx::Rect& dst_subrect,
1305     bool flip_vertically,
1306     bool use_mrt) {
1307   helper_->InitScalerImpl();
1308   // Just query if the best readback configuration needs a swizzle In
1309   // ReadbackPlane() we will choose GL_RGBA/GL_BGRA_EXT based on swizzle
1310   GLenum format, type;
1311   size_t bytes_per_pixel;
1312   FormatSupport supported = GetReadbackConfig(
1313       kRGBA_8888_SkColorType, true, &format, &type, &bytes_per_pixel);
1314   DCHECK((format == GL_RGBA || format == GL_BGRA_EXT) &&
1315          type == GL_UNSIGNED_BYTE);
1316
1317   ReadbackSwizzle swizzle = kSwizzleNone;
1318   if (supported == GLHelperReadbackSupport::SWIZZLE)
1319     swizzle = kSwizzleBGRA;
1320
1321   if (max_draw_buffers_ >= 2 && use_mrt) {
1322     return new ReadbackYUV_MRT(gl_,
1323                                this,
1324                                helper_->scaler_impl_.get(),
1325                                quality,
1326                                src_size,
1327                                src_subrect,
1328                                dst_size,
1329                                dst_subrect,
1330                                flip_vertically,
1331                                swizzle);
1332   }
1333   return new ReadbackYUVImpl(gl_,
1334                              this,
1335                              helper_->scaler_impl_.get(),
1336                              quality,
1337                              src_size,
1338                              src_subrect,
1339                              dst_size,
1340                              dst_subrect,
1341                              flip_vertically,
1342                              swizzle);
1343 }
1344
1345 ReadbackYUVInterface* GLHelper::CreateReadbackPipelineYUV(
1346     ScalerQuality quality,
1347     const gfx::Size& src_size,
1348     const gfx::Rect& src_subrect,
1349     const gfx::Size& dst_size,
1350     const gfx::Rect& dst_subrect,
1351     bool flip_vertically,
1352     bool use_mrt) {
1353   InitCopyTextToImpl();
1354   return copy_texture_to_impl_->CreateReadbackPipelineYUV(quality,
1355                                                           src_size,
1356                                                           src_subrect,
1357                                                           dst_size,
1358                                                           dst_subrect,
1359                                                           flip_vertically,
1360                                                           use_mrt);
1361 }
1362
1363 }  // namespace content