Decouple GLHelper from media

content/browser/compositor/gl_helper.cc

 // Copyright (c) 2012 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 "content/browser/compositor/gl_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/compositor/gl_helper_readback_support.h"
 #include "content/browser/compositor/gl_helper_scaling.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
-#include "media/base/video_frame.h"
-#include "media/base/video_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace {
 
 class ScopedFlush {
@@ skipping 121 matching lines @@
       const gfx::Size& dst_size,
       int32_t bytes_per_row,     // generally dst_size.width() * 4
       int32_t row_stride_bytes,  // generally dst_size.width() * 4
       unsigned char* out,
       GLenum format,
       GLenum type,
       size_t bytes_per_pixel,
       const base::Callback<void(bool)>& callback);
 
   void ReadbackPlane(TextureFrameBufferPair* source,
-                     const scoped_refptr<media::VideoFrame>& target,
-                     int plane,
+                     int row_stride_bytes,
+                     unsigned char* data,
                      int size_shift,
                      const gfx::Rect& paste_rect,
                      ReadbackSwizzle swizzle,
                      const base::Callback<void(bool)>& callback);
 
   GLuint CopyAndScaleTexture(GLuint texture,
                              const gfx::Size& src_size,
                              const gfx::Size& dst_size,
                              bool vertically_flip_texture,
                              GLHelper::ScalerQuality quality);
@@ skipping 81 matching lines @@
                     GLHelperScaling* scaler_impl,
                     GLHelper::ScalerQuality quality,
                     const gfx::Size& src_size,
                     const gfx::Rect& src_subrect,
                     const gfx::Size& dst_size,
                     bool flip_vertically,
                     ReadbackSwizzle swizzle);
 
     void ReadbackYUV(const gpu::Mailbox& mailbox,
                      const gpu::SyncToken& sync_token,
-                     const scoped_refptr<media::VideoFrame>& target,
+                     const gfx::Rect& target_visible_rect,
+                     int y_plane_row_stride_bytes,
+                     unsigned char* y_plane_data,
+                     int u_plane_row_stride_bytes,
+                     unsigned char* u_plane_data,
+                     int v_plane_row_stride_bytes,
+                     unsigned char* v_plane_data,
                      const gfx::Point& paste_location,
                      const base::Callback<void(bool)>& callback) override;
 
     ScalerInterface* scaler() override { return scaler_.scaler(); }
 
    private:
     GLES2Interface* gl_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
     ReadbackSwizzle swizzle_;
@@ skipping 15 matching lines @@
                     GLHelperScaling* scaler_impl,
                     GLHelper::ScalerQuality quality,
                     const gfx::Size& src_size,
                     const gfx::Rect& src_subrect,
                     const gfx::Size& dst_size,
                     bool flip_vertically,
                     ReadbackSwizzle swizzle);
 
     void ReadbackYUV(const gpu::Mailbox& mailbox,
                      const gpu::SyncToken& sync_token,
-                     const scoped_refptr<media::VideoFrame>& target,
+                     const gfx::Rect& target_visible_rect,
+                     int y_plane_row_stride_bytes,
+                     unsigned char* y_plane_data,
+                     int u_plane_row_stride_bytes,
+                     unsigned char* u_plane_data,
+                     int v_plane_row_stride_bytes,
+                     unsigned char* v_plane_data,
                      const gfx::Point& paste_location,
                      const base::Callback<void(bool)>& callback) override;
 
     ScalerInterface* scaler() override { return scaler_.scaler(); }
 
    private:
     GLES2Interface* gl_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
     GLHelper::ScalerQuality quality_;
@@ skipping 603 matching lines @@
 void GLHelper::Flush() {
   gl_->Flush();
 }
 
 void GLHelper::InsertOrderingBarrier() {
   gl_->OrderingBarrierCHROMIUM();
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackPlane(
     TextureFrameBufferPair* source,
-    const scoped_refptr<media::VideoFrame>& target,
-    int plane,
+    int row_stride_bytes,
+    unsigned char* data,
     int size_shift,
     const gfx::Rect& paste_rect,
     ReadbackSwizzle swizzle,
     const base::Callback<void(bool)>& callback) {
   gl_->BindFramebuffer(GL_FRAMEBUFFER, source->framebuffer());
-  const size_t offset = target->stride(plane) * (paste_rect.y() >> size_shift) +
+  const size_t offset = row_stride_bytes * (paste_rect.y() >> size_shift) +
                         (paste_rect.x() >> size_shift);
   ReadbackAsync(source->size(), paste_rect.width() >> size_shift,
-                target->stride(plane), target->data(plane) + offset,
+                row_stride_bytes, data + offset,
                 (swizzle == kSwizzleBGRA) ? GL_BGRA_EXT : GL_RGBA,
                 GL_UNSIGNED_BYTE, 4, callback);
 }
 
 const float GLHelper::CopyTextureToImpl::kRGBtoYColorWeights[] = {
     0.257f, 0.504f, 0.098f, 0.0625f};
 const float GLHelper::CopyTextureToImpl::kRGBtoUColorWeights[] = {
     -0.148f, -0.291f, 0.439f, 0.5f};
 const float GLHelper::CopyTextureToImpl::kRGBtoVColorWeights[] = {
     0.439f, -0.368f, -0.071f, 0.5f};
@@ skipping 50 matching lines @@
                        (dst_size.width() + 7) & ~7,
                        (dst_size.height() + 1) & ~1),
              gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2),
              false,
              (swizzle == kSwizzleBGRA),
              kRGBtoVColorWeights)) {
   DCHECK(!(dst_size.width() & 1));
   DCHECK(!(dst_size.height() & 1));
 }
 
-static void CallbackKeepingVideoFrameAlive(
-    scoped_refptr<media::VideoFrame> video_frame,
-    const base::Callback<void(bool)>& callback,
-    bool success) {
-  callback.Run(success);
-}
-
 void GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUV(
     const gpu::Mailbox& mailbox,
     const gpu::SyncToken& sync_token,
-    const scoped_refptr<media::VideoFrame>& target,
+    const gfx::Rect& target_visible_rect,
+    int y_plane_row_stride_bytes,
+    unsigned char* y_plane_data,
+    int u_plane_row_stride_bytes,
+    unsigned char* u_plane_data,
+    int v_plane_row_stride_bytes,
+    unsigned char* v_plane_data,
     const gfx::Point& paste_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(!(paste_location.x() & 1));
   DCHECK(!(paste_location.y() & 1));
 
   GLuint mailbox_texture =
       copy_impl_->ConsumeMailboxToTexture(mailbox, sync_token);
 
   // Scale texture to right size.
   scaler_.Scale(mailbox_texture);
   gl_->DeleteTextures(1, &mailbox_texture);
 
   // Convert the scaled texture in to Y, U and V planes.
   y_.Scale(scaler_.texture());
   u_.Scale(scaler_.texture());
   v_.Scale(scaler_.texture());
 
   const gfx::Rect paste_rect(paste_location, dst_size_);
-  if (!target->visible_rect().Contains(paste_rect)) {
+  if (!target_visible_rect.Contains(paste_rect)) {
     LOG(DFATAL) << "Paste rect not inside VideoFrame's visible rect!";
     callback.Run(false);
     return;
   }
 
   // Read back planes, one at a time. Keep the video frame alive while doing the
   // readback.
-  copy_impl_->ReadbackPlane(y_.texture_and_framebuffer(), target,
-                            media::VideoFrame::kYPlane, 0, paste_rect, swizzle_,
-                            base::Bind(&nullcallback));
-  copy_impl_->ReadbackPlane(u_.texture_and_framebuffer(), target,
-                            media::VideoFrame::kUPlane, 1, paste_rect, swizzle_,
-                            base::Bind(&nullcallback));
-  copy_impl_->ReadbackPlane(
-      v_.texture_and_framebuffer(), target, media::VideoFrame::kVPlane, 1,
-      paste_rect, swizzle_,
-      base::Bind(&CallbackKeepingVideoFrameAlive, target, callback));
+  copy_impl_->ReadbackPlane(y_.texture_and_framebuffer(),
+                            y_plane_row_stride_bytes, y_plane_data, 0,
+                            paste_rect, swizzle_, base::Bind(&nullcallback));
+  copy_impl_->ReadbackPlane(u_.texture_and_framebuffer(),
+                            u_plane_row_stride_bytes, u_plane_data, 1,
+                            paste_rect, swizzle_, base::Bind(&nullcallback));
+  copy_impl_->ReadbackPlane(v_.texture_and_framebuffer(),
+                            v_plane_row_stride_bytes, v_plane_data, 1,
+                            paste_rect, swizzle_, callback);
   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
-  media::LetterboxYUV(target.get(), paste_rect);
 }
 
 // YUV readback constructors. Initiates the main scaler pipeline and
 // one planar scaler for each of the Y, U and V planes.
 GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV_MRT(
     GLES2Interface* gl,
     CopyTextureToImpl* copy_impl,
     GLHelperScaling* scaler_impl,
     GLHelper::ScalerQuality quality,
     const gfx::Size& src_size,
@@ skipping 37 matching lines @@
   DCHECK(!(dst_size.height() & 1));
 
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl, uv_);
   gl->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (dst_size.width() + 3) / 4,
                  dst_size.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV(
     const gpu::Mailbox& mailbox,
     const gpu::SyncToken& sync_token,
-    const scoped_refptr<media::VideoFrame>& target,
+    const gfx::Rect& target_visible_rect,
+    int y_plane_row_stride_bytes,
+    unsigned char* y_plane_data,
+    int u_plane_row_stride_bytes,
+    unsigned char* u_plane_data,
+    int v_plane_row_stride_bytes,
+    unsigned char* v_plane_data,
     const gfx::Point& paste_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(!(paste_location.x() & 1));
   DCHECK(!(paste_location.y() & 1));
 
   GLuint mailbox_texture =
       copy_impl_->ConsumeMailboxToTexture(mailbox, sync_token);
 
   GLuint texture;
   if (quality_ == GLHelper::SCALER_QUALITY_FAST) {
@@ skipping 13 matching lines @@
   outputs[1] = uv_;
   pass1_shader_->Execute(texture, outputs);
 
   gl_->DeleteTextures(1, &mailbox_texture);
 
   outputs[0] = u_.texture();
   outputs[1] = v_.texture();
   pass2_shader_->Execute(uv_, outputs);
 
   const gfx::Rect paste_rect(paste_location, dst_size_);
-  if (!target->visible_rect().Contains(paste_rect)) {
+  if (!target_visible_rect.Contains(paste_rect)) {
     LOG(DFATAL) << "Paste rect not inside VideoFrame's visible rect!";
     callback.Run(false);
     return;
   }
 
   // Read back planes, one at a time.
-  copy_impl_->ReadbackPlane(&y_, target, media::VideoFrame::kYPlane, 0,
+  copy_impl_->ReadbackPlane(&y_, y_plane_row_stride_bytes, y_plane_data, 0,
                             paste_rect, swizzle_, base::Bind(&nullcallback));
-  copy_impl_->ReadbackPlane(&u_, target, media::VideoFrame::kUPlane, 1,
+  copy_impl_->ReadbackPlane(&u_, u_plane_row_stride_bytes, u_plane_data, 1,
                             paste_rect, swizzle_, base::Bind(&nullcallback));
-  copy_impl_->ReadbackPlane(
-      &v_, target, media::VideoFrame::kVPlane, 1, paste_rect, swizzle_,
-      base::Bind(&CallbackKeepingVideoFrameAlive, target, callback));
+  copy_impl_->ReadbackPlane(&v_, v_plane_row_stride_bytes, v_plane_data, 1,
+                            paste_rect, swizzle_, callback);
   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
-  media::LetterboxYUV(target.get(), paste_rect);
 }
 
 bool GLHelper::IsReadbackConfigSupported(SkColorType color_type) {
   DCHECK(readback_support_.get());
   GLenum format, type;
   size_t bytes_per_pixel;
   FormatSupport support = readback_support_->GetReadbackConfig(
       color_type, false, &format, &type, &bytes_per_pixel);
 
   return (support == GLHelperReadbackSupport::SUPPORTED);
@@ skipping 36 matching lines @@
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool flip_vertically,
     bool use_mrt) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CreateReadbackPipelineYUV(
       quality, src_size, src_subrect, dst_size, flip_vertically, use_mrt);
 }
 
 }  // namespace content