src/cobalt/renderer/rasterizer/egl/hardware_rasterizer.cc - cobalt - Git at Google

 // Copyright 2017 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "cobalt/renderer/rasterizer/egl/hardware_rasterizer.h"

 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <vector>

 #include "base/debug/trace_event.h"
 #include "base/threading/thread_checker.h"
 #include "cobalt/math/size.h"
 #include "cobalt/renderer/backend/egl/framebuffer.h"
 #include "cobalt/renderer/backend/egl/graphics_context.h"
 #include "cobalt/renderer/backend/egl/graphics_system.h"
 #include "cobalt/renderer/backend/egl/texture.h"
 #include "cobalt/renderer/backend/egl/utils.h"
 #include "cobalt/renderer/frame_rate_throttler.h"
 #include "cobalt/renderer/rasterizer/egl/draw_object_manager.h"
 #include "cobalt/renderer/rasterizer/egl/graphics_state.h"
 #include "cobalt/renderer/rasterizer/egl/render_tree_node_visitor.h"
 #include "cobalt/renderer/rasterizer/egl/shader_program_manager.h"
 #include "cobalt/renderer/rasterizer/skia/hardware_rasterizer.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/core/SkSurfaceProps.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrRenderTarget.h"
 #include "third_party/skia/include/gpu/GrTypes.h"

 namespace cobalt {
 namespace renderer {
 namespace rasterizer {
 namespace egl {

 class HardwareRasterizer::Impl {
  public:
   explicit Impl(backend::GraphicsContext* graphics_context,
                 int skia_cache_size_in_bytes,
                 int scratch_surface_cache_size_in_bytes,
                 int surface_cache_size_in_bytes);
   ~Impl();

   void Submit(const scoped_refptr<render_tree::Node>& render_tree,
               const scoped_refptr<backend::RenderTarget>& render_target,
               const Options& options);

   backend::TextureEGL* SubmitToFallbackRasterizer(
       const scoped_refptr<render_tree::Node>& render_tree,
       const math::RectF& viewport);

   render_tree::ResourceProvider* GetResourceProvider() {
     return fallback_rasterizer_->GetResourceProvider();
   }

  private:
   GrContext* GetGrContext() {
     return fallback_rasterizer_->GetGrContext();
   }

   scoped_ptr<skia::HardwareRasterizer> fallback_rasterizer_;
   scoped_ptr<GraphicsState> graphics_state_;
   scoped_ptr<ShaderProgramManager> shader_program_manager_;

   backend::GraphicsContextEGL* graphics_context_;
   FrameRateThrottler frame_rate_throttler_;
   base::ThreadChecker thread_checker_;

   static const size_t kMinOffscreenTargets = 3;
   struct OffscreenTarget {
     scoped_ptr<backend::FramebufferEGL> framebuffer;
     SkAutoTUnref<SkSurface> skia_surface;
   };
   typedef std::vector<OffscreenTarget*> OffscreenTargetList;
   OffscreenTargetList used_offscreen_targets_;
   OffscreenTargetList unused_offscreen_targets_;
 };

 HardwareRasterizer::Impl::Impl(
     backend::GraphicsContext* graphics_context,
     int skia_cache_size_in_bytes,
     int scratch_surface_cache_size_in_bytes,
     int surface_cache_size_in_bytes)
     : fallback_rasterizer_(new skia::HardwareRasterizer(
           graphics_context,
           skia_cache_size_in_bytes,
           scratch_surface_cache_size_in_bytes,
           surface_cache_size_in_bytes)),
       graphics_context_(
           base::polymorphic_downcast<backend::GraphicsContextEGL*>(
               graphics_context)) {
   backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
       graphics_context_);

   graphics_state_.reset(new GraphicsState());
   shader_program_manager_.reset(new ShaderProgramManager());
 }

 HardwareRasterizer::Impl::~Impl() {
   backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
       graphics_context_);

   GL_CALL(glFinish());
   while (!unused_offscreen_targets_.empty()) {
     delete unused_offscreen_targets_.back();
     unused_offscreen_targets_.pop_back();
   }

   shader_program_manager_.reset();
   graphics_state_.reset();
 }

 void HardwareRasterizer::Impl::Submit(
     const scoped_refptr<render_tree::Node>& render_tree,
     const scoped_refptr<backend::RenderTarget>& render_target,
     const Options& options) {
   DCHECK(thread_checker_.CalledOnValidThread());

   backend::RenderTargetEGL* render_target_egl =
       base::polymorphic_downcast<backend::RenderTargetEGL*>(
           render_target.get());
   backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
       graphics_context_, render_target_egl);

   fallback_rasterizer_->AdvanceFrame();

   const math::Size& target_size = render_target->GetSize();
   graphics_state_->SetClipAdjustment(target_size);
   graphics_state_->Viewport(0, 0, target_size.width(), target_size.height());
   graphics_state_->Scissor(0, 0, target_size.width(), target_size.height());

   {
     DrawObjectManager draw_object_manager;
     RenderTreeNodeVisitor::FallbackRasterizeFunction fallback_rasterize =
         base::Bind(&HardwareRasterizer::Impl::SubmitToFallbackRasterizer,
                    base::Unretained(this));
     RenderTreeNodeVisitor visitor(graphics_state_.get(),
                                   &draw_object_manager,
                                   &fallback_rasterize);

     {
       TRACE_EVENT0("cobalt::renderer", "VisitRenderTree");
       render_tree->Accept(&visitor);
     }

     graphics_state_->BeginFrame();

     {
       TRACE_EVENT0("cobalt::renderer", "UpdateVertexBuffer");
       draw_object_manager.ExecuteUpdateVertexBuffer(graphics_state_.get(),
           shader_program_manager_.get());
       graphics_state_->UpdateVertexData();
     }

     {
       TRACE_EVENT0("cobalt::renderer", "RasterizeOffscreen");

       // Reset the skia graphics context since the egl rasterizer dirtied it.
       GetGrContext()->resetContext();

       draw_object_manager.ExecuteRasterizeOffscreen(graphics_state_.get(),
           shader_program_manager_.get());
       GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, 0));

       // Reset the egl graphics state since skia dirtied it.
       graphics_state_->SetDirty();
     }

     graphics_state_->Clear();

     {
       TRACE_EVENT0("cobalt::renderer", "RasterizeNormal");
       draw_object_manager.ExecuteRasterizeNormal(graphics_state_.get(),
           shader_program_manager_.get());
     }

     graphics_state_->EndFrame();
   }

   // Update the offscreen target cache. Keep an extra frame's worth of targets
   // around.
   while (unused_offscreen_targets_.size() > kMinOffscreenTargets &&
          unused_offscreen_targets_.size() > used_offscreen_targets_.size()) {
     delete unused_offscreen_targets_.back();
     unused_offscreen_targets_.pop_back();
   }

   // Add most recently used offscreen targets to the front.
   unused_offscreen_targets_.insert(unused_offscreen_targets_.begin(),
                                    used_offscreen_targets_.begin(),
                                    used_offscreen_targets_.end());
   used_offscreen_targets_.clear();

   frame_rate_throttler_.EndInterval();
   graphics_context_->SwapBuffers(render_target_egl);
   frame_rate_throttler_.BeginInterval();
 }

 backend::TextureEGL* HardwareRasterizer::Impl::SubmitToFallbackRasterizer(
     const scoped_refptr<render_tree::Node>& render_tree,
     const math::RectF& viewport) {
   TRACE_EVENT0("cobalt::renderer", "SubmitToFallbackRasterizer");

   // Get an offscreen target for rendering.
   math::Size viewport_size(viewport.width(), viewport.height());
   OffscreenTarget* offscreen_target = NULL;
   for (OffscreenTargetList::iterator iter = unused_offscreen_targets_.begin();
        iter != unused_offscreen_targets_.end(); ++iter) {
     if ((*iter)->framebuffer->GetSize() == viewport_size) {
       offscreen_target = *iter;
       unused_offscreen_targets_.erase(iter);
       break;
     }
   }

   if (offscreen_target == NULL) {
     offscreen_target = new OffscreenTarget;

     // Create a new framebuffer.
     offscreen_target->framebuffer.reset(new backend::FramebufferEGL(
         graphics_context_, viewport_size, GL_RGBA, GL_NONE));

     // Wrap the framebuffer as a skia surface.
     GrBackendRenderTargetDesc skia_desc;
     skia_desc.fWidth = viewport_size.width();
     skia_desc.fHeight = viewport_size.height();
     skia_desc.fConfig = kRGBA_8888_GrPixelConfig;
     skia_desc.fOrigin = kTopLeft_GrSurfaceOrigin;
     skia_desc.fSampleCnt = 0;
     skia_desc.fStencilBits = 0;
     skia_desc.fRenderTargetHandle = offscreen_target->framebuffer->gl_handle();

     SkAutoTUnref<GrRenderTarget> skia_render_target(
         GetGrContext()->wrapBackendRenderTarget(skia_desc));
     SkSurfaceProps skia_surface_props(
         SkSurfaceProps::kUseDistanceFieldFonts_Flag,
         SkSurfaceProps::kLegacyFontHost_InitType);
     offscreen_target->skia_surface.reset(SkSurface::NewRenderTargetDirect(
         skia_render_target, &skia_surface_props));
   }
   used_offscreen_targets_.push_back(offscreen_target);

   backend::FramebufferEGL* framebuffer = offscreen_target->framebuffer.get();
   SkCanvas* canvas = offscreen_target->skia_surface->getCanvas();

   canvas->save();
   canvas->clear(SkColorSetARGB(0, 0, 0, 0));
   canvas->translate(viewport.x(), viewport.y());
   fallback_rasterizer_->SubmitOffscreen(render_tree, canvas);
   canvas->restore();

   return framebuffer->GetColorTexture();
 }

 HardwareRasterizer::HardwareRasterizer(
     backend::GraphicsContext* graphics_context,
     int skia_cache_size_in_bytes,
     int scratch_surface_cache_size_in_bytes,
     int surface_cache_size_in_bytes)
     : impl_(new Impl(graphics_context,
                      skia_cache_size_in_bytes,
                      scratch_surface_cache_size_in_bytes,
                      surface_cache_size_in_bytes)) {
 }

 void HardwareRasterizer::Submit(
     const scoped_refptr<render_tree::Node>& render_tree,
     const scoped_refptr<backend::RenderTarget>& render_target,
     const Options& options) {
   TRACE_EVENT0("cobalt::renderer", "HardwareRasterizer::Submit");
   impl_->Submit(render_tree, render_target, options);
 }

 render_tree::ResourceProvider* HardwareRasterizer::GetResourceProvider() {
   return impl_->GetResourceProvider();
 }

 }  // namespace egl
 }  // namespace rasterizer
 }  // namespace renderer
 }  // namespace cobalt
	// Copyright 2017 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "cobalt/renderer/rasterizer/egl/hardware_rasterizer.h"

	#include <GLES2/gl2.h>
	#include <GLES2/gl2ext.h>
	#include <vector>

	#include "base/debug/trace_event.h"
	#include "base/threading/thread_checker.h"
	#include "cobalt/math/size.h"
	#include "cobalt/renderer/backend/egl/framebuffer.h"
	#include "cobalt/renderer/backend/egl/graphics_context.h"
	#include "cobalt/renderer/backend/egl/graphics_system.h"
	#include "cobalt/renderer/backend/egl/texture.h"
	#include "cobalt/renderer/backend/egl/utils.h"
	#include "cobalt/renderer/frame_rate_throttler.h"
	#include "cobalt/renderer/rasterizer/egl/draw_object_manager.h"
	#include "cobalt/renderer/rasterizer/egl/graphics_state.h"
	#include "cobalt/renderer/rasterizer/egl/render_tree_node_visitor.h"
	#include "cobalt/renderer/rasterizer/egl/shader_program_manager.h"
	#include "cobalt/renderer/rasterizer/skia/hardware_rasterizer.h"
	#include "third_party/skia/include/core/SkCanvas.h"
	#include "third_party/skia/include/core/SkRefCnt.h"
	#include "third_party/skia/include/core/SkSurface.h"
	#include "third_party/skia/include/core/SkSurfaceProps.h"
	#include "third_party/skia/include/gpu/GrContext.h"
	#include "third_party/skia/include/gpu/GrRenderTarget.h"
	#include "third_party/skia/include/gpu/GrTypes.h"

	namespace cobalt {
	namespace renderer {
	namespace rasterizer {
	namespace egl {

	class HardwareRasterizer::Impl {
	public:
	explicit Impl(backend::GraphicsContext* graphics_context,
	int skia_cache_size_in_bytes,
	int scratch_surface_cache_size_in_bytes,
	int surface_cache_size_in_bytes);
	~Impl();

	void Submit(const scoped_refptr<render_tree::Node>& render_tree,
	const scoped_refptr<backend::RenderTarget>& render_target,
	const Options& options);

	backend::TextureEGL* SubmitToFallbackRasterizer(
	const scoped_refptr<render_tree::Node>& render_tree,
	const math::RectF& viewport);

	render_tree::ResourceProvider* GetResourceProvider() {
	return fallback_rasterizer_->GetResourceProvider();
	}

	private:
	GrContext* GetGrContext() {
	return fallback_rasterizer_->GetGrContext();
	}

	scoped_ptr<skia::HardwareRasterizer> fallback_rasterizer_;
	scoped_ptr<GraphicsState> graphics_state_;
	scoped_ptr<ShaderProgramManager> shader_program_manager_;

	backend::GraphicsContextEGL* graphics_context_;
	FrameRateThrottler frame_rate_throttler_;
	base::ThreadChecker thread_checker_;

	static const size_t kMinOffscreenTargets = 3;
	struct OffscreenTarget {
	scoped_ptr<backend::FramebufferEGL> framebuffer;
	SkAutoTUnref<SkSurface> skia_surface;
	};
	typedef std::vector<OffscreenTarget*> OffscreenTargetList;
	OffscreenTargetList used_offscreen_targets_;
	OffscreenTargetList unused_offscreen_targets_;
	};

	HardwareRasterizer::Impl::Impl(
	backend::GraphicsContext* graphics_context,
	int skia_cache_size_in_bytes,
	int scratch_surface_cache_size_in_bytes,
	int surface_cache_size_in_bytes)
	: fallback_rasterizer_(new skia::HardwareRasterizer(
	graphics_context,
	skia_cache_size_in_bytes,
	scratch_surface_cache_size_in_bytes,
	surface_cache_size_in_bytes)),
	graphics_context_(
	base::polymorphic_downcast<backend::GraphicsContextEGL*>(
	graphics_context)) {
	backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
	graphics_context_);

	graphics_state_.reset(new GraphicsState());
	shader_program_manager_.reset(new ShaderProgramManager());
	}

	HardwareRasterizer::Impl::~Impl() {
	backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
	graphics_context_);

	GL_CALL(glFinish());
	while (!unused_offscreen_targets_.empty()) {
	delete unused_offscreen_targets_.back();
	unused_offscreen_targets_.pop_back();
	}

	shader_program_manager_.reset();
	graphics_state_.reset();
	}

	void HardwareRasterizer::Impl::Submit(
	const scoped_refptr<render_tree::Node>& render_tree,
	const scoped_refptr<backend::RenderTarget>& render_target,
	const Options& options) {
	DCHECK(thread_checker_.CalledOnValidThread());

	backend::RenderTargetEGL* render_target_egl =
	base::polymorphic_downcast<backend::RenderTargetEGL*>(
	render_target.get());
	backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
	graphics_context_, render_target_egl);

	fallback_rasterizer_->AdvanceFrame();

	const math::Size& target_size = render_target->GetSize();
	graphics_state_->SetClipAdjustment(target_size);
	graphics_state_->Viewport(0, 0, target_size.width(), target_size.height());
	graphics_state_->Scissor(0, 0, target_size.width(), target_size.height());

	{
	DrawObjectManager draw_object_manager;
	RenderTreeNodeVisitor::FallbackRasterizeFunction fallback_rasterize =
	base::Bind(&HardwareRasterizer::Impl::SubmitToFallbackRasterizer,
	base::Unretained(this));
	RenderTreeNodeVisitor visitor(graphics_state_.get(),
	&draw_object_manager,
	&fallback_rasterize);

	{
	TRACE_EVENT0("cobalt::renderer", "VisitRenderTree");
	render_tree->Accept(&visitor);
	}

	graphics_state_->BeginFrame();

	{
	TRACE_EVENT0("cobalt::renderer", "UpdateVertexBuffer");
	draw_object_manager.ExecuteUpdateVertexBuffer(graphics_state_.get(),
	shader_program_manager_.get());
	graphics_state_->UpdateVertexData();
	}

	{
	TRACE_EVENT0("cobalt::renderer", "RasterizeOffscreen");

	// Reset the skia graphics context since the egl rasterizer dirtied it.
	GetGrContext()->resetContext();

	draw_object_manager.ExecuteRasterizeOffscreen(graphics_state_.get(),
	shader_program_manager_.get());
	GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, 0));

	// Reset the egl graphics state since skia dirtied it.
	graphics_state_->SetDirty();
	}

	graphics_state_->Clear();

	{
	TRACE_EVENT0("cobalt::renderer", "RasterizeNormal");
	draw_object_manager.ExecuteRasterizeNormal(graphics_state_.get(),
	shader_program_manager_.get());
	}

	graphics_state_->EndFrame();
	}

	// Update the offscreen target cache. Keep an extra frame's worth of targets
	// around.
	while (unused_offscreen_targets_.size() > kMinOffscreenTargets &&
	unused_offscreen_targets_.size() > used_offscreen_targets_.size()) {
	delete unused_offscreen_targets_.back();
	unused_offscreen_targets_.pop_back();
	}

	// Add most recently used offscreen targets to the front.
	unused_offscreen_targets_.insert(unused_offscreen_targets_.begin(),
	used_offscreen_targets_.begin(),
	used_offscreen_targets_.end());
	used_offscreen_targets_.clear();

	frame_rate_throttler_.EndInterval();
	graphics_context_->SwapBuffers(render_target_egl);
	frame_rate_throttler_.BeginInterval();
	}

	backend::TextureEGL* HardwareRasterizer::Impl::SubmitToFallbackRasterizer(
	const scoped_refptr<render_tree::Node>& render_tree,
	const math::RectF& viewport) {
	TRACE_EVENT0("cobalt::renderer", "SubmitToFallbackRasterizer");

	// Get an offscreen target for rendering.
	math::Size viewport_size(viewport.width(), viewport.height());
	OffscreenTarget* offscreen_target = NULL;
	for (OffscreenTargetList::iterator iter = unused_offscreen_targets_.begin();
	iter != unused_offscreen_targets_.end(); ++iter) {
	if ((*iter)->framebuffer->GetSize() == viewport_size) {
	offscreen_target = *iter;
	unused_offscreen_targets_.erase(iter);
	break;
	}
	}

	if (offscreen_target == NULL) {
	offscreen_target = new OffscreenTarget;

	// Create a new framebuffer.
	offscreen_target->framebuffer.reset(new backend::FramebufferEGL(
	graphics_context_, viewport_size, GL_RGBA, GL_NONE));

	// Wrap the framebuffer as a skia surface.
	GrBackendRenderTargetDesc skia_desc;
	skia_desc.fWidth = viewport_size.width();
	skia_desc.fHeight = viewport_size.height();
	skia_desc.fConfig = kRGBA_8888_GrPixelConfig;
	skia_desc.fOrigin = kTopLeft_GrSurfaceOrigin;
	skia_desc.fSampleCnt = 0;
	skia_desc.fStencilBits = 0;
	skia_desc.fRenderTargetHandle = offscreen_target->framebuffer->gl_handle();

	SkAutoTUnref<GrRenderTarget> skia_render_target(
	GetGrContext()->wrapBackendRenderTarget(skia_desc));
	SkSurfaceProps skia_surface_props(
	SkSurfaceProps::kUseDistanceFieldFonts_Flag,
	SkSurfaceProps::kLegacyFontHost_InitType);
	offscreen_target->skia_surface.reset(SkSurface::NewRenderTargetDirect(
	skia_render_target, &skia_surface_props));
	}
	used_offscreen_targets_.push_back(offscreen_target);

	backend::FramebufferEGL* framebuffer = offscreen_target->framebuffer.get();
	SkCanvas* canvas = offscreen_target->skia_surface->getCanvas();

	canvas->save();
	canvas->clear(SkColorSetARGB(0, 0, 0, 0));
	canvas->translate(viewport.x(), viewport.y());
	fallback_rasterizer_->SubmitOffscreen(render_tree, canvas);
	canvas->restore();

	return framebuffer->GetColorTexture();
	}

	HardwareRasterizer::HardwareRasterizer(
	backend::GraphicsContext* graphics_context,
	int skia_cache_size_in_bytes,
	int scratch_surface_cache_size_in_bytes,
	int surface_cache_size_in_bytes)
	: impl_(new Impl(graphics_context,
	skia_cache_size_in_bytes,
	scratch_surface_cache_size_in_bytes,
	surface_cache_size_in_bytes)) {
	}

	void HardwareRasterizer::Submit(
	const scoped_refptr<render_tree::Node>& render_tree,
	const scoped_refptr<backend::RenderTarget>& render_target,
	const Options& options) {
	TRACE_EVENT0("cobalt::renderer", "HardwareRasterizer::Submit");
	impl_->Submit(render_tree, render_target, options);
	}

	render_tree::ResourceProvider* HardwareRasterizer::GetResourceProvider() {
	return impl_->GetResourceProvider();
	}

	} // namespace egl
	} // namespace rasterizer
	} // namespace renderer
	} // namespace cobalt