cc/software_renderer.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/software_renderer.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "cc/debug_border_draw_quad.h"
   9 #include "cc/render_pass_draw_quad.h"
  10 #include "cc/solid_color_draw_quad.h"
  11 #include "cc/texture_draw_quad.h"
  12 #include "cc/tile_draw_quad.h"
  13 #include "third_party/skia/include/core/SkCanvas.h"
  14 #include "third_party/skia/include/core/SkColor.h"
  15 #include "third_party/skia/include/core/SkMatrix.h"
  16 #include "third_party/skia/include/core/SkShader.h"
  17 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
  18 #include "ui/gfx/rect_conversions.h"
  19 #include "ui/gfx/skia_util.h"
  20 #include <public/WebCompositorSoftwareOutputDevice.h>
  21 #include <public/WebImage.h>
  22 #include <public/WebSize.h>
  23 #include <public/WebTransformationMatrix.h>
  24
  25 using WebKit::WebCompositorSoftwareOutputDevice;
  26 using WebKit::WebSize;
  27 using WebKit::WebTransformationMatrix;
  28
  29 namespace cc {
  30
  31 namespace {
  32
  33 void toSkMatrix(SkMatrix* flattened, const WebTransformationMatrix& m)
  34 {
  35     // Convert from 4x4 to 3x3 by dropping the third row and column.
  36     flattened->set(0, SkDoubleToScalar(m.m11()));
  37     flattened->set(1, SkDoubleToScalar(m.m21()));
  38     flattened->set(2, SkDoubleToScalar(m.m41()));
  39     flattened->set(3, SkDoubleToScalar(m.m12()));
  40     flattened->set(4, SkDoubleToScalar(m.m22()));
  41     flattened->set(5, SkDoubleToScalar(m.m42()));
  42     flattened->set(6, SkDoubleToScalar(m.m14()));
  43     flattened->set(7, SkDoubleToScalar(m.m24()));
  44     flattened->set(8, SkDoubleToScalar(m.m44()));
  45 }
  46
  47 bool isScaleAndTranslate(const SkMatrix& matrix)
  48 {
  49     return SkScalarNearlyZero(matrix[SkMatrix::kMSkewX]) &&
  50            SkScalarNearlyZero(matrix[SkMatrix::kMSkewY]) &&
  51            SkScalarNearlyZero(matrix[SkMatrix::kMPersp0]) &&
  52            SkScalarNearlyZero(matrix[SkMatrix::kMPersp1]) &&
  53            SkScalarNearlyZero(matrix[SkMatrix::kMPersp2] - 1.0f);
  54 }
  55
  56 } // anonymous namespace
  57
  58 scoped_ptr<SoftwareRenderer> SoftwareRenderer::create(RendererClient* client, ResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
  59 {
  60     return make_scoped_ptr(new SoftwareRenderer(client, resourceProvider, outputDevice));
  61 }
  62
  63 SoftwareRenderer::SoftwareRenderer(RendererClient* client, ResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
  64     : DirectRenderer(client, resourceProvider)
  65     , m_visible(true)
  66     , m_outputDevice(outputDevice)
  67     , m_skCurrentCanvas(0)
  68 {
  69     m_resourceProvider->setDefaultResourceType(ResourceProvider::Bitmap);
  70
  71     m_capabilities.maxTextureSize = INT_MAX;
  72     m_capabilities.bestTextureFormat = GL_RGBA;
  73     m_capabilities.contextHasCachedFrontBuffer = true;
  74     m_capabilities.usingSetVisibility = true;
  75
  76     viewportChanged();
  77 }
  78
  79 SoftwareRenderer::~SoftwareRenderer()
  80 {
  81 }
  82
  83 const RendererCapabilities& SoftwareRenderer::capabilities() const
  84 {
  85     return m_capabilities;
  86 }
  87
  88 void SoftwareRenderer::viewportChanged()
  89 {
  90     m_outputDevice->didChangeViewportSize(WebSize(viewportSize().width(), viewportSize().height()));
  91 }
  92
  93 void SoftwareRenderer::beginDrawingFrame(DrawingFrame& frame)
  94 {
  95     TRACE_EVENT0("cc", "SoftwareRenderer::beginDrawingFrame");
  96     m_skRootCanvas = make_scoped_ptr(new SkCanvas(m_outputDevice->lock(true)->getSkBitmap()));
  97 }
  98
  99 void SoftwareRenderer::finishDrawingFrame(DrawingFrame& frame)
 100 {
 101     TRACE_EVENT0("cc", "SoftwareRenderer::finishDrawingFrame");
 102     m_currentFramebufferLock.reset();
 103     m_skCurrentCanvas = 0;
 104     m_skRootCanvas.reset();
 105     m_outputDevice->unlock();
 106 }
 107
 108 bool SoftwareRenderer::flippedFramebuffer() const
 109 {
 110     return false;
 111 }
 112
 113 void SoftwareRenderer::finish()
 114 {
 115 }
 116
 117 void SoftwareRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)
 118 {
 119     m_currentFramebufferLock.reset();
 120     m_skCurrentCanvas = m_skRootCanvas.get();
 121 }
 122
 123 bool SoftwareRenderer::bindFramebufferToTexture(DrawingFrame& frame, const ScopedResource* texture, const gfx::Rect& framebufferRect)
 124 {
 125     m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockSoftware(m_resourceProvider, texture->id()));
 126     m_skCurrentCanvas = m_currentFramebufferLock->skCanvas();
 127     initializeMatrices(frame, framebufferRect, false);
 128     setDrawViewportSize(framebufferRect.size());
 129
 130     return true;
 131 }
 132
 133 void SoftwareRenderer::setScissorTestRect(const gfx::Rect& scissorRect)
 134 {
 135     m_skCurrentCanvas->clipRect(gfx::RectToSkRect(scissorRect), SkRegion::kReplace_Op);
 136 }
 137
 138 void SoftwareRenderer::clearFramebuffer(DrawingFrame& frame)
 139 {
 140     if (frame.currentRenderPass->hasTransparentBackground()) {
 141         m_skCurrentCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
 142     } else {
 143 #ifndef NDEBUG
 144         // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.
 145         m_skCurrentCanvas->clear(SkColorSetARGB(255, 0, 0, 255));
 146 #endif
 147     }
 148 }
 149
 150 void SoftwareRenderer::setDrawViewportSize(const gfx::Size& viewportSize)
 151 {
 152 }
 153
 154 bool SoftwareRenderer::isSoftwareResource(ResourceProvider::ResourceId id) const
 155 {
 156     switch (m_resourceProvider->resourceType(id)) {
 157     case ResourceProvider::GLTexture:
 158         return false;
 159     case ResourceProvider::Bitmap:
 160         return true;
 161     }
 162
 163     LOG(FATAL) << "Invalid resource type.";
 164     return false;
 165 }
 166
 167 void SoftwareRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
 168 {
 169     TRACE_EVENT0("cc", "SoftwareRenderer::drawQuad");
 170     WebTransformationMatrix quadRectMatrix;
 171     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->quadRect());
 172     WebTransformationMatrix contentsDeviceTransform = (frame.windowMatrix * frame.projectionMatrix * quadRectMatrix).to2dTransform();
 173     SkMatrix skDeviceMatrix;
 174     toSkMatrix(&skDeviceMatrix, contentsDeviceTransform);
 175     m_skCurrentCanvas->setMatrix(skDeviceMatrix);
 176
 177     m_skCurrentPaint.reset();
 178     if (!isScaleAndTranslate(skDeviceMatrix)) {
 179       m_skCurrentPaint.setAntiAlias(true);
 180       m_skCurrentPaint.setFilterBitmap(true);
 181     }
 182     if (quad->needsBlending()) {
 183         m_skCurrentPaint.setAlpha(quad->opacity() * 255);
 184         m_skCurrentPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
 185     } else {
 186         m_skCurrentPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
 187     }
 188
 189     switch (quad->material()) {
 190     case DrawQuad::DebugBorder:
 191         drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));
 192         break;
 193     case DrawQuad::SolidColor:
 194         drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));
 195         break;
 196     case DrawQuad::TextureContent:
 197         drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));
 198         break;
 199     case DrawQuad::TiledContent:
 200         drawTileQuad(frame, TileDrawQuad::materialCast(quad));
 201         break;
 202     case DrawQuad::RenderPass:
 203         drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
 204         break;
 205     default:
 206         drawUnsupportedQuad(frame, quad);
 207         break;
 208     }
 209
 210     m_skCurrentCanvas->resetMatrix();
 211 }
 212
 213 void SoftwareRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)
 214 {
 215     // We need to apply the matrix manually to have pixel-sized stroke width.
 216     SkPoint vertices[4];
 217     gfx::RectFToSkRect(quadVertexRect()).toQuad(vertices);
 218     SkPoint transformedVertices[4];
 219     m_skCurrentCanvas->getTotalMatrix().mapPoints(transformedVertices, vertices, 4);
 220     m_skCurrentCanvas->resetMatrix();
 221
 222     m_skCurrentPaint.setColor(quad->color());
 223     m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
 224     m_skCurrentPaint.setStyle(SkPaint::kStroke_Style);
 225     m_skCurrentPaint.setStrokeWidth(quad->width());
 226     m_skCurrentCanvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, transformedVertices, m_skCurrentPaint);
 227 }
 228
 229 void SoftwareRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 230 {
 231     m_skCurrentPaint.setColor(quad->color());
 232     m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
 233     m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint);
 234 }
 235
 236 void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 237 {
 238     if (!isSoftwareResource(quad->resourceId())) {
 239         drawUnsupportedQuad(frame, quad);
 240         return;
 241     }
 242
 243     // FIXME: Add support for non-premultiplied alpha.
 244     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
 245     const SkBitmap* bitmap = lock.skBitmap();
 246     gfx::RectF uvRect = gfx::ScaleRect(quad->uvRect(), bitmap->width(), bitmap->height());
 247     SkRect skUvRect = gfx::RectFToSkRect(uvRect);
 248     if (quad->flipped())
 249         m_skCurrentCanvas->scale(1, -1);
 250     m_skCurrentCanvas->drawBitmapRectToRect(*bitmap, &skUvRect,
 251                                             gfx::RectFToSkRect(quadVertexRect()),
 252                                             &m_skCurrentPaint);
 253 }
 254
 255 void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
 256 {
 257     DCHECK(isSoftwareResource(quad->resourceId()));
 258     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
 259
 260     SkRect uvRect = SkRect::MakeXYWH(
 261         quad->textureOffset().x(), quad->textureOffset().y(),
 262         quad->quadRect().width(), quad->quadRect().height());
 263     m_skCurrentPaint.setFilterBitmap(true);
 264     m_skCurrentCanvas->drawBitmapRectToRect(*lock.skBitmap(), &uvRect,
 265                                             gfx::RectFToSkRect(quadVertexRect()),
 266                                             &m_skCurrentPaint);
 267 }
 268
 269 void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const RenderPassDrawQuad* quad)
 270 {
 271     CachedResource* contentTexture = m_renderPassTextures.get(quad->renderPassId());
 272     if (!contentTexture || !contentTexture->id())
 273         return;
 274
 275     const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
 276     DCHECK(renderPass);
 277     if (!renderPass)
 278         return;
 279
 280     DCHECK(isSoftwareResource(contentTexture->id()));
 281     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, contentTexture->id());
 282
 283     SkRect destRect = gfx::RectFToSkRect(quadVertexRect());
 284
 285     const SkBitmap* content = lock.skBitmap();
 286
 287     SkRect contentRect;
 288     content->getBounds(&contentRect);
 289
 290     SkMatrix contentMat;
 291     contentMat.setRectToRect(contentRect, destRect, SkMatrix::kFill_ScaleToFit);
 292
 293     SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(*content,
 294                                                                SkShader::kClamp_TileMode,
 295                                                                SkShader::kClamp_TileMode));
 296     shader->setLocalMatrix(contentMat);
 297     m_skCurrentPaint.setShader(shader);
 298
 299     SkImageFilter* filter = renderPass->filter();
 300     if (filter)
 301         m_skCurrentPaint.setImageFilter(filter);
 302
 303     if (quad->maskResourceId()) {
 304         ResourceProvider::ScopedReadLockSoftware maskLock(m_resourceProvider, quad->maskResourceId());
 305
 306         const SkBitmap* mask = maskLock.skBitmap();
 307
 308         SkRect maskRect = SkRect::MakeXYWH(
 309             quad->maskTexCoordOffsetX() * mask->width(),
 310             quad->maskTexCoordOffsetY() * mask->height(),
 311             quad->maskTexCoordScaleX() * mask->width(),
 312             quad->maskTexCoordScaleY() * mask->height());
 313
 314         SkMatrix maskMat;
 315         maskMat.setRectToRect(maskRect, destRect, SkMatrix::kFill_ScaleToFit);
 316
 317         SkAutoTUnref<SkShader> maskShader(SkShader::CreateBitmapShader(*mask,
 318                                                                        SkShader::kClamp_TileMode,
 319                                                                        SkShader::kClamp_TileMode));
 320         maskShader->setLocalMatrix(maskMat);
 321
 322         SkPaint maskPaint;
 323         maskPaint.setShader(maskShader);
 324
 325         SkAutoTUnref<SkLayerRasterizer> maskRasterizer(new SkLayerRasterizer);
 326         maskRasterizer->addLayer(maskPaint);
 327
 328         m_skCurrentPaint.setRasterizer(maskRasterizer);
 329         m_skCurrentCanvas->drawRect(destRect, m_skCurrentPaint);
 330     } else {
 331         // FIXME: Apply background filters and blend with content
 332         m_skCurrentCanvas->drawRect(destRect, m_skCurrentPaint);
 333     }
 334 }
 335
 336 void SoftwareRenderer::drawUnsupportedQuad(const DrawingFrame& frame, const DrawQuad* quad)
 337 {
 338     m_skCurrentPaint.setColor(SK_ColorMAGENTA);
 339     m_skCurrentPaint.setAlpha(quad->opacity() * 255);
 340     m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint);
 341 }
 342
 343 bool SoftwareRenderer::swapBuffers()
 344 {
 345     if (m_client->hasImplThread())
 346         m_client->onSwapBuffersComplete();
 347     return true;
 348 }
 349
 350 void SoftwareRenderer::getFramebufferPixels(void *pixels, const gfx::Rect& rect)
 351 {
 352     TRACE_EVENT0("cc", "SoftwareRenderer::getFramebufferPixels");
 353     SkBitmap fullBitmap = m_outputDevice->lock(false)->getSkBitmap();
 354     SkBitmap subsetBitmap;
 355     SkIRect invertRect = SkIRect::MakeXYWH(rect.x(), viewportSize().height() - rect.bottom(), rect.width(), rect.height());
 356     fullBitmap.extractSubset(&subsetBitmap, invertRect);
 357     subsetBitmap.copyPixelsTo(pixels, rect.width() * rect.height() * 4, rect.width() * 4);
 358     m_outputDevice->unlock();
 359 }
 360
 361 void SoftwareRenderer::setVisible(bool visible)
 362 {
 363     if (m_visible == visible)
 364         return;
 365     m_visible = visible;
 366 }
 367
 368 }  // namespace cc