| // 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 "components/display_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 "components/display_compositor/gl_helper_readback_support.h" |
| #include "components/display_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 "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 { |
| public: |
| explicit ScopedFlush(gpu::gles2::GLES2Interface* gl) : gl_(gl) {} |
| |
| ~ScopedFlush() { gl_->Flush(); } |
| |
| private: |
| gpu::gles2::GLES2Interface* gl_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ScopedFlush); |
| }; |
| |
| // Helper class for allocating and holding an RGBA texture of a given |
| // size and an associated framebuffer. |
| class TextureFrameBufferPair { |
| public: |
| TextureFrameBufferPair(GLES2Interface* gl, gfx::Size size) |
| : texture_(gl), framebuffer_(gl), size_(size) { |
| display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder( |
| gl, texture_); |
| gl->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0, |
| GL_RGBA, GL_UNSIGNED_BYTE, NULL); |
| display_compositor::ScopedFramebufferBinder<GL_FRAMEBUFFER> |
| framebuffer_binder(gl, framebuffer_); |
| gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| GL_TEXTURE_2D, texture_, 0); |
| } |
| |
| GLuint texture() const { return texture_.id(); } |
| GLuint framebuffer() const { return framebuffer_.id(); } |
| gfx::Size size() const { return size_; } |
| |
| private: |
| display_compositor::ScopedTexture texture_; |
| display_compositor::ScopedFramebuffer framebuffer_; |
| gfx::Size size_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TextureFrameBufferPair); |
| }; |
| |
| // Helper class for holding a scaler, a texture for the output of that |
| // scaler and an associated frame buffer. This is inteded to be used |
| // when the output of a scaler is to be sent to a readback. |
| class ScalerHolder { |
| public: |
| ScalerHolder(GLES2Interface* gl, |
| display_compositor::GLHelper::ScalerInterface* scaler) |
| : texture_and_framebuffer_(gl, scaler->DstSize()), scaler_(scaler) {} |
| |
| void Scale(GLuint src_texture) { |
| scaler_->Scale(src_texture, texture_and_framebuffer_.texture()); |
| } |
| |
| display_compositor::GLHelper::ScalerInterface* scaler() const { |
| return scaler_.get(); |
| } |
| TextureFrameBufferPair* texture_and_framebuffer() { |
| return &texture_and_framebuffer_; |
| } |
| GLuint texture() const { return texture_and_framebuffer_.texture(); } |
| |
| private: |
| TextureFrameBufferPair texture_and_framebuffer_; |
| std::unique_ptr<display_compositor::GLHelper::ScalerInterface> scaler_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ScalerHolder); |
| }; |
| |
| } // namespace |
| |
| namespace display_compositor { |
| typedef GLHelperReadbackSupport::FormatSupport FormatSupport; |
| |
| // Implements GLHelper::CropScaleReadbackAndCleanTexture and encapsulates |
| // the data needed for it. |
| class GLHelper::CopyTextureToImpl |
| : public base::SupportsWeakPtr<GLHelper::CopyTextureToImpl> { |
| public: |
| CopyTextureToImpl(GLES2Interface* gl, |
| gpu::ContextSupport* context_support, |
| GLHelper* helper) |
| : gl_(gl), |
| context_support_(context_support), |
| helper_(helper), |
| flush_(gl), |
| max_draw_buffers_(0) { |
| const GLubyte* extensions = gl_->GetString(GL_EXTENSIONS); |
| if (!extensions) |
| return; |
| std::string extensions_string = |
| " " + std::string(reinterpret_cast<const char*>(extensions)) + " "; |
| if (extensions_string.find(" GL_EXT_draw_buffers ") != std::string::npos) { |
| gl_->GetIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &max_draw_buffers_); |
| } |
| } |
| ~CopyTextureToImpl() { CancelRequests(); } |
| |
| GLuint ConsumeMailboxToTexture(const gpu::Mailbox& mailbox, |
| const gpu::SyncToken& sync_token) { |
| return helper_->ConsumeMailboxToTexture(mailbox, sync_token); |
| } |
| |
| void CropScaleReadbackAndCleanTexture( |
| GLuint src_texture, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| unsigned char* out, |
| const SkColorType out_color_type, |
| const base::Callback<void(bool)>& callback, |
| GLHelper::ScalerQuality quality); |
| |
| void ReadbackTextureSync(GLuint texture, |
| const gfx::Rect& src_rect, |
| unsigned char* out, |
| SkColorType format); |
| |
| void ReadbackTextureAsync(GLuint texture, |
| const gfx::Size& dst_size, |
| unsigned char* out, |
| SkColorType color_type, |
| const base::Callback<void(bool)>& callback); |
| |
| // Reads back bytes from the currently bound frame buffer. |
| // Note that dst_size is specified in bytes, not pixels. |
| void ReadbackAsync( |
| 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, |
| 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); |
| |
| ReadbackYUVInterface* CreateReadbackPipelineYUV( |
| GLHelper::ScalerQuality quality, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| bool flip_vertically, |
| bool use_mrt); |
| |
| // Returns the maximum number of draw buffers available, |
| // 0 if GL_EXT_draw_buffers is not available. |
| GLint MaxDrawBuffers() const { return max_draw_buffers_; } |
| |
| FormatSupport GetReadbackConfig(SkColorType color_type, |
| bool can_swizzle, |
| GLenum* format, |
| GLenum* type, |
| size_t* bytes_per_pixel); |
| |
| private: |
| // A single request to CropScaleReadbackAndCleanTexture. |
| // The main thread can cancel the request, before it's handled by the helper |
| // thread, by resetting the texture and pixels fields. Alternatively, the |
| // thread marks that it handles the request by resetting the pixels field |
| // (meaning it guarantees that the callback with be called). |
| // In either case, the callback must be called exactly once, and the texture |
| // must be deleted by the main thread gl. |
| struct Request { |
| Request(const gfx::Size& size_, |
| int32_t bytes_per_row_, |
| int32_t row_stride_bytes_, |
| unsigned char* pixels_, |
| const base::Callback<void(bool)>& callback_) |
| : done(false), |
| size(size_), |
| bytes_per_row(bytes_per_row_), |
| row_stride_bytes(row_stride_bytes_), |
| pixels(pixels_), |
| callback(callback_), |
| buffer(0), |
| query(0) {} |
| |
| bool done; |
| bool result; |
| gfx::Size size; |
| int bytes_per_row; |
| int row_stride_bytes; |
| unsigned char* pixels; |
| base::Callback<void(bool)> callback; |
| GLuint buffer; |
| GLuint query; |
| }; |
| |
| // We must take care to call the callbacks last, as they may |
| // end up destroying the gl_helper and make *this invalid. |
| // We stick the finished requests in a stack object that calls |
| // the callbacks when it goes out of scope. |
| class FinishRequestHelper { |
| public: |
| FinishRequestHelper() {} |
| ~FinishRequestHelper() { |
| while (!requests_.empty()) { |
| Request* request = requests_.front(); |
| requests_.pop(); |
| request->callback.Run(request->result); |
| delete request; |
| } |
| } |
| void Add(Request* r) { requests_.push(r); } |
| |
| private: |
| std::queue<Request*> requests_; |
| DISALLOW_COPY_AND_ASSIGN(FinishRequestHelper); |
| }; |
| |
| // A readback pipeline that also converts the data to YUV before |
| // reading it back. |
| class ReadbackYUVImpl : public ReadbackYUVInterface { |
| public: |
| ReadbackYUVImpl(GLES2Interface* gl, |
| CopyTextureToImpl* copy_impl, |
| 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 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_; |
| ScalerHolder scaler_; |
| ScalerHolder y_; |
| ScalerHolder u_; |
| ScalerHolder v_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ReadbackYUVImpl); |
| }; |
| |
| // A readback pipeline that also converts the data to YUV before |
| // reading it back. This one uses Multiple Render Targets, which |
| // may not be supported on all platforms. |
| class ReadbackYUV_MRT : public ReadbackYUVInterface { |
| public: |
| ReadbackYUV_MRT(GLES2Interface* gl, |
| CopyTextureToImpl* copy_impl, |
| 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 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_; |
| ReadbackSwizzle swizzle_; |
| ScalerHolder scaler_; |
| std::unique_ptr<display_compositor::GLHelperScaling::ShaderInterface> |
| pass1_shader_; |
| std::unique_ptr<display_compositor::GLHelperScaling::ShaderInterface> |
| pass2_shader_; |
| TextureFrameBufferPair y_; |
| ScopedTexture uv_; |
| TextureFrameBufferPair u_; |
| TextureFrameBufferPair v_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ReadbackYUV_MRT); |
| }; |
| |
| // Copies the block of pixels specified with |src_subrect| from |src_texture|, |
| // scales it to |dst_size|, writes it into a texture, and returns its ID. |
| // |src_size| is the size of |src_texture|. |
| GLuint ScaleTexture(GLuint src_texture, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| bool vertically_flip_texture, |
| bool swizzle, |
| SkColorType color_type, |
| GLHelper::ScalerQuality quality); |
| |
| // Converts each four consecutive pixels of the source texture into one pixel |
| // in the result texture with each pixel channel representing the grayscale |
| // color of one of the four original pixels: |
| // R1G1B1A1 R2G2B2A2 R3G3B3A3 R4G4B4A4 -> X1X2X3X4 |
| // The resulting texture is still an RGBA texture (which is ~4 times narrower |
| // than the original). If rendered directly, it wouldn't show anything useful, |
| // but the data in it can be used to construct a grayscale image. |
| // |encoded_texture_size| is the exact size of the resulting RGBA texture. It |
| // is equal to src_size.width()/4 rounded upwards. Some channels in the last |
| // pixel ((-src_size.width()) % 4) to be exact) are padding and don't contain |
| // useful data. |
| // If swizzle is set to true, the transformed pixels are reordered: |
| // R1G1B1A1 R2G2B2A2 R3G3B3A3 R4G4B4A4 -> X3X2X1X4. |
| GLuint EncodeTextureAsGrayscale(GLuint src_texture, |
| const gfx::Size& src_size, |
| gfx::Size* const encoded_texture_size, |
| bool vertically_flip_texture, |
| bool swizzle); |
| |
| static void nullcallback(bool success) {} |
| void ReadbackDone(Request* request, int bytes_per_pixel); |
| void FinishRequest(Request* request, |
| bool result, |
| FinishRequestHelper* helper); |
| void CancelRequests(); |
| |
| static const float kRGBtoYColorWeights[]; |
| static const float kRGBtoUColorWeights[]; |
| static const float kRGBtoVColorWeights[]; |
| static const float kRGBtoGrayscaleColorWeights[]; |
| |
| GLES2Interface* gl_; |
| gpu::ContextSupport* context_support_; |
| GLHelper* helper_; |
| |
| // A scoped flush that will ensure all resource deletions are flushed when |
| // this object is destroyed. Must be declared before other Scoped* fields. |
| ScopedFlush flush_; |
| |
| std::queue<Request*> request_queue_; |
| GLint max_draw_buffers_; |
| }; |
| |
| GLHelper::ScalerInterface* GLHelper::CreateScaler(ScalerQuality quality, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| bool vertically_flip_texture, |
| bool swizzle) { |
| InitScalerImpl(); |
| return scaler_impl_->CreateScaler(quality, src_size, src_subrect, dst_size, |
| vertically_flip_texture, swizzle); |
| } |
| |
| GLuint GLHelper::CopyTextureToImpl::ScaleTexture( |
| GLuint src_texture, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| bool vertically_flip_texture, |
| bool swizzle, |
| SkColorType color_type, |
| GLHelper::ScalerQuality quality) { |
| GLuint dst_texture = 0u; |
| gl_->GenTextures(1, &dst_texture); |
| { |
| GLenum format = GL_RGBA, type = GL_UNSIGNED_BYTE; |
| ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture); |
| |
| // Use GL_RGBA for destination/temporary texture unless we're working with |
| // 16-bit data |
| if (color_type == kRGB_565_SkColorType) { |
| format = GL_RGB; |
| type = GL_UNSIGNED_SHORT_5_6_5; |
| } |
| |
| gl_->TexImage2D(GL_TEXTURE_2D, 0, format, dst_size.width(), |
| dst_size.height(), 0, format, type, NULL); |
| } |
| std::unique_ptr<ScalerInterface> scaler( |
| helper_->CreateScaler(quality, src_size, src_subrect, dst_size, |
| vertically_flip_texture, swizzle)); |
| scaler->Scale(src_texture, dst_texture); |
| return dst_texture; |
| } |
| |
| GLuint GLHelper::CopyTextureToImpl::EncodeTextureAsGrayscale( |
| GLuint src_texture, |
| const gfx::Size& src_size, |
| gfx::Size* const encoded_texture_size, |
| bool vertically_flip_texture, |
| bool swizzle) { |
| GLuint dst_texture = 0u; |
| gl_->GenTextures(1, &dst_texture); |
| // The size of the encoded texture. |
| *encoded_texture_size = |
| gfx::Size((src_size.width() + 3) / 4, src_size.height()); |
| { |
| ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture); |
| gl_->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, encoded_texture_size->width(), |
| encoded_texture_size->height(), 0, GL_RGBA, |
| GL_UNSIGNED_BYTE, NULL); |
| } |
| |
| helper_->InitScalerImpl(); |
| std::unique_ptr<ScalerInterface> grayscale_scaler( |
| helper_->scaler_impl_.get()->CreatePlanarScaler( |
| src_size, |
| gfx::Rect(0, 0, (src_size.width() + 3) & ~3, src_size.height()), |
| *encoded_texture_size, vertically_flip_texture, swizzle, |
| kRGBtoGrayscaleColorWeights)); |
| grayscale_scaler->Scale(src_texture, dst_texture); |
| return dst_texture; |
| } |
| |
| void GLHelper::CopyTextureToImpl::ReadbackAsync( |
| const gfx::Size& dst_size, |
| int32_t bytes_per_row, |
| int32_t row_stride_bytes, |
| unsigned char* out, |
| GLenum format, |
| GLenum type, |
| size_t bytes_per_pixel, |
| const base::Callback<void(bool)>& callback) { |
| TRACE_EVENT0("gpu.capture", "GLHelper::CopyTextureToImpl::ReadbackAsync"); |
| Request* request = |
| new Request(dst_size, bytes_per_row, row_stride_bytes, out, callback); |
| request_queue_.push(request); |
| request->buffer = 0u; |
| |
| gl_->GenBuffers(1, &request->buffer); |
| gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, request->buffer); |
| gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, |
| bytes_per_pixel * dst_size.GetArea(), NULL, GL_STREAM_READ); |
| |
| request->query = 0u; |
| gl_->GenQueriesEXT(1, &request->query); |
| gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, request->query); |
| gl_->ReadPixels(0, 0, dst_size.width(), dst_size.height(), format, type, |
| NULL); |
| gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM); |
| gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0); |
| context_support_->SignalQuery( |
| request->query, base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(), |
| request, bytes_per_pixel)); |
| } |
| |
| void GLHelper::CopyTextureToImpl::CropScaleReadbackAndCleanTexture( |
| GLuint src_texture, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| unsigned char* out, |
| const SkColorType out_color_type, |
| const base::Callback<void(bool)>& callback, |
| GLHelper::ScalerQuality quality) { |
| GLenum format, type; |
| size_t bytes_per_pixel; |
| SkColorType readback_color_type = out_color_type; |
| // Single-component textures are not supported by all GPUs, so we implement |
| // kAlpha_8_SkColorType support here via a special encoding (see below) using |
| // a 32-bit texture to represent an 8-bit image. |
| // Thus we use generic 32-bit readback in this case. |
| if (out_color_type == kAlpha_8_SkColorType) { |
| readback_color_type = kRGBA_8888_SkColorType; |
| } |
| |
| FormatSupport supported = GetReadbackConfig(readback_color_type, true, |
| &format, &type, &bytes_per_pixel); |
| |
| if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) { |
| callback.Run(false); |
| return; |
| } |
| |
| GLuint texture = src_texture; |
| |
| // Scale texture if needed |
| // Optimization: SCALER_QUALITY_FAST is just a single bilinear pass, which we |
| // can do just as well in EncodeTextureAsGrayscale, which we will do if |
| // out_color_type is kAlpha_8_SkColorType, so let's skip the scaling step |
| // in that case. |
| bool scale_texture = out_color_type != kAlpha_8_SkColorType || |
| quality != GLHelper::SCALER_QUALITY_FAST; |
| if (scale_texture) { |
| // Don't swizzle during the scale step for kAlpha_8_SkColorType. |
| // We will swizzle in the encode step below if needed. |
| bool scale_swizzle = out_color_type == kAlpha_8_SkColorType |
| ? false |
| : supported == GLHelperReadbackSupport::SWIZZLE; |
| texture = ScaleTexture(src_texture, src_size, src_subrect, dst_size, true, |
| scale_swizzle, out_color_type == kAlpha_8_SkColorType |
| ? kN32_SkColorType |
| : out_color_type, |
| quality); |
| DCHECK(texture); |
| } |
| |
| gfx::Size readback_texture_size = dst_size; |
| // Encode texture to grayscale if needed. |
| if (out_color_type == kAlpha_8_SkColorType) { |
| // Do the vertical flip here if we haven't already done it when we scaled |
| // the texture. |
| bool encode_as_grayscale_vertical_flip = !scale_texture; |
| // EncodeTextureAsGrayscale by default creates a texture which should be |
| // read back as RGBA, so need to swizzle if the readback format is BGRA. |
| bool encode_as_grayscale_swizzle = format == GL_BGRA_EXT; |
| GLuint tmp_texture = EncodeTextureAsGrayscale( |
| texture, dst_size, &readback_texture_size, |
| encode_as_grayscale_vertical_flip, encode_as_grayscale_swizzle); |
| // If the scaled texture was created - delete it |
| if (scale_texture) |
| gl_->DeleteTextures(1, &texture); |
| texture = tmp_texture; |
| DCHECK(texture); |
| } |
| |
| // Readback the pixels of the resulting texture |
| ScopedFramebuffer dst_framebuffer(gl_); |
| ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_, |
| dst_framebuffer); |
| ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture); |
| gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, |
| texture, 0); |
| |
| int32_t bytes_per_row = out_color_type == kAlpha_8_SkColorType |
| ? dst_size.width() |
| : dst_size.width() * bytes_per_pixel; |
| |
| ReadbackAsync(readback_texture_size, bytes_per_row, bytes_per_row, out, |
| format, type, bytes_per_pixel, callback); |
| gl_->DeleteTextures(1, &texture); |
| } |
| |
| void GLHelper::CopyTextureToImpl::ReadbackTextureSync(GLuint texture, |
| const gfx::Rect& src_rect, |
| unsigned char* out, |
| SkColorType color_type) { |
| GLenum format, type; |
| size_t bytes_per_pixel; |
| FormatSupport supported = |
| GetReadbackConfig(color_type, false, &format, &type, &bytes_per_pixel); |
| if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) { |
| return; |
| } |
| |
| ScopedFramebuffer dst_framebuffer(gl_); |
| ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_, |
| dst_framebuffer); |
| ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture); |
| gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, |
| texture, 0); |
| gl_->ReadPixels(src_rect.x(), src_rect.y(), src_rect.width(), |
| src_rect.height(), format, type, out); |
| } |
| |
| void GLHelper::CopyTextureToImpl::ReadbackTextureAsync( |
| GLuint texture, |
| const gfx::Size& dst_size, |
| unsigned char* out, |
| SkColorType color_type, |
| const base::Callback<void(bool)>& callback) { |
| GLenum format, type; |
| size_t bytes_per_pixel; |
| FormatSupport supported = |
| GetReadbackConfig(color_type, false, &format, &type, &bytes_per_pixel); |
| if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) { |
| callback.Run(false); |
| return; |
| } |
| |
| ScopedFramebuffer dst_framebuffer(gl_); |
| ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_, |
| dst_framebuffer); |
| ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture); |
| gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, |
| texture, 0); |
| ReadbackAsync(dst_size, dst_size.width() * bytes_per_pixel, |
| dst_size.width() * bytes_per_pixel, out, format, type, |
| bytes_per_pixel, callback); |
| } |
| |
| GLuint GLHelper::CopyTextureToImpl::CopyAndScaleTexture( |
| GLuint src_texture, |
| const gfx::Size& src_size, |
| const gfx::Size& dst_size, |
| bool vertically_flip_texture, |
| GLHelper::ScalerQuality quality) { |
| return ScaleTexture(src_texture, src_size, gfx::Rect(src_size), dst_size, |
| vertically_flip_texture, false, |
| kRGBA_8888_SkColorType, // GL_RGBA |
| quality); |
| } |
| |
| void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request, |
| int bytes_per_pixel) { |
| TRACE_EVENT0("gpu.capture", |
| "GLHelper::CopyTextureToImpl::CheckReadbackFramebufferComplete"); |
| finished_request->done = true; |
| |
| FinishRequestHelper finish_request_helper; |
| |
| // We process transfer requests in the order they were received, regardless |
| // of the order we get the callbacks in. |
| while (!request_queue_.empty()) { |
| Request* request = request_queue_.front(); |
| if (!request->done) { |
| break; |
| } |
| |
| bool result = false; |
| if (request->buffer != 0) { |
| gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, request->buffer); |
| unsigned char* data = static_cast<unsigned char*>(gl_->MapBufferCHROMIUM( |
| GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY)); |
| if (data) { |
| result = true; |
| if (request->bytes_per_row == request->size.width() * bytes_per_pixel && |
| request->bytes_per_row == request->row_stride_bytes) { |
| memcpy(request->pixels, data, |
| request->size.GetArea() * bytes_per_pixel); |
| } else { |
| unsigned char* out = request->pixels; |
| for (int y = 0; y < request->size.height(); y++) { |
| memcpy(out, data, request->bytes_per_row); |
| out += request->row_stride_bytes; |
| data += request->size.width() * bytes_per_pixel; |
| } |
| } |
| gl_->UnmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM); |
| } |
| gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0); |
| } |
| FinishRequest(request, result, &finish_request_helper); |
| } |
| } |
| |
| void GLHelper::CopyTextureToImpl::FinishRequest( |
| Request* request, |
| bool result, |
| FinishRequestHelper* finish_request_helper) { |
| TRACE_EVENT0("gpu.capture", "GLHelper::CopyTextureToImpl::FinishRequest"); |
| DCHECK(request_queue_.front() == request); |
| request_queue_.pop(); |
| request->result = result; |
| ScopedFlush flush(gl_); |
| if (request->query != 0) { |
| gl_->DeleteQueriesEXT(1, &request->query); |
| request->query = 0; |
| } |
| if (request->buffer != 0) { |
| gl_->DeleteBuffers(1, &request->buffer); |
| request->buffer = 0; |
| } |
| finish_request_helper->Add(request); |
| } |
| |
| void GLHelper::CopyTextureToImpl::CancelRequests() { |
| FinishRequestHelper finish_request_helper; |
| while (!request_queue_.empty()) { |
| Request* request = request_queue_.front(); |
| FinishRequest(request, false, &finish_request_helper); |
| } |
| } |
| |
| FormatSupport GLHelper::CopyTextureToImpl::GetReadbackConfig( |
| SkColorType color_type, |
| bool can_swizzle, |
| GLenum* format, |
| GLenum* type, |
| size_t* bytes_per_pixel) { |
| return helper_->readback_support_->GetReadbackConfig( |
| color_type, can_swizzle, format, type, bytes_per_pixel); |
| } |
| |
| GLHelper::GLHelper(GLES2Interface* gl, gpu::ContextSupport* context_support) |
| : gl_(gl), |
| context_support_(context_support), |
| readback_support_(new GLHelperReadbackSupport(gl)) {} |
| |
| GLHelper::~GLHelper() {} |
| |
| void GLHelper::CropScaleReadbackAndCleanTexture( |
| GLuint src_texture, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| unsigned char* out, |
| const SkColorType out_color_type, |
| const base::Callback<void(bool)>& callback, |
| GLHelper::ScalerQuality quality) { |
| InitCopyTextToImpl(); |
| copy_texture_to_impl_->CropScaleReadbackAndCleanTexture( |
| src_texture, src_size, src_subrect, dst_size, out, out_color_type, |
| callback, quality); |
| } |
| |
| void GLHelper::CropScaleReadbackAndCleanMailbox( |
| const gpu::Mailbox& src_mailbox, |
| const gpu::SyncToken& sync_token, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| unsigned char* out, |
| const SkColorType out_color_type, |
| const base::Callback<void(bool)>& callback, |
| GLHelper::ScalerQuality quality) { |
| GLuint mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_token); |
| CropScaleReadbackAndCleanTexture(mailbox_texture, src_size, src_subrect, |
| dst_size, out, out_color_type, callback, |
| quality); |
| gl_->DeleteTextures(1, &mailbox_texture); |
| } |
| |
| void GLHelper::ReadbackTextureSync(GLuint texture, |
| const gfx::Rect& src_rect, |
| unsigned char* out, |
| SkColorType format) { |
| InitCopyTextToImpl(); |
| copy_texture_to_impl_->ReadbackTextureSync(texture, src_rect, out, format); |
| } |
| |
| void GLHelper::ReadbackTextureAsync( |
| GLuint texture, |
| const gfx::Size& dst_size, |
| unsigned char* out, |
| SkColorType color_type, |
| const base::Callback<void(bool)>& callback) { |
| InitCopyTextToImpl(); |
| copy_texture_to_impl_->ReadbackTextureAsync(texture, dst_size, out, |
| color_type, callback); |
| } |
| |
| GLuint GLHelper::CopyTexture(GLuint texture, const gfx::Size& size) { |
| InitCopyTextToImpl(); |
| return copy_texture_to_impl_->CopyAndScaleTexture( |
| texture, size, size, false, GLHelper::SCALER_QUALITY_FAST); |
| } |
| |
| GLuint GLHelper::CopyAndScaleTexture(GLuint texture, |
| const gfx::Size& src_size, |
| const gfx::Size& dst_size, |
| bool vertically_flip_texture, |
| ScalerQuality quality) { |
| InitCopyTextToImpl(); |
| return copy_texture_to_impl_->CopyAndScaleTexture( |
| texture, src_size, dst_size, vertically_flip_texture, quality); |
| } |
| |
| GLuint GLHelper::CompileShaderFromSource(const GLchar* source, GLenum type) { |
| GLuint shader = gl_->CreateShader(type); |
| GLint length = strlen(source); |
| gl_->ShaderSource(shader, 1, &source, &length); |
| gl_->CompileShader(shader); |
| GLint compile_status = 0; |
| gl_->GetShaderiv(shader, GL_COMPILE_STATUS, &compile_status); |
| if (!compile_status) { |
| GLint log_length = 0; |
| gl_->GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length); |
| if (log_length) { |
| std::unique_ptr<GLchar[]> log(new GLchar[log_length]); |
| GLsizei returned_log_length = 0; |
| gl_->GetShaderInfoLog(shader, log_length, &returned_log_length, |
| log.get()); |
| LOG(ERROR) << std::string(log.get(), returned_log_length); |
| } |
| gl_->DeleteShader(shader); |
| return 0; |
| } |
| return shader; |
| } |
| |
| void GLHelper::InitCopyTextToImpl() { |
| // Lazily initialize |copy_texture_to_impl_| |
| if (!copy_texture_to_impl_) |
| copy_texture_to_impl_.reset( |
| new CopyTextureToImpl(gl_, context_support_, this)); |
| } |
| |
| void GLHelper::InitScalerImpl() { |
| // Lazily initialize |scaler_impl_| |
| if (!scaler_impl_) |
| scaler_impl_.reset(new GLHelperScaling(gl_, this)); |
| } |
| |
| GLint GLHelper::MaxDrawBuffers() { |
| InitCopyTextToImpl(); |
| return copy_texture_to_impl_->MaxDrawBuffers(); |
| } |
| |
| void GLHelper::CopySubBufferDamage(GLenum target, |
| GLuint texture, |
| GLuint previous_texture, |
| const SkRegion& new_damage, |
| const SkRegion& old_damage) { |
| SkRegion region(old_damage); |
| if (region.op(new_damage, SkRegion::kDifference_Op)) { |
| ScopedFramebuffer dst_framebuffer(gl_); |
| ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_, |
| dst_framebuffer); |
| gl_->BindTexture(target, texture); |
| gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, |
| previous_texture, 0); |
| for (SkRegion::Iterator it(region); !it.done(); it.next()) { |
| const SkIRect& rect = it.rect(); |
| gl_->CopyTexSubImage2D(target, 0, rect.x(), rect.y(), rect.x(), rect.y(), |
| rect.width(), rect.height()); |
| } |
| gl_->BindTexture(target, 0); |
| gl_->Flush(); |
| } |
| } |
| |
| GLuint GLHelper::CreateTexture() { |
| GLuint texture = 0u; |
| gl_->GenTextures(1, &texture); |
| display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder( |
| gl_, texture); |
| gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| return texture; |
| } |
| |
| void GLHelper::DeleteTexture(GLuint texture_id) { |
| gl_->DeleteTextures(1, &texture_id); |
| } |
| |
| void GLHelper::GenerateSyncToken(gpu::SyncToken* sync_token) { |
| const uint64_t fence_sync = gl_->InsertFenceSyncCHROMIUM(); |
| gl_->ShallowFlushCHROMIUM(); |
| gl_->GenSyncTokenCHROMIUM(fence_sync, sync_token->GetData()); |
| } |
| |
| void GLHelper::WaitSyncToken(const gpu::SyncToken& sync_token) { |
| gl_->WaitSyncTokenCHROMIUM(sync_token.GetConstData()); |
| } |
| |
| gpu::MailboxHolder GLHelper::ProduceMailboxHolderFromTexture( |
| GLuint texture_id) { |
| gpu::Mailbox mailbox; |
| gl_->GenMailboxCHROMIUM(mailbox.name); |
| gl_->ProduceTextureDirectCHROMIUM(texture_id, GL_TEXTURE_2D, mailbox.name); |
| |
| gpu::SyncToken sync_token; |
| GenerateSyncToken(&sync_token); |
| |
| return gpu::MailboxHolder(mailbox, sync_token, GL_TEXTURE_2D); |
| } |
| |
| GLuint GLHelper::ConsumeMailboxToTexture(const gpu::Mailbox& mailbox, |
| const gpu::SyncToken& sync_token) { |
| if (mailbox.IsZero()) |
| return 0; |
| if (sync_token.HasData()) |
| WaitSyncToken(sync_token); |
| GLuint texture = |
| gl_->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name); |
| return texture; |
| } |
| |
| void GLHelper::ResizeTexture(GLuint texture, const gfx::Size& size) { |
| display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder( |
| gl_, texture); |
| gl_->TexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.width(), size.height(), 0, |
| GL_RGB, GL_UNSIGNED_BYTE, NULL); |
| } |
| |
| void GLHelper::CopyTextureSubImage(GLuint texture, const gfx::Rect& rect) { |
| display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder( |
| gl_, texture); |
| gl_->CopyTexSubImage2D(GL_TEXTURE_2D, 0, rect.x(), rect.y(), rect.x(), |
| rect.y(), rect.width(), rect.height()); |
| } |
| |
| void GLHelper::CopyTextureFullImage(GLuint texture, const gfx::Size& size) { |
| display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder( |
| gl_, texture); |
| gl_->CopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, size.width(), |
| size.height(), 0); |
| } |
| |
| void GLHelper::Flush() { |
| gl_->Flush(); |
| } |
| |
| void GLHelper::InsertOrderingBarrier() { |
| gl_->OrderingBarrierCHROMIUM(); |
| } |
| |
| void GLHelper::CopyTextureToImpl::ReadbackPlane( |
| TextureFrameBufferPair* source, |
| 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 = row_stride_bytes * (paste_rect.y() >> size_shift) + |
| (paste_rect.x() >> size_shift); |
| ReadbackAsync(source->size(), paste_rect.width() >> size_shift, |
| 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}; |
| const float GLHelper::CopyTextureToImpl::kRGBtoGrayscaleColorWeights[] = { |
| 0.213f, 0.715f, 0.072f, 0.0f}; |
| |
| // YUV readback constructors. Initiates the main scaler pipeline and |
| // one planar scaler for each of the Y, U and V planes. |
| GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUVImpl( |
| GLES2Interface* gl, |
| CopyTextureToImpl* copy_impl, |
| 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) |
| : gl_(gl), |
| copy_impl_(copy_impl), |
| dst_size_(dst_size), |
| swizzle_(swizzle), |
| scaler_(gl, |
| scaler_impl->CreateScaler(quality, |
| src_size, |
| src_subrect, |
| dst_size, |
| flip_vertically, |
| false)), |
| y_(gl, |
| scaler_impl->CreatePlanarScaler( |
| dst_size, |
| gfx::Rect(0, 0, (dst_size.width() + 3) & ~3, dst_size.height()), |
| gfx::Size((dst_size.width() + 3) / 4, dst_size.height()), |
| false, |
| (swizzle == kSwizzleBGRA), |
| kRGBtoYColorWeights)), |
| u_(gl, |
| scaler_impl->CreatePlanarScaler( |
| dst_size, |
| gfx::Rect(0, |
| 0, |
| (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), |
| kRGBtoUColorWeights)), |
| v_(gl, |
| scaler_impl->CreatePlanarScaler( |
| dst_size, |
| gfx::Rect(0, |
| 0, |
| (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)); |
| } |
| |
| void GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUV( |
| const gpu::Mailbox& mailbox, |
| const gpu::SyncToken& sync_token, |
| 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)) { |
| 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(), |
| 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); |
| } |
| |
| // 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, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| bool flip_vertically, |
| ReadbackSwizzle swizzle) |
| : gl_(gl), |
| copy_impl_(copy_impl), |
| dst_size_(dst_size), |
| quality_(quality), |
| swizzle_(swizzle), |
| scaler_(gl, |
| scaler_impl->CreateScaler(quality, |
| src_size, |
| src_subrect, |
| dst_size, |
| false, |
| false)), |
| pass1_shader_(scaler_impl->CreateYuvMrtShader( |
| dst_size, |
| gfx::Rect(0, 0, (dst_size.width() + 3) & ~3, dst_size.height()), |
| gfx::Size((dst_size.width() + 3) / 4, dst_size.height()), |
| flip_vertically, |
| (swizzle == kSwizzleBGRA), |
| GLHelperScaling::SHADER_YUV_MRT_PASS1)), |
| pass2_shader_(scaler_impl->CreateYuvMrtShader( |
| gfx::Size((dst_size.width() + 3) / 4, dst_size.height()), |
| gfx::Rect(0, 0, (dst_size.width() + 7) / 8 * 2, dst_size.height()), |
| gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2), |
| false, |
| (swizzle == kSwizzleBGRA), |
| GLHelperScaling::SHADER_YUV_MRT_PASS2)), |
| y_(gl, gfx::Size((dst_size.width() + 3) / 4, dst_size.height())), |
| uv_(gl), |
| u_(gl, |
| gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2)), |
| v_(gl, |
| gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2)) { |
| DCHECK(!(dst_size.width() & 1)); |
| DCHECK(!(dst_size.height() & 1)); |
| |
| display_compositor::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 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) { |
| // Optimization: SCALER_QUALITY_FAST is just a single bilinear |
| // pass, which pass1_shader_ can do just as well, so let's skip |
| // the actual scaling in that case. |
| texture = mailbox_texture; |
| } else { |
| // Scale texture to right size. |
| scaler_.Scale(mailbox_texture); |
| texture = scaler_.texture(); |
| } |
| |
| std::vector<GLuint> outputs(2); |
| // Convert the scaled texture in to Y, U and V planes. |
| outputs[0] = y_.texture(); |
| 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)) { |
| 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_, y_plane_row_stride_bytes, y_plane_data, 0, |
| paste_rect, swizzle_, base::Bind(&nullcallback)); |
| copy_impl_->ReadbackPlane(&u_, u_plane_row_stride_bytes, u_plane_data, 1, |
| paste_rect, swizzle_, base::Bind(&nullcallback)); |
| copy_impl_->ReadbackPlane(&v_, v_plane_row_stride_bytes, v_plane_data, 1, |
| paste_rect, swizzle_, callback); |
| gl_->BindFramebuffer(GL_FRAMEBUFFER, 0); |
| } |
| |
| 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); |
| } |
| |
| ReadbackYUVInterface* GLHelper::CopyTextureToImpl::CreateReadbackPipelineYUV( |
| GLHelper::ScalerQuality quality, |
| const gfx::Size& src_size, |
| const gfx::Rect& src_subrect, |
| const gfx::Size& dst_size, |
| bool flip_vertically, |
| bool use_mrt) { |
| helper_->InitScalerImpl(); |
| // Just query if the best readback configuration needs a swizzle In |
| // ReadbackPlane() we will choose GL_RGBA/GL_BGRA_EXT based on swizzle |
| GLenum format, type; |
| size_t bytes_per_pixel; |
| FormatSupport supported = GetReadbackConfig(kRGBA_8888_SkColorType, true, |
| &format, &type, &bytes_per_pixel); |
| DCHECK((format == GL_RGBA || format == GL_BGRA_EXT) && |
| type == GL_UNSIGNED_BYTE); |
| |
| ReadbackSwizzle swizzle = kSwizzleNone; |
| if (supported == GLHelperReadbackSupport::SWIZZLE) |
| swizzle = kSwizzleBGRA; |
| |
| if (max_draw_buffers_ >= 2 && use_mrt) { |
| return new ReadbackYUV_MRT(gl_, this, helper_->scaler_impl_.get(), quality, |
| src_size, src_subrect, dst_size, flip_vertically, |
| swizzle); |
| } |
| return new ReadbackYUVImpl(gl_, this, helper_->scaler_impl_.get(), quality, |
| src_size, src_subrect, dst_size, flip_vertically, |
| swizzle); |
| } |
| |
| ReadbackYUVInterface* GLHelper::CreateReadbackPipelineYUV( |
| ScalerQuality quality, |
| const gfx::Size& src_size, |
| 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 display_compositor |