cc/output/gl_renderer.cc - Issue 1535833002: Delete CC.

Unified Diff: cc/output/gl_renderer.cc

Issue 1535833002: Delete CC. (Closed) Base URL: git@github.com:domokit/mojo.git@moz-5

Patch Set: rebase Created 4 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: cc/output/gl_renderer.cc

diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc

deleted file mode 100644

index fe11f9dd792cfb8d0b95dba9bc416522a94ef9b0..0000000000000000000000000000000000000000

--- a/cc/output/gl_renderer.cc

+++ /dev/null

@@ -1,3332 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#include "cc/output/gl_renderer.h"

-#include <algorithm>

-#include <limits>

-#include <set>

-#include <string>

-#include <vector>

-#include "base/logging.h"

-#include "base/memory/scoped_ptr.h"

-#include "base/strings/string_split.h"

-#include "base/strings/string_util.h"

-#include "base/strings/stringprintf.h"

-#include "build/build_config.h"

-#include "base/trace_event/trace_event.h"

-#include "cc/base/math_util.h"

-#include "cc/output/compositor_frame.h"

-#include "cc/output/compositor_frame_metadata.h"

-#include "cc/output/context_provider.h"

-#include "cc/output/copy_output_request.h"

-#include "cc/output/dynamic_geometry_binding.h"

-#include "cc/output/gl_frame_data.h"

-#include "cc/output/output_surface.h"

-#include "cc/output/render_surface_filters.h"

-#include "cc/output/static_geometry_binding.h"

-#include "cc/quads/draw_polygon.h"

-#include "cc/quads/render_pass.h"

-#include "cc/quads/stream_video_draw_quad.h"

-#include "cc/quads/texture_draw_quad.h"

-#include "cc/resources/layer_quad.h"

-#include "cc/resources/scoped_resource.h"

-#include "cc/resources/texture_mailbox_deleter.h"

-#include "gpu/GLES2/gl2extchromium.h"

-#include "gpu/command_buffer/client/context_support.h"

-#include "gpu/command_buffer/client/gles2_interface.h"

-#include "gpu/command_buffer/common/gpu_memory_allocation.h"

-#include "third_party/skia/include/core/SkBitmap.h"

-#include "third_party/skia/include/core/SkColor.h"

-#include "third_party/skia/include/core/SkColorFilter.h"

-#include "third_party/skia/include/core/SkImage.h"

-#include "third_party/skia/include/core/SkSurface.h"

-#include "third_party/skia/include/gpu/GrContext.h"

-#include "third_party/skia/include/gpu/GrTexture.h"

-#include "third_party/skia/include/gpu/SkGrTexturePixelRef.h"

-#include "third_party/skia/include/gpu/gl/GrGLInterface.h"

-#include "ui/gfx/geometry/quad_f.h"

-#include "ui/gfx/geometry/rect_conversions.h"

-using gpu::gles2::GLES2Interface;

-namespace cc {

-namespace {

-bool NeedsIOSurfaceReadbackWorkaround() {

-#if defined(OS_MACOSX)

- // This isn't strictly required in DumpRenderTree-mode when Mesa is used,

- // but it doesn't seem to hurt.

- return true;

-#else

- return false;

-#endif

-Float4 UVTransform(const TextureDrawQuad* quad) {

- gfx::PointF uv0 = quad->uv_top_left;

- gfx::PointF uv1 = quad->uv_bottom_right;

- Float4 xform = {{uv0.x(), uv0.y(), uv1.x() - uv0.x(), uv1.y() - uv0.y()}};

- if (quad->flipped) {

- xform.data[1] = 1.0f - xform.data[1];

- xform.data[3] = -xform.data[3];

- }

- return xform;

-Float4 PremultipliedColor(SkColor color) {

- const float factor = 1.0f / 255.0f;

- const float alpha = SkColorGetA(color) * factor;

- Float4 result = {

- {SkColorGetR(color) * factor * alpha, SkColorGetG(color) * factor * alpha,

- SkColorGetB(color) * factor * alpha, alpha}};

- return result;

-SamplerType SamplerTypeFromTextureTarget(GLenum target) {

- switch (target) {

- case GL_TEXTURE_2D:

- return SAMPLER_TYPE_2D;

- case GL_TEXTURE_RECTANGLE_ARB:

- return SAMPLER_TYPE_2D_RECT;

- case GL_TEXTURE_EXTERNAL_OES:

- return SAMPLER_TYPE_EXTERNAL_OES;

- default:

- NOTREACHED();

- return SAMPLER_TYPE_2D;

- }

-BlendMode BlendModeFromSkXfermode(SkXfermode::Mode mode) {

- switch (mode) {

- case SkXfermode::kSrcOver_Mode:

- return BLEND_MODE_NORMAL;

- case SkXfermode::kScreen_Mode:

- return BLEND_MODE_SCREEN;

- case SkXfermode::kOverlay_Mode:

- return BLEND_MODE_OVERLAY;

- case SkXfermode::kDarken_Mode:

- return BLEND_MODE_DARKEN;

- case SkXfermode::kLighten_Mode:

- return BLEND_MODE_LIGHTEN;

- case SkXfermode::kColorDodge_Mode:

- return BLEND_MODE_COLOR_DODGE;

- case SkXfermode::kColorBurn_Mode:

- return BLEND_MODE_COLOR_BURN;

- case SkXfermode::kHardLight_Mode:

- return BLEND_MODE_HARD_LIGHT;

- case SkXfermode::kSoftLight_Mode:

- return BLEND_MODE_SOFT_LIGHT;

- case SkXfermode::kDifference_Mode:

- return BLEND_MODE_DIFFERENCE;

- case SkXfermode::kExclusion_Mode:

- return BLEND_MODE_EXCLUSION;

- case SkXfermode::kMultiply_Mode:

- return BLEND_MODE_MULTIPLY;

- case SkXfermode::kHue_Mode:

- return BLEND_MODE_HUE;

- case SkXfermode::kSaturation_Mode:

- return BLEND_MODE_SATURATION;

- case SkXfermode::kColor_Mode:

- return BLEND_MODE_COLOR;

- case SkXfermode::kLuminosity_Mode:

- return BLEND_MODE_LUMINOSITY;

- default:

- NOTREACHED();

- return BLEND_MODE_NONE;

- }

-// Smallest unit that impact anti-aliasing output. We use this to

-// determine when anti-aliasing is unnecessary.

-const float kAntiAliasingEpsilon = 1.0f / 1024.0f;

-// Block or crash if the number of pending sync queries reach this high as

-// something is seriously wrong on the service side if this happens.

-const size_t kMaxPendingSyncQueries = 16;

-} // anonymous namespace

-static GLint GetActiveTextureUnit(GLES2Interface* gl) {

- GLint active_unit = 0;

- gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);

- return active_unit;

-struct GLRenderer::PendingAsyncReadPixels {

- PendingAsyncReadPixels() : buffer(0) {}

- scoped_ptr<CopyOutputRequest> copy_request;

- base::CancelableClosure finished_read_pixels_callback;

- unsigned buffer;

- private:

- DISALLOW_COPY_AND_ASSIGN(PendingAsyncReadPixels);

-};

-class GLRenderer::SyncQuery {

- public:

- explicit SyncQuery(gpu::gles2::GLES2Interface* gl)

- : gl_(gl), query_id_(0u), is_pending_(false), weak_ptr_factory_(this) {

- gl_->GenQueriesEXT(1, &query_id_);

- }

- virtual ~SyncQuery() { gl_->DeleteQueriesEXT(1, &query_id_); }

- scoped_refptr<ResourceProvider::Fence> Begin() {

- DCHECK(!IsPending());

- // Invalidate weak pointer held by old fence.

- weak_ptr_factory_.InvalidateWeakPtrs();

- // Note: In case the set of drawing commands issued before End() do not

- // depend on the query, defer BeginQueryEXT call until Set() is called and

- // query is required.

- return make_scoped_refptr<ResourceProvider::Fence>(

- new Fence(weak_ptr_factory_.GetWeakPtr()));

- }

- void Set() {

- if (is_pending_)

- return;

- // Note: BeginQueryEXT on GL_COMMANDS_COMPLETED_CHROMIUM is effectively a

- // noop relative to GL, so it doesn't matter where it happens but we still

- // make sure to issue this command when Set() is called (prior to issuing

- // any drawing commands that depend on query), in case some future extension

- // can take advantage of this.

- gl_->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, query_id_);

- is_pending_ = true;

- }

- void End() {

- if (!is_pending_)

- return;

- gl_->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);

- }

- bool IsPending() {

- if (!is_pending_)

- return false;

- unsigned result_available = 1;

- gl_->GetQueryObjectuivEXT(

- query_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &result_available);

- is_pending_ = !result_available;

- return is_pending_;

- }

- void Wait() {

- if (!is_pending_)

- return;

- unsigned result = 0;

- gl_->GetQueryObjectuivEXT(query_id_, GL_QUERY_RESULT_EXT, &result);

- is_pending_ = false;

- }

- private:

- class Fence : public ResourceProvider::Fence {

- public:

- explicit Fence(base::WeakPtr<GLRenderer::SyncQuery> query)

- : query_(query) {}

- // Overridden from ResourceProvider::Fence:

- void Set() override {

- DCHECK(query_);

- query_->Set();

- }

- bool HasPassed() override { return !query_ || !query_->IsPending(); }

- void Wait() override {

- if (query_)

- query_->Wait();

- }

- private:

- ~Fence() override {}

- base::WeakPtr<SyncQuery> query_;

- DISALLOW_COPY_AND_ASSIGN(Fence);

- };

- gpu::gles2::GLES2Interface* gl_;

- unsigned query_id_;

- bool is_pending_;

- base::WeakPtrFactory<SyncQuery> weak_ptr_factory_;

- DISALLOW_COPY_AND_ASSIGN(SyncQuery);

-};

-scoped_ptr<GLRenderer> GLRenderer::Create(

- RendererClient* client,

- const RendererSettings* settings,

- OutputSurface* output_surface,

- ResourceProvider* resource_provider,

- TextureMailboxDeleter* texture_mailbox_deleter,

- int highp_threshold_min) {

- return make_scoped_ptr(new GLRenderer(client,

- settings,

- output_surface,

- resource_provider,

- texture_mailbox_deleter,

- highp_threshold_min));

-GLRenderer::GLRenderer(RendererClient* client,

- const RendererSettings* settings,

- OutputSurface* output_surface,

- ResourceProvider* resource_provider,

- TextureMailboxDeleter* texture_mailbox_deleter,

- int highp_threshold_min)

- : DirectRenderer(client, settings, output_surface, resource_provider),

- offscreen_framebuffer_id_(0),

- shared_geometry_quad_(QuadVertexRect()),

- gl_(output_surface->context_provider()->ContextGL()),

- context_support_(output_surface->context_provider()->ContextSupport()),

- texture_mailbox_deleter_(texture_mailbox_deleter),

- is_backbuffer_discarded_(false),

- is_scissor_enabled_(false),

- scissor_rect_needs_reset_(true),

- stencil_shadow_(false),

- blend_shadow_(false),

- highp_threshold_min_(highp_threshold_min),

- highp_threshold_cache_(0),

- use_sync_query_(false),

- on_demand_tile_raster_resource_id_(0),

- bound_geometry_(NO_BINDING) {

- DCHECK(gl_);

- DCHECK(context_support_);

- ContextProvider::Capabilities context_caps =

- output_surface_->context_provider()->ContextCapabilities();

- capabilities_.using_partial_swap =

- settings_->partial_swap_enabled && context_caps.gpu.post_sub_buffer;

- DCHECK(!context_caps.gpu.iosurface || context_caps.gpu.texture_rectangle);

- capabilities_.using_egl_image = context_caps.gpu.egl_image_external;

- capabilities_.max_texture_size = resource_provider_->max_texture_size();

- capabilities_.best_texture_format = resource_provider_->best_texture_format();

- // The updater can access textures while the GLRenderer is using them.

- capabilities_.allow_partial_texture_updates = true;

- capabilities_.using_image = context_caps.gpu.image;

- capabilities_.using_discard_framebuffer =

- context_caps.gpu.discard_framebuffer;

- capabilities_.allow_rasterize_on_demand = true;

- use_sync_query_ = context_caps.gpu.sync_query;

- use_blend_equation_advanced_ = context_caps.gpu.blend_equation_advanced;

- use_blend_equation_advanced_coherent_ =

- context_caps.gpu.blend_equation_advanced_coherent;

- InitializeSharedObjects();

-GLRenderer::~GLRenderer() {

- while (!pending_async_read_pixels_.empty()) {

- PendingAsyncReadPixels* pending_read = pending_async_read_pixels_.back();

- pending_read->finished_read_pixels_callback.Cancel();

- pending_async_read_pixels_.pop_back();

- }

- in_use_overlay_resources_.clear();

- CleanupSharedObjects();

-const RendererCapabilitiesImpl& GLRenderer::Capabilities() const {

- return capabilities_;

-void GLRenderer::DebugGLCall(GLES2Interface* gl,

- const char* command,

- const char* file,

- int line) {

- GLuint error = gl->GetError();

- if (error != GL_NO_ERROR)

- LOG(ERROR) << "GL command failed: File: " << file << "\n\tLine " << line

- << "\n\tcommand: " << command << ", error "

- << static_cast<int>(error) << "\n";

-void GLRenderer::DidChangeVisibility() {

- EnforceMemoryPolicy();

- context_support_->SetSurfaceVisible(visible());

-void GLRenderer::ReleaseRenderPassTextures() { render_pass_textures_.clear(); }

-void GLRenderer::DiscardPixels() {

- if (!capabilities_.using_discard_framebuffer)

- return;

- bool using_default_framebuffer =

- !current_framebuffer_lock_ &&

- output_surface_->capabilities().uses_default_gl_framebuffer;

- GLenum attachments[] = {static_cast<GLenum>(

- using_default_framebuffer ? GL_COLOR_EXT : GL_COLOR_ATTACHMENT0_EXT)};

- gl_->DiscardFramebufferEXT(

- GL_FRAMEBUFFER, arraysize(attachments), attachments);

-void GLRenderer::PrepareSurfaceForPass(

- DrawingFrame* frame,

- SurfaceInitializationMode initialization_mode,

- const gfx::Rect& render_pass_scissor) {

- switch (initialization_mode) {

- case SURFACE_INITIALIZATION_MODE_PRESERVE:

- EnsureScissorTestDisabled();

- return;

- case SURFACE_INITIALIZATION_MODE_FULL_SURFACE_CLEAR:

- EnsureScissorTestDisabled();

- DiscardPixels();

- ClearFramebuffer(frame);

- break;

- case SURFACE_INITIALIZATION_MODE_SCISSORED_CLEAR:

- SetScissorTestRect(render_pass_scissor);

- ClearFramebuffer(frame);

- break;

- }

-void GLRenderer::ClearFramebuffer(DrawingFrame* frame) {

- // On DEBUG builds, opaque render passes are cleared to blue to easily see

- // regions that were not drawn on the screen.

- if (frame->current_render_pass->has_transparent_background)

- GLC(gl_, gl_->ClearColor(0, 0, 0, 0));

- else

- GLC(gl_, gl_->ClearColor(0, 0, 1, 1));

- bool always_clear = false;

-#ifndef NDEBUG

- always_clear = true;

-#endif

- if (always_clear || frame->current_render_pass->has_transparent_background) {

- GLbitfield clear_bits = GL_COLOR_BUFFER_BIT;

- if (always_clear)

- clear_bits |= GL_STENCIL_BUFFER_BIT;

- gl_->Clear(clear_bits);

- }

-static ResourceProvider::ResourceId WaitOnResourceSyncPoints(

- ResourceProvider* resource_provider,

- ResourceProvider::ResourceId resource_id) {

- resource_provider->WaitSyncPointIfNeeded(resource_id);

- return resource_id;

-void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {

- TRACE_EVENT0("cc", "GLRenderer::BeginDrawingFrame");

- scoped_refptr<ResourceProvider::Fence> read_lock_fence;

- if (use_sync_query_) {

- // Block until oldest sync query has passed if the number of pending queries

- // ever reach kMaxPendingSyncQueries.

- if (pending_sync_queries_.size() >= kMaxPendingSyncQueries) {

- LOG(ERROR) << "Reached limit of pending sync queries.";

- pending_sync_queries_.front()->Wait();

- DCHECK(!pending_sync_queries_.front()->IsPending());

- }

- while (!pending_sync_queries_.empty()) {

- if (pending_sync_queries_.front()->IsPending())

- break;

- available_sync_queries_.push_back(pending_sync_queries_.take_front());

- }

- current_sync_query_ = available_sync_queries_.empty()

- ? make_scoped_ptr(new SyncQuery(gl_))

- : available_sync_queries_.take_front();

- read_lock_fence = current_sync_query_->Begin();

- } else {

- read_lock_fence =

- make_scoped_refptr(new ResourceProvider::SynchronousFence(gl_));

- }

- resource_provider_->SetReadLockFence(read_lock_fence.get());

- // Insert WaitSyncPointCHROMIUM on quad resources prior to drawing the frame,

- // so that drawing can proceed without GL context switching interruptions.

- DrawQuad::ResourceIteratorCallback wait_on_resource_syncpoints_callback =

- base::Bind(&WaitOnResourceSyncPoints, resource_provider_);

- for (const auto& pass : *frame->render_passes_in_draw_order) {

- for (const auto& quad : pass->quad_list)

- quad->IterateResources(wait_on_resource_syncpoints_callback);

- }

- // TODO(enne): Do we need to reinitialize all of this state per frame?

- ReinitializeGLState();

-void GLRenderer::DoNoOp() {

- GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, 0));

- GLC(gl_, gl_->Flush());

-void GLRenderer::DoDrawQuad(DrawingFrame* frame,

- const DrawQuad* quad,

- const gfx::QuadF* clip_region) {

- DCHECK(quad->rect.Contains(quad->visible_rect));

- if (quad->material != DrawQuad::TEXTURE_CONTENT) {

- FlushTextureQuadCache(SHARED_BINDING);

- }

- switch (quad->material) {

- case DrawQuad::INVALID:

- case DrawQuad::UNUSED_SPACE_FOR_PICTURE_CONTENT:

- NOTREACHED();

- break;

- case DrawQuad::CHECKERBOARD:

- DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad),

- clip_region);

- break;

- case DrawQuad::DEBUG_BORDER:

- DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));

- break;

- case DrawQuad::IO_SURFACE_CONTENT:

- DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad),

- clip_region);

- break;

- case DrawQuad::RENDER_PASS:

- DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad),

- clip_region);

- break;

- case DrawQuad::SOLID_COLOR:

- DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad),

- clip_region);

- break;

- case DrawQuad::STREAM_VIDEO_CONTENT:

- DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad),

- clip_region);

- break;

- case DrawQuad::SURFACE_CONTENT:

- // Surface content should be fully resolved to other quad types before

- // reaching a direct renderer.

- NOTREACHED();

- break;

- case DrawQuad::TEXTURE_CONTENT:

- EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad),

- clip_region);

- break;

- case DrawQuad::TILED_CONTENT:

- DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad), clip_region);

- break;

- case DrawQuad::YUV_VIDEO_CONTENT:

- DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad),

- clip_region);

- break;

- }

-void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,

- const CheckerboardDrawQuad* quad,

- const gfx::QuadF* clip_region) {

- // TODO(enne) For now since checkerboards shouldn't be part of a 3D

- // context, clipping regions aren't supported so we skip drawing them

- // if this becomes the case.

- if (clip_region) {

- return;

- }

- SetBlendEnabled(quad->ShouldDrawWithBlending());

- const TileCheckerboardProgram* program = GetTileCheckerboardProgram();

- DCHECK(program && (program->initialized() || IsContextLost()));

- SetUseProgram(program->program());

- SkColor color = quad->color;

- GLC(gl_,

- gl_->Uniform4f(program->fragment_shader().color_location(),

- SkColorGetR(color) * (1.0f / 255.0f),

- SkColorGetG(color) * (1.0f / 255.0f),

- SkColorGetB(color) * (1.0f / 255.0f),

- 1));

- const int kCheckerboardWidth = 16;

- float frequency = 1.0f / kCheckerboardWidth;

- gfx::Rect tile_rect = quad->rect;

- float tex_offset_x =

- static_cast<int>(tile_rect.x() / quad->scale) % kCheckerboardWidth;

- float tex_offset_y =

- static_cast<int>(tile_rect.y() / quad->scale) % kCheckerboardWidth;

- float tex_scale_x = tile_rect.width() / quad->scale;

- float tex_scale_y = tile_rect.height() / quad->scale;

- GLC(gl_,

- gl_->Uniform4f(program->fragment_shader().tex_transform_location(),

- tex_offset_x,

- tex_offset_y,

- tex_scale_x,

- tex_scale_y));

- GLC(gl_,

- gl_->Uniform1f(program->fragment_shader().frequency_location(),

- frequency));

- SetShaderOpacity(quad->opacity(),

- program->fragment_shader().alpha_location());

- DrawQuadGeometry(frame,

- quad->quadTransform(),

- quad->rect,

- program->vertex_shader().matrix_location());

-// This function does not handle 3D sorting right now, since the debug border

-// quads are just drawn as their original quads and not in split pieces. This

-// results in some debug border quads drawing over foreground quads.

-void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,

- const DebugBorderDrawQuad* quad) {

- SetBlendEnabled(quad->ShouldDrawWithBlending());

- static float gl_matrix[16];

- const DebugBorderProgram* program = GetDebugBorderProgram();

- DCHECK(program && (program->initialized() || IsContextLost()));

- SetUseProgram(program->program());

- // Use the full quad_rect for debug quads to not move the edges based on

- // partial swaps.

- gfx::Rect layer_rect = quad->rect;

- gfx::Transform render_matrix;

- QuadRectTransform(&render_matrix, quad->quadTransform(), layer_rect);

- GLRenderer::ToGLMatrix(&gl_matrix[0],

- frame->projection_matrix * render_matrix);

- GLC(gl_,

- gl_->UniformMatrix4fv(

- program->vertex_shader().matrix_location(), 1, false, &gl_matrix[0]));

- SkColor color = quad->color;

- float alpha = SkColorGetA(color) * (1.0f / 255.0f);

- GLC(gl_,

- gl_->Uniform4f(program->fragment_shader().color_location(),

- (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,

- (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,

- (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,

- alpha));

- GLC(gl_, gl_->LineWidth(quad->width));

- // The indices for the line are stored in the same array as the triangle

- // indices.

- GLC(gl_, gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));

-bool GLRenderer::CanApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {

- return use_blend_equation_advanced_ ||

- blend_mode == SkXfermode::kScreen_Mode ||

- blend_mode == SkXfermode::kSrcOver_Mode;

-void GLRenderer::ApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {

- DCHECK(CanApplyBlendModeUsingBlendFunc(blend_mode));

- // Any modes set here must be reset in RestoreBlendFuncToDefault

- if (use_blend_equation_advanced_) {

- GLenum equation = GL_FUNC_ADD;

- switch (blend_mode) {

- case SkXfermode::kScreen_Mode:

- equation = GL_SCREEN_KHR;

- break;

- case SkXfermode::kOverlay_Mode:

- equation = GL_OVERLAY_KHR;

- break;

- case SkXfermode::kDarken_Mode:

- equation = GL_DARKEN_KHR;

- break;

- case SkXfermode::kLighten_Mode:

- equation = GL_LIGHTEN_KHR;

- break;

- case SkXfermode::kColorDodge_Mode:

- equation = GL_COLORDODGE_KHR;

- break;

- case SkXfermode::kColorBurn_Mode:

- equation = GL_COLORBURN_KHR;

- break;

- case SkXfermode::kHardLight_Mode:

- equation = GL_HARDLIGHT_KHR;

- break;

- case SkXfermode::kSoftLight_Mode:

- equation = GL_SOFTLIGHT_KHR;

- break;

- case SkXfermode::kDifference_Mode:

- equation = GL_DIFFERENCE_KHR;

- break;

- case SkXfermode::kExclusion_Mode:

- equation = GL_EXCLUSION_KHR;

- break;

- case SkXfermode::kMultiply_Mode:

- equation = GL_MULTIPLY_KHR;

- break;

- case SkXfermode::kHue_Mode:

- equation = GL_HSL_HUE_KHR;

- break;

- case SkXfermode::kSaturation_Mode:

- equation = GL_HSL_SATURATION_KHR;

- break;

- case SkXfermode::kColor_Mode:

- equation = GL_HSL_COLOR_KHR;

- break;

- case SkXfermode::kLuminosity_Mode:

- equation = GL_HSL_LUMINOSITY_KHR;

- break;

- default:

- return;

- }

- GLC(gl_, gl_->BlendEquation(equation));

- } else {

- if (blend_mode == SkXfermode::kScreen_Mode) {

- GLC(gl_, gl_->BlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE));

- }

-void GLRenderer::RestoreBlendFuncToDefault(SkXfermode::Mode blend_mode) {

- if (blend_mode == SkXfermode::kSrcOver_Mode)

- return;

- if (use_blend_equation_advanced_) {

- GLC(gl_, gl_->BlendEquation(GL_FUNC_ADD));

- } else {

- GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));

- }

-// This takes a gfx::Rect and a clip region quad in the same space,

-// and returns a quad with the same proportions in the space -0.5->0.5.

-bool GetScaledRegion(const gfx::Rect& rect,

- const gfx::QuadF* clip,

- gfx::QuadF* scaled_region) {

- if (!clip)

- return false;

- gfx::PointF p1(((clip->p1().x() - rect.x()) / rect.width()) - 0.5f,

- ((clip->p1().y() - rect.y()) / rect.height()) - 0.5f);

- gfx::PointF p2(((clip->p2().x() - rect.x()) / rect.width()) - 0.5f,

- ((clip->p2().y() - rect.y()) / rect.height()) - 0.5f);

- gfx::PointF p3(((clip->p3().x() - rect.x()) / rect.width()) - 0.5f,

- ((clip->p3().y() - rect.y()) / rect.height()) - 0.5f);

- gfx::PointF p4(((clip->p4().x() - rect.x()) / rect.width()) - 0.5f,

- ((clip->p4().y() - rect.y()) / rect.height()) - 0.5f);

- *scaled_region = gfx::QuadF(p1, p2, p3, p4);

- return true;

-// This takes a gfx::Rect and a clip region quad in the same space,

-// and returns the proportional uv's in the space 0->1.

-bool GetScaledUVs(const gfx::Rect& rect, const gfx::QuadF* clip, float uvs[8]) {

- if (!clip)

- return false;

- uvs[0] = ((clip->p1().x() - rect.x()) / rect.width());

- uvs[1] = ((clip->p1().y() - rect.y()) / rect.height());

- uvs[2] = ((clip->p2().x() - rect.x()) / rect.width());

- uvs[3] = ((clip->p2().y() - rect.y()) / rect.height());

- uvs[4] = ((clip->p3().x() - rect.x()) / rect.width());

- uvs[5] = ((clip->p3().y() - rect.y()) / rect.height());

- uvs[6] = ((clip->p4().x() - rect.x()) / rect.width());

- uvs[7] = ((clip->p4().y() - rect.y()) / rect.height());

- return true;

-gfx::Rect GLRenderer::GetBackdropBoundingBoxForRenderPassQuad(

- DrawingFrame* frame,

- const RenderPassDrawQuad* quad,

- const gfx::Transform& contents_device_transform,

- const gfx::QuadF* clip_region,

- bool use_aa) {

- gfx::QuadF scaled_region;

- if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) {

- scaled_region = SharedGeometryQuad().BoundingBox();

- }

- gfx::Rect backdrop_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(

- contents_device_transform, scaled_region.BoundingBox()));

- if (!backdrop_rect.IsEmpty() && use_aa) {

- const int kOutsetForAntialiasing = 1;

- backdrop_rect.Inset(-kOutsetForAntialiasing, -kOutsetForAntialiasing);

- }

- backdrop_rect.Intersect(MoveFromDrawToWindowSpace(

- frame, frame->current_render_pass->output_rect));

- return backdrop_rect;

-scoped_ptr<ScopedResource> GLRenderer::GetBackdropTexture(

- const gfx::Rect& bounding_rect) {

- scoped_ptr<ScopedResource> device_background_texture =

- ScopedResource::Create(resource_provider_);

- // CopyTexImage2D fails when called on a texture having immutable storage.

- device_background_texture->Allocate(

- bounding_rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT, RGBA_8888);

- {

- ResourceProvider::ScopedWriteLockGL lock(resource_provider_,

- device_background_texture->id());

- GetFramebufferTexture(

- lock.texture_id(), device_background_texture->format(), bounding_rect);

- }

- return device_background_texture.Pass();

-void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,

- const RenderPassDrawQuad* quad,

- const gfx::QuadF* clip_region) {

- ScopedResource* contents_texture =

- render_pass_textures_.get(quad->render_pass_id);

- if (!contents_texture || !contents_texture->id())

- return;

- gfx::Transform quad_rect_matrix;

- QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);

- gfx::Transform contents_device_transform =

- frame->window_matrix * frame->projection_matrix * quad_rect_matrix;

- contents_device_transform.FlattenTo2d();

- // Can only draw surface if device matrix is invertible.

- if (!contents_device_transform.IsInvertible())

- return;

- gfx::QuadF surface_quad = SharedGeometryQuad();

- float edge[24];

- bool use_aa = settings_->allow_antialiasing &&

- ShouldAntialiasQuad(contents_device_transform, quad,

- settings_->force_antialiasing);

- SetupQuadForClippingAndAntialiasing(contents_device_transform, quad, use_aa,

- clip_region, &surface_quad, edge);

- SkXfermode::Mode blend_mode = quad->shared_quad_state->blend_mode;

- bool use_shaders_for_blending =

- !CanApplyBlendModeUsingBlendFunc(blend_mode) ||

- settings_->force_blending_with_shaders;

- scoped_ptr<ScopedResource> background_texture;

- skia::RefPtr<SkImage> background_image;

- gfx::Rect background_rect;

- if (use_shaders_for_blending) {

- // Compute a bounding box around the pixels that will be visible through

- // the quad.

- background_rect = GetBackdropBoundingBoxForRenderPassQuad(

- frame, quad, contents_device_transform, clip_region, use_aa);

- if (!background_rect.IsEmpty()) {

- // The pixels from the filtered background should completely replace the

- // current pixel values.

- if (blend_enabled())

- SetBlendEnabled(false);

- // Read the pixels in the bounding box into a buffer R.

- // This function allocates a texture, which should contribute to the

- // amount of memory used by render surfaces:

- // LayerTreeHost::CalculateMemoryForRenderSurfaces.

- background_texture = GetBackdropTexture(background_rect);

- }

- if (!background_texture) {

- // Something went wrong with reading the backdrop.

- DCHECK(!background_image);

- use_shaders_for_blending = false;

- } else if (background_image) {

- // Reset original background texture if there is not any mask

- if (!quad->mask_resource_id)

- background_texture.reset();

- }

- // Need original background texture for mask?

- bool mask_for_background =

- background_texture && // Have original background texture

- background_image && // Have filtered background texture

- quad->mask_resource_id; // Have mask texture

- SetBlendEnabled(

- !use_shaders_for_blending &&

- (quad->ShouldDrawWithBlending() || !IsDefaultBlendMode(blend_mode)));

- // TODO(senorblanco): Cache this value so that we don't have to do it for both

- // the surface and its replica. Apply filters to the contents texture.

- skia::RefPtr<SkImage> filter_image;

- SkScalar color_matrix[20];

- bool use_color_matrix = false;

- DCHECK(quad->filters.IsEmpty());

- scoped_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;

- unsigned mask_texture_id = 0;

- SamplerType mask_sampler = SAMPLER_TYPE_NA;

- if (quad->mask_resource_id) {

- mask_resource_lock.reset(new ResourceProvider::ScopedSamplerGL(

- resource_provider_, quad->mask_resource_id, GL_TEXTURE1, GL_LINEAR));

- mask_texture_id = mask_resource_lock->texture_id();

- mask_sampler = SamplerTypeFromTextureTarget(mask_resource_lock->target());

- }

- scoped_ptr<ResourceProvider::ScopedSamplerGL> contents_resource_lock;

- if (filter_image) {

- GrTexture* texture = filter_image->getTexture();

- DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));

- gl_->BindTexture(GL_TEXTURE_2D, texture->getTextureHandle());

- } else {

- contents_resource_lock =

- make_scoped_ptr(new ResourceProvider::ScopedSamplerGL(

- resource_provider_, contents_texture->id(), GL_LINEAR));

- DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),

- contents_resource_lock->target());

- }

- if (!use_shaders_for_blending) {

- if (!use_blend_equation_advanced_coherent_ && use_blend_equation_advanced_)

- GLC(gl_, gl_->BlendBarrierKHR());

- ApplyBlendModeUsingBlendFunc(blend_mode);

- }

- TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(

- gl_,

- &highp_threshold_cache_,

- highp_threshold_min_,

- quad->shared_quad_state->visible_content_rect.bottom_right());

- ShaderLocations locations;

- DCHECK_EQ(background_texture || background_image, use_shaders_for_blending);

- BlendMode shader_blend_mode = use_shaders_for_blending

- ? BlendModeFromSkXfermode(blend_mode)

- : BLEND_MODE_NONE;

- if (use_aa && mask_texture_id && !use_color_matrix) {

- const RenderPassMaskProgramAA* program = GetRenderPassMaskProgramAA(

- tex_coord_precision, mask_sampler,

- shader_blend_mode, mask_for_background);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- } else if (!use_aa && mask_texture_id && !use_color_matrix) {

- const RenderPassMaskProgram* program = GetRenderPassMaskProgram(

- tex_coord_precision, mask_sampler,

- shader_blend_mode, mask_for_background);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- } else if (use_aa && !mask_texture_id && !use_color_matrix) {

- const RenderPassProgramAA* program =

- GetRenderPassProgramAA(tex_coord_precision, shader_blend_mode);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- } else if (use_aa && mask_texture_id && use_color_matrix) {

- const RenderPassMaskColorMatrixProgramAA* program =

- GetRenderPassMaskColorMatrixProgramAA(

- tex_coord_precision, mask_sampler,

- shader_blend_mode, mask_for_background);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- } else if (use_aa && !mask_texture_id && use_color_matrix) {

- const RenderPassColorMatrixProgramAA* program =

- GetRenderPassColorMatrixProgramAA(tex_coord_precision,

- shader_blend_mode);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- } else if (!use_aa && mask_texture_id && use_color_matrix) {

- const RenderPassMaskColorMatrixProgram* program =

- GetRenderPassMaskColorMatrixProgram(

- tex_coord_precision, mask_sampler,

- shader_blend_mode, mask_for_background);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- } else if (!use_aa && !mask_texture_id && use_color_matrix) {

- const RenderPassColorMatrixProgram* program =

- GetRenderPassColorMatrixProgram(tex_coord_precision, shader_blend_mode);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- } else {

- const RenderPassProgram* program =

- GetRenderPassProgram(tex_coord_precision, shader_blend_mode);

- SetUseProgram(program->program());

- program->vertex_shader().FillLocations(&locations);

- program->fragment_shader().FillLocations(&locations);

- GLC(gl_, gl_->Uniform1i(locations.sampler, 0));

- }

- float tex_scale_x =

- quad->rect.width() / static_cast<float>(contents_texture->size().width());

- float tex_scale_y = quad->rect.height() /

- static_cast<float>(contents_texture->size().height());

- DCHECK_LE(tex_scale_x, 1.0f);

- DCHECK_LE(tex_scale_y, 1.0f);

- DCHECK(locations.tex_transform != -1 || IsContextLost());

- // Flip the content vertically in the shader, as the RenderPass input

- // texture is already oriented the same way as the framebuffer, but the

- // projection transform does a flip.

- GLC(gl_,

- gl_->Uniform4f(locations.tex_transform,

- 0.0f,

- tex_scale_y,

- tex_scale_x,

- -tex_scale_y));

- GLint last_texture_unit = 0;

- if (locations.mask_sampler != -1) {

- DCHECK_NE(locations.mask_tex_coord_scale, 1);

- DCHECK_NE(locations.mask_tex_coord_offset, 1);

- GLC(gl_, gl_->Uniform1i(locations.mask_sampler, 1));

- gfx::RectF mask_uv_rect = quad->MaskUVRect();

- if (mask_sampler != SAMPLER_TYPE_2D) {

- mask_uv_rect.Scale(quad->mask_texture_size.width(),

- quad->mask_texture_size.height());

- }

- // Mask textures are oriented vertically flipped relative to the framebuffer

- // and the RenderPass contents texture, so we flip the tex coords from the

- // RenderPass texture to find the mask texture coords.

- GLC(gl_,

- gl_->Uniform2f(locations.mask_tex_coord_offset,

- mask_uv_rect.x(),

- mask_uv_rect.bottom()));

- GLC(gl_,

- gl_->Uniform2f(locations.mask_tex_coord_scale,

- mask_uv_rect.width() / tex_scale_x,

- -mask_uv_rect.height() / tex_scale_y));

- last_texture_unit = 1;

- }

- if (locations.edge != -1)

- GLC(gl_, gl_->Uniform3fv(locations.edge, 8, edge));

- if (locations.viewport != -1) {

- float viewport[4] = {static_cast<float>(viewport_.x()),

- static_cast<float>(viewport_.y()),

- static_cast<float>(viewport_.width()),

- static_cast<float>(viewport_.height()), };

- GLC(gl_, gl_->Uniform4fv(locations.viewport, 1, viewport));

- }

- if (locations.color_matrix != -1) {

- float matrix[16];

- for (int i = 0; i < 4; ++i) {

- for (int j = 0; j < 4; ++j)

- matrix[i * 4 + j] = SkScalarToFloat(color_matrix[j * 5 + i]);

- }

- GLC(gl_,

- gl_->UniformMatrix4fv(locations.color_matrix, 1, false, matrix));

- }

- static const float kScale = 1.0f / 255.0f;

- if (locations.color_offset != -1) {

- float offset[4];

- for (int i = 0; i < 4; ++i)

- offset[i] = SkScalarToFloat(color_matrix[i * 5 + 4]) * kScale;

- GLC(gl_, gl_->Uniform4fv(locations.color_offset, 1, offset));

- }

- scoped_ptr<ResourceProvider::ScopedSamplerGL> shader_background_sampler_lock;

- if (locations.backdrop != -1) {

- DCHECK(background_texture || background_image);

- DCHECK_NE(locations.backdrop, 0);

- DCHECK_NE(locations.backdrop_rect, 0);

- GLC(gl_, gl_->Uniform1i(locations.backdrop, ++last_texture_unit));

- GLC(gl_,

- gl_->Uniform4f(locations.backdrop_rect,

- background_rect.x(),

- background_rect.y(),

- background_rect.width(),

- background_rect.height()));

- if (background_image) {

- GrTexture* texture = background_image->getTexture();

- GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0 + last_texture_unit));

- gl_->BindTexture(GL_TEXTURE_2D, texture->getTextureHandle());

- GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));

- if (mask_for_background)

- GLC(gl_, gl_->Uniform1i(locations.original_backdrop,

- ++last_texture_unit));

- }

- if (background_texture) {

- shader_background_sampler_lock = make_scoped_ptr(

- new ResourceProvider::ScopedSamplerGL(resource_provider_,

- background_texture->id(),

- GL_TEXTURE0 + last_texture_unit,

- GL_LINEAR));

- DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),

- shader_background_sampler_lock->target());

- }

- SetShaderOpacity(quad->opacity(), locations.alpha);

- SetShaderQuadF(surface_quad, locations.quad);

- DrawQuadGeometry(

- frame, quad->quadTransform(), quad->rect, locations.matrix);

- // Flush the compositor context before the filter bitmap goes out of

- // scope, so the draw gets processed before the filter texture gets deleted.

- if (filter_image)

- GLC(gl_, gl_->Flush());

- if (!use_shaders_for_blending)

- RestoreBlendFuncToDefault(blend_mode);

-struct SolidColorProgramUniforms {

- unsigned program;

- unsigned matrix_location;

- unsigned viewport_location;

- unsigned quad_location;

- unsigned edge_location;

- unsigned color_location;

-};

-template <class T>

-static void SolidColorUniformLocation(T program,

- SolidColorProgramUniforms* uniforms) {

- uniforms->program = program->program();

- uniforms->matrix_location = program->vertex_shader().matrix_location();

- uniforms->viewport_location = program->vertex_shader().viewport_location();

- uniforms->quad_location = program->vertex_shader().quad_location();

- uniforms->edge_location = program->vertex_shader().edge_location();

- uniforms->color_location = program->fragment_shader().color_location();

-namespace {

-// These functions determine if a quad, clipped by a clip_region contains

-// the entire {top|bottom|left|right} edge.

-bool is_top(const gfx::QuadF* clip_region, const DrawQuad* quad) {

- if (!quad->IsTopEdge())

- return false;

- if (!clip_region)

- return true;

- return std::abs(clip_region->p1().y()) < kAntiAliasingEpsilon &&

- std::abs(clip_region->p2().y()) < kAntiAliasingEpsilon;

-bool is_bottom(const gfx::QuadF* clip_region, const DrawQuad* quad) {

- if (!quad->IsBottomEdge())

- return false;

- if (!clip_region)

- return true;

- return std::abs(clip_region->p3().y() -

- quad->shared_quad_state->content_bounds.height()) <

- kAntiAliasingEpsilon &&

- std::abs(clip_region->p4().y() -

- quad->shared_quad_state->content_bounds.height()) <

- kAntiAliasingEpsilon;

-bool is_left(const gfx::QuadF* clip_region, const DrawQuad* quad) {

- if (!quad->IsLeftEdge())

- return false;

- if (!clip_region)

- return true;

- return std::abs(clip_region->p1().x()) < kAntiAliasingEpsilon &&

- std::abs(clip_region->p4().x()) < kAntiAliasingEpsilon;

-bool is_right(const gfx::QuadF* clip_region, const DrawQuad* quad) {

- if (!quad->IsRightEdge())

- return false;

- if (!clip_region)

- return true;

- return std::abs(clip_region->p2().x() -

- quad->shared_quad_state->content_bounds.width()) <

- kAntiAliasingEpsilon &&

- std::abs(clip_region->p3().x() -

- quad->shared_quad_state->content_bounds.width()) <

- kAntiAliasingEpsilon;

-} // anonymous namespace

-static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges(

- const LayerQuad& device_layer_edges,

- const gfx::Transform& device_transform,

- const gfx::QuadF* clip_region,

- const DrawQuad* quad) {

- gfx::RectF tile_rect = quad->visible_rect;

- gfx::QuadF tile_quad(tile_rect);

- if (clip_region) {

- if (quad->material != DrawQuad::RENDER_PASS) {

- tile_quad = *clip_region;

- } else {

- GetScaledRegion(quad->rect, clip_region, &tile_quad);

- }

- gfx::PointF bottom_right = tile_quad.p3();

- gfx::PointF bottom_left = tile_quad.p4();

- gfx::PointF top_left = tile_quad.p1();

- gfx::PointF top_right = tile_quad.p2();

- bool clipped = false;

- // Map points to device space. We ignore |clipped|, since the result of

- // |MapPoint()| still produces a valid point to draw the quad with. When

- // clipped, the point will be outside of the viewport. See crbug.com/416367.

- bottom_right = MathUtil::MapPoint(device_transform, bottom_right, &clipped);

- bottom_left = MathUtil::MapPoint(device_transform, bottom_left, &clipped);

- top_left = MathUtil::MapPoint(device_transform, top_left, &clipped);

- top_right = MathUtil::MapPoint(device_transform, top_right, &clipped);

- LayerQuad::Edge bottom_edge(bottom_right, bottom_left);

- LayerQuad::Edge left_edge(bottom_left, top_left);

- LayerQuad::Edge top_edge(top_left, top_right);

- LayerQuad::Edge right_edge(top_right, bottom_right);

- // Only apply anti-aliasing to edges not clipped by culling or scissoring.

- // If an edge is degenerate we do not want to replace it with a "proper" edge

- // as that will cause the quad to possibly expand is strange ways.

- if (!top_edge.degenerate() && is_top(clip_region, quad) &&

- tile_rect.y() == quad->rect.y()) {

- top_edge = device_layer_edges.top();

- }

- if (!left_edge.degenerate() && is_left(clip_region, quad) &&

- tile_rect.x() == quad->rect.x()) {

- left_edge = device_layer_edges.left();

- }

- if (!right_edge.degenerate() && is_right(clip_region, quad) &&

- tile_rect.right() == quad->rect.right()) {

- right_edge = device_layer_edges.right();

- }

- if (!bottom_edge.degenerate() && is_bottom(clip_region, quad) &&

- tile_rect.bottom() == quad->rect.bottom()) {

- bottom_edge = device_layer_edges.bottom();

- }

- float sign = tile_quad.IsCounterClockwise() ? -1 : 1;

- bottom_edge.scale(sign);

- left_edge.scale(sign);

- top_edge.scale(sign);

- right_edge.scale(sign);

- // Create device space quad.

- return LayerQuad(left_edge, top_edge, right_edge, bottom_edge).ToQuadF();

-float GetTotalQuadError(const gfx::QuadF* clipped_quad,

- const gfx::QuadF* ideal_rect) {

- return (clipped_quad->p1() - ideal_rect->p1()).LengthSquared() +

- (clipped_quad->p2() - ideal_rect->p2()).LengthSquared() +

- (clipped_quad->p3() - ideal_rect->p3()).LengthSquared() +

- (clipped_quad->p4() - ideal_rect->p4()).LengthSquared();

-// Attempt to rotate the clipped quad until it lines up the most

-// correctly. This is necessary because we check the edges of this

-// quad against the expected left/right/top/bottom for anti-aliasing.

-void AlignQuadToBoundingBox(gfx::QuadF* clipped_quad) {

- gfx::QuadF bounding_quad = gfx::QuadF(clipped_quad->BoundingBox());

- gfx::QuadF best_rotation = *clipped_quad;

- float least_error_amount = GetTotalQuadError(clipped_quad, &bounding_quad);

- for (size_t i = 1; i < 4; ++i) {

- clipped_quad->Realign(1);

- float new_error = GetTotalQuadError(clipped_quad, &bounding_quad);

- if (new_error < least_error_amount) {

- least_error_amount = new_error;

- best_rotation = *clipped_quad;

- }

- *clipped_quad = best_rotation;

-// static

-bool GLRenderer::ShouldAntialiasQuad(const gfx::Transform& device_transform,

- const DrawQuad* quad,

- bool force_antialiasing) {

- bool is_render_pass_quad = (quad->material == DrawQuad::RENDER_PASS);

- // For render pass quads, |device_transform| already contains quad's rect.

- // TODO(rosca@adobe.com): remove branching on is_render_pass_quad

- // crbug.com/429702

- if (!is_render_pass_quad && !quad->IsEdge())

- return false;

- gfx::RectF content_rect =

- is_render_pass_quad ? QuadVertexRect() : quad->visibleContentRect();

- bool clipped = false;

- gfx::QuadF device_layer_quad =

- MathUtil::MapQuad(device_transform, gfx::QuadF(content_rect), &clipped);

- if (device_layer_quad.BoundingBox().IsEmpty())

- return false;

- bool is_axis_aligned_in_target = device_layer_quad.IsRectilinear();

- bool is_nearest_rect_within_epsilon =

- is_axis_aligned_in_target &&

- gfx::IsNearestRectWithinDistance(device_layer_quad.BoundingBox(),

- kAntiAliasingEpsilon);

- // AAing clipped quads is not supported by the code yet.

- bool use_aa = !clipped && !is_nearest_rect_within_epsilon;

- return use_aa || force_antialiasing;

-// static

-void GLRenderer::SetupQuadForClippingAndAntialiasing(

- const gfx::Transform& device_transform,

- const DrawQuad* quad,

- bool use_aa,

- const gfx::QuadF* clip_region,

- gfx::QuadF* local_quad,

- float edge[24]) {

- bool is_render_pass_quad = (quad->material == DrawQuad::RENDER_PASS);

- gfx::QuadF rotated_clip;

- const gfx::QuadF* local_clip_region = clip_region;

- if (local_clip_region) {

- rotated_clip = *clip_region;

- AlignQuadToBoundingBox(&rotated_clip);

- local_clip_region = &rotated_clip;

- }

- gfx::QuadF content_rect = is_render_pass_quad

- ? gfx::QuadF(QuadVertexRect())

- : gfx::QuadF(quad->visibleContentRect());

- if (!use_aa) {

- if (local_clip_region) {

- if (!is_render_pass_quad) {

- content_rect = *local_clip_region;

- } else {

- GetScaledRegion(quad->rect, local_clip_region, &content_rect);

- }

- *local_quad = content_rect;

- }

- return;

- }

- bool clipped = false;

- gfx::QuadF device_layer_quad =

- MathUtil::MapQuad(device_transform, content_rect, &clipped);

- LayerQuad device_layer_bounds(gfx::QuadF(device_layer_quad.BoundingBox()));

- device_layer_bounds.InflateAntiAliasingDistance();

- LayerQuad device_layer_edges(device_layer_quad);

- device_layer_edges.InflateAntiAliasingDistance();

- device_layer_edges.ToFloatArray(edge);

- device_layer_bounds.ToFloatArray(&edge[12]);

- // If we have a clip region then we are split, and therefore

- // by necessity, at least one of our edges is not an external

- // one.

- bool is_full_rect = quad->visible_rect == quad->rect;

- bool region_contains_all_outside_edges =

- is_full_rect &&

- (is_top(local_clip_region, quad) && is_left(local_clip_region, quad) &&

- is_bottom(local_clip_region, quad) && is_right(local_clip_region, quad));

- bool use_aa_on_all_four_edges =

- !local_clip_region &&

- (is_render_pass_quad || region_contains_all_outside_edges);

- gfx::QuadF device_quad =

- use_aa_on_all_four_edges

- ? device_layer_edges.ToQuadF()

- : GetDeviceQuadWithAntialiasingOnExteriorEdges(

- device_layer_edges, device_transform, local_clip_region, quad);

- // Map device space quad to local space. device_transform has no 3d

- // component since it was flattened, so we don't need to project. We should

- // have already checked that the transform was uninvertible above.

- gfx::Transform inverse_device_transform(gfx::Transform::kSkipInitialization);

- bool did_invert = device_transform.GetInverse(&inverse_device_transform);

- DCHECK(did_invert);

- *local_quad =

- MathUtil::MapQuad(inverse_device_transform, device_quad, &clipped);

- // We should not DCHECK(!clipped) here, because anti-aliasing inflation may

- // cause device_quad to become clipped. To our knowledge this scenario does

- // not need to be handled differently than the unclipped case.

-void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,

- const SolidColorDrawQuad* quad,

- const gfx::QuadF* clip_region) {

- gfx::Rect tile_rect = quad->visible_rect;

- SkColor color = quad->color;

- float opacity = quad->opacity();

- float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;

- // Early out if alpha is small enough that quad doesn't contribute to output.

- if (alpha < std::numeric_limits<float>::epsilon() &&

- quad->ShouldDrawWithBlending())

- return;

- gfx::Transform device_transform =

- frame->window_matrix * frame->projection_matrix * quad->quadTransform();

- device_transform.FlattenTo2d();

- if (!device_transform.IsInvertible())

- return;

- bool force_aa = false;

- gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));

- float edge[24];

- bool use_aa = settings_->allow_antialiasing &&

- !quad->force_anti_aliasing_off &&

- ShouldAntialiasQuad(device_transform, quad, force_aa);

- SetupQuadForClippingAndAntialiasing(device_transform, quad, use_aa,

- clip_region, &local_quad, edge);

- SolidColorProgramUniforms uniforms;

- if (use_aa) {

- SolidColorUniformLocation(GetSolidColorProgramAA(), &uniforms);

- } else {

- SolidColorUniformLocation(GetSolidColorProgram(), &uniforms);

- }

- SetUseProgram(uniforms.program);

- GLC(gl_,

- gl_->Uniform4f(uniforms.color_location,

- (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,

- (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,

- (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,

- alpha));

- if (use_aa) {

- float viewport[4] = {static_cast<float>(viewport_.x()),

- static_cast<float>(viewport_.y()),

- static_cast<float>(viewport_.width()),

- static_cast<float>(viewport_.height()), };

- GLC(gl_, gl_->Uniform4fv(uniforms.viewport_location, 1, viewport));

- GLC(gl_, gl_->Uniform3fv(uniforms.edge_location, 8, edge));

- }

- // Enable blending when the quad properties require it or if we decided

- // to use antialiasing.

- SetBlendEnabled(quad->ShouldDrawWithBlending() || use_aa);

- // Normalize to tile_rect.

- local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());

- SetShaderQuadF(local_quad, uniforms.quad_location);

- // The transform and vertex data are used to figure out the extents that the

- // un-antialiased quad should have and which vertex this is and the float

- // quad passed in via uniform is the actual geometry that gets used to draw

- // it. This is why this centered rect is used and not the original quad_rect.

- gfx::RectF centered_rect(

- gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),

- tile_rect.size());

- DrawQuadGeometry(

- frame, quad->quadTransform(), centered_rect, uniforms.matrix_location);

-struct TileProgramUniforms {

- unsigned program;

- unsigned matrix_location;

- unsigned viewport_location;

- unsigned quad_location;

- unsigned edge_location;

- unsigned vertex_tex_transform_location;

- unsigned sampler_location;

- unsigned fragment_tex_transform_location;

- unsigned alpha_location;

-};

-template <class T>

-static void TileUniformLocation(T program, TileProgramUniforms* uniforms) {

- uniforms->program = program->program();

- uniforms->matrix_location = program->vertex_shader().matrix_location();

- uniforms->viewport_location = program->vertex_shader().viewport_location();

- uniforms->quad_location = program->vertex_shader().quad_location();

- uniforms->edge_location = program->vertex_shader().edge_location();

- uniforms->vertex_tex_transform_location =

- program->vertex_shader().vertex_tex_transform_location();

- uniforms->sampler_location = program->fragment_shader().sampler_location();

- uniforms->alpha_location = program->fragment_shader().alpha_location();

- uniforms->fragment_tex_transform_location =

- program->fragment_shader().fragment_tex_transform_location();

-void GLRenderer::DrawTileQuad(const DrawingFrame* frame,

- const TileDrawQuad* quad,

- const gfx::QuadF* clip_region) {

- DrawContentQuad(frame, quad, quad->resource_id, clip_region);

-void GLRenderer::DrawContentQuad(const DrawingFrame* frame,

- const ContentDrawQuadBase* quad,

- ResourceProvider::ResourceId resource_id,

- const gfx::QuadF* clip_region) {

- gfx::Transform device_transform =

- frame->window_matrix * frame->projection_matrix * quad->quadTransform();

- device_transform.FlattenTo2d();

- bool use_aa = settings_->allow_antialiasing &&

- ShouldAntialiasQuad(device_transform, quad, false);

- // TODO(timav): simplify coordinate transformations in DrawContentQuadAA

- // similar to the way DrawContentQuadNoAA works and then consider

- // combining DrawContentQuadAA and DrawContentQuadNoAA into one method.

- if (use_aa)

- DrawContentQuadAA(frame, quad, resource_id, device_transform, clip_region);

- else

- DrawContentQuadNoAA(frame, quad, resource_id, clip_region);

-void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,

- const ContentDrawQuadBase* quad,

- ResourceProvider::ResourceId resource_id,

- const gfx::Transform& device_transform,

- const gfx::QuadF* clip_region) {

- if (!device_transform.IsInvertible())

- return;

- gfx::Rect tile_rect = quad->visible_rect;

- gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(

- quad->tex_coord_rect, quad->rect, tile_rect);

- float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();

- float tex_to_geom_scale_y =

- quad->rect.height() / quad->tex_coord_rect.height();

- gfx::RectF clamp_geom_rect(tile_rect);

- gfx::RectF clamp_tex_rect(tex_coord_rect);

- // Clamp texture coordinates to avoid sampling outside the layer

- // by deflating the tile region half a texel or half a texel

- // minus epsilon for one pixel layers. The resulting clamp region

- // is mapped to the unit square by the vertex shader and mapped

- // back to normalized texture coordinates by the fragment shader

- // after being clamped to 0-1 range.

- float tex_clamp_x =

- std::min(0.5f, 0.5f * clamp_tex_rect.width() - kAntiAliasingEpsilon);

- float tex_clamp_y =

- std::min(0.5f, 0.5f * clamp_tex_rect.height() - kAntiAliasingEpsilon);

- float geom_clamp_x =

- std::min(tex_clamp_x * tex_to_geom_scale_x,

- 0.5f * clamp_geom_rect.width() - kAntiAliasingEpsilon);

- float geom_clamp_y =

- std::min(tex_clamp_y * tex_to_geom_scale_y,

- 0.5f * clamp_geom_rect.height() - kAntiAliasingEpsilon);

- clamp_geom_rect.Inset(geom_clamp_x, geom_clamp_y, geom_clamp_x, geom_clamp_y);

- clamp_tex_rect.Inset(tex_clamp_x, tex_clamp_y, tex_clamp_x, tex_clamp_y);

- // Map clamping rectangle to unit square.

- float vertex_tex_translate_x = -clamp_geom_rect.x() / clamp_geom_rect.width();

- float vertex_tex_translate_y =

- -clamp_geom_rect.y() / clamp_geom_rect.height();

- float vertex_tex_scale_x = tile_rect.width() / clamp_geom_rect.width();

- float vertex_tex_scale_y = tile_rect.height() / clamp_geom_rect.height();

- TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(

- gl_, &highp_threshold_cache_, highp_threshold_min_, quad->texture_size);

- gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));

- float edge[24];

- SetupQuadForClippingAndAntialiasing(device_transform, quad, true, clip_region,

- &local_quad, edge);

- ResourceProvider::ScopedSamplerGL quad_resource_lock(

- resource_provider_, resource_id,

- quad->nearest_neighbor ? GL_NEAREST : GL_LINEAR);

- SamplerType sampler =

- SamplerTypeFromTextureTarget(quad_resource_lock.target());

- float fragment_tex_translate_x = clamp_tex_rect.x();

- float fragment_tex_translate_y = clamp_tex_rect.y();

- float fragment_tex_scale_x = clamp_tex_rect.width();

- float fragment_tex_scale_y = clamp_tex_rect.height();

- // Map to normalized texture coordinates.

- if (sampler != SAMPLER_TYPE_2D_RECT) {

- gfx::Size texture_size = quad->texture_size;

- DCHECK(!texture_size.IsEmpty());

- fragment_tex_translate_x /= texture_size.width();

- fragment_tex_translate_y /= texture_size.height();

- fragment_tex_scale_x /= texture_size.width();

- fragment_tex_scale_y /= texture_size.height();

- }

- TileProgramUniforms uniforms;

- if (quad->swizzle_contents) {

- TileUniformLocation(GetTileProgramSwizzleAA(tex_coord_precision, sampler),

- &uniforms);

- } else {

- TileUniformLocation(GetTileProgramAA(tex_coord_precision, sampler),

- &uniforms);

- }

- SetUseProgram(uniforms.program);

- GLC(gl_, gl_->Uniform1i(uniforms.sampler_location, 0));

- float viewport[4] = {

- static_cast<float>(viewport_.x()),

- static_cast<float>(viewport_.y()),

- static_cast<float>(viewport_.width()),

- static_cast<float>(viewport_.height()),

- };

- GLC(gl_, gl_->Uniform4fv(uniforms.viewport_location, 1, viewport));

- GLC(gl_, gl_->Uniform3fv(uniforms.edge_location, 8, edge));

- GLC(gl_,

- gl_->Uniform4f(uniforms.vertex_tex_transform_location,

- vertex_tex_translate_x,

- vertex_tex_translate_y,

- vertex_tex_scale_x,

- vertex_tex_scale_y));

- GLC(gl_,

- gl_->Uniform4f(uniforms.fragment_tex_transform_location,

- fragment_tex_translate_x,

- fragment_tex_translate_y,

- fragment_tex_scale_x,

- fragment_tex_scale_y));

- // Blending is required for antialiasing.

- SetBlendEnabled(true);

- // Normalize to tile_rect.

- local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());

- SetShaderOpacity(quad->opacity(), uniforms.alpha_location);

- SetShaderQuadF(local_quad, uniforms.quad_location);

- // The transform and vertex data are used to figure out the extents that the

- // un-antialiased quad should have and which vertex this is and the float

- // quad passed in via uniform is the actual geometry that gets used to draw

- // it. This is why this centered rect is used and not the original quad_rect.

- gfx::RectF centered_rect(

- gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),

- tile_rect.size());

- DrawQuadGeometry(

- frame, quad->quadTransform(), centered_rect, uniforms.matrix_location);

-void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,

- const ContentDrawQuadBase* quad,

- ResourceProvider::ResourceId resource_id,

- const gfx::QuadF* clip_region) {

- gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(

- quad->tex_coord_rect, quad->rect, quad->visible_rect);

- float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();

- float tex_to_geom_scale_y =

- quad->rect.height() / quad->tex_coord_rect.height();

- bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);

- GLenum filter =

- (scaled || !quad->quadTransform().IsIdentityOrIntegerTranslation()) &&

- !quad->nearest_neighbor

- ? GL_LINEAR

- : GL_NEAREST;

- ResourceProvider::ScopedSamplerGL quad_resource_lock(

- resource_provider_, resource_id, filter);

- SamplerType sampler =

- SamplerTypeFromTextureTarget(quad_resource_lock.target());

- float vertex_tex_translate_x = tex_coord_rect.x();

- float vertex_tex_translate_y = tex_coord_rect.y();

- float vertex_tex_scale_x = tex_coord_rect.width();

- float vertex_tex_scale_y = tex_coord_rect.height();

- // Map to normalized texture coordinates.

- if (sampler != SAMPLER_TYPE_2D_RECT) {

- gfx::Size texture_size = quad->texture_size;

- DCHECK(!texture_size.IsEmpty());

- vertex_tex_translate_x /= texture_size.width();

- vertex_tex_translate_y /= texture_size.height();

- vertex_tex_scale_x /= texture_size.width();

- vertex_tex_scale_y /= texture_size.height();

- }

- TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(

- gl_, &highp_threshold_cache_, highp_threshold_min_, quad->texture_size);

- TileProgramUniforms uniforms;

- if (quad->ShouldDrawWithBlending()) {

- if (quad->swizzle_contents) {

- TileUniformLocation(GetTileProgramSwizzle(tex_coord_precision, sampler),

- &uniforms);

- } else {

- TileUniformLocation(GetTileProgram(tex_coord_precision, sampler),

- &uniforms);

- }

- } else {

- if (quad->swizzle_contents) {

- TileUniformLocation(

- GetTileProgramSwizzleOpaque(tex_coord_precision, sampler), &uniforms);

- } else {

- TileUniformLocation(GetTileProgramOpaque(tex_coord_precision, sampler),

- &uniforms);

- }

- SetUseProgram(uniforms.program);

- GLC(gl_, gl_->Uniform1i(uniforms.sampler_location, 0));

- GLC(gl_,

- gl_->Uniform4f(uniforms.vertex_tex_transform_location,

- vertex_tex_translate_x,

- vertex_tex_translate_y,

- vertex_tex_scale_x,

- vertex_tex_scale_y));

- SetBlendEnabled(quad->ShouldDrawWithBlending());

- SetShaderOpacity(quad->opacity(), uniforms.alpha_location);

- // Pass quad coordinates to the uniform in the same order as GeometryBinding

- // does, then vertices will match the texture mapping in the vertex buffer.

- // The method SetShaderQuadF() changes the order of vertices and so it's

- // not used here.

- gfx::QuadF tile_rect(quad->visible_rect);

- float width = quad->visible_rect.width();

- float height = quad->visible_rect.height();

- gfx::PointF top_left = quad->visible_rect.origin();

- if (clip_region) {

- tile_rect = *clip_region;

- float gl_uv[8] = {

- (tile_rect.p4().x() - top_left.x()) / width,

- (tile_rect.p4().y() - top_left.y()) / height,

- (tile_rect.p1().x() - top_left.x()) / width,

- (tile_rect.p1().y() - top_left.y()) / height,

- (tile_rect.p2().x() - top_left.x()) / width,

- (tile_rect.p2().y() - top_left.y()) / height,

- (tile_rect.p3().x() - top_left.x()) / width,

- (tile_rect.p3().y() - top_left.y()) / height,

- };

- PrepareGeometry(CLIPPED_BINDING);

- clipped_geometry_->InitializeCustomQuadWithUVs(

- gfx::QuadF(quad->visible_rect), gl_uv);

- } else {

- PrepareGeometry(SHARED_BINDING);

- }

- float gl_quad[8] = {

- tile_rect.p4().x(),

- tile_rect.p4().y(),

- tile_rect.p1().x(),

- tile_rect.p1().y(),

- tile_rect.p2().x(),

- tile_rect.p2().y(),

- tile_rect.p3().x(),

- tile_rect.p3().y(),

- };

- GLC(gl_, gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad));

- static float gl_matrix[16];

- ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad->quadTransform());

- GLC(gl_,

- gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]));

- GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));

-void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,

- const YUVVideoDrawQuad* quad,

- const gfx::QuadF* clip_region) {

- SetBlendEnabled(quad->ShouldDrawWithBlending());

- TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(

- gl_,

- &highp_threshold_cache_,

- highp_threshold_min_,

- quad->shared_quad_state->visible_content_rect.bottom_right());

- bool use_alpha_plane = quad->a_plane_resource_id != 0;

- ResourceProvider::ScopedSamplerGL y_plane_lock(

- resource_provider_, quad->y_plane_resource_id, GL_TEXTURE1, GL_LINEAR);

- DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), y_plane_lock.target());

- ResourceProvider::ScopedSamplerGL u_plane_lock(

- resource_provider_, quad->u_plane_resource_id, GL_TEXTURE2, GL_LINEAR);

- DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), u_plane_lock.target());

- ResourceProvider::ScopedSamplerGL v_plane_lock(

- resource_provider_, quad->v_plane_resource_id, GL_TEXTURE3, GL_LINEAR);

- DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), v_plane_lock.target());

- scoped_ptr<ResourceProvider::ScopedSamplerGL> a_plane_lock;

- if (use_alpha_plane) {

- a_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(

- resource_provider_, quad->a_plane_resource_id, GL_TEXTURE4, GL_LINEAR));

- DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), a_plane_lock->target());

- }

- int matrix_location = -1;

- int tex_scale_location = -1;

- int tex_offset_location = -1;

- int clamp_rect_location = -1;

- int y_texture_location = -1;

- int u_texture_location = -1;

- int v_texture_location = -1;

- int a_texture_location = -1;

- int yuv_matrix_location = -1;

- int yuv_adj_location = -1;

- int alpha_location = -1;

- if (use_alpha_plane) {

- const VideoYUVAProgram* program = GetVideoYUVAProgram(tex_coord_precision);

- DCHECK(program && (program->initialized() || IsContextLost()));

- SetUseProgram(program->program());

- matrix_location = program->vertex_shader().matrix_location();

- tex_scale_location = program->vertex_shader().tex_scale_location();

- tex_offset_location = program->vertex_shader().tex_offset_location();

- y_texture_location = program->fragment_shader().y_texture_location();

- u_texture_location = program->fragment_shader().u_texture_location();

- v_texture_location = program->fragment_shader().v_texture_location();

- a_texture_location = program->fragment_shader().a_texture_location();

- yuv_matrix_location = program->fragment_shader().yuv_matrix_location();

- yuv_adj_location = program->fragment_shader().yuv_adj_location();

- clamp_rect_location = program->fragment_shader().clamp_rect_location();

- alpha_location = program->fragment_shader().alpha_location();

- } else {

- const VideoYUVProgram* program = GetVideoYUVProgram(tex_coord_precision);