The Tor Browser: gfx/layers/d3d10/CanvasLayerD3D10.cpp@6474c204b198 (annotated)

gfx/layers/d3d10/CanvasLayerD3D10.cpp@6474c204b198 (annotated)

gfx/layers/d3d10/CanvasLayerD3D10.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "CanvasLayerD3D10.h"
 #include "../d3d9/Nv3DVUtils.h"
 #include "gfxWindowsSurface.h"
 #include "gfxWindowsPlatform.h"
 #include "SurfaceStream.h"
 #include "SharedSurfaceANGLE.h"
 #include "SharedSurfaceGL.h"
 #include "gfxContext.h"
 #include "GLContext.h"
 #include "gfxPrefs.h"
 using namespace mozilla::gl;
 using namespace mozilla::gfx;
 namespace mozilla {
 namespace layers {
 CanvasLayerD3D10::CanvasLayerD3D10(LayerManagerD3D10 *aManager)
   : CanvasLayer(aManager, nullptr)
   , LayerD3D10(aManager)
   , mDataIsPremultiplied(false)
   , mNeedsYFlip(false)
   , mHasAlpha(true)
 {
     mImplData = static_cast<LayerD3D10*>(this);
 }
 CanvasLayerD3D10::~CanvasLayerD3D10()
 {
 }
 void
 CanvasLayerD3D10::Initialize(const Data& aData)
 {
   NS_ASSERTION(mSurface == nullptr, "BasicCanvasLayer::Initialize called twice!");
   if (aData.mGLContext) {
     mGLContext = aData.mGLContext;
     NS_ASSERTION(mGLContext->IsOffscreen(), "Canvas GLContext must be offscreen.");
     mDataIsPremultiplied = aData.mIsGLAlphaPremult;
     mNeedsYFlip = true;
     GLScreenBuffer* screen = mGLContext->Screen();
     SurfaceStreamType streamType =
         SurfaceStream::ChooseGLStreamType(SurfaceStream::MainThread,
                                           screen->PreserveBuffer());
     SurfaceFactory_GL* factory = nullptr;
     if (!gfxPrefs::WebGLForceLayersReadback()) {
       if (mGLContext->IsANGLE()) {
         factory = SurfaceFactory_ANGLEShareHandle::Create(mGLContext,
                                                           device(),
                                                           screen->Caps());
       }
     }
     if (factory) {
       screen->Morph(factory, streamType);
     }
   } else if (aData.mDrawTarget) {
     mDrawTarget = aData.mDrawTarget;
     mNeedsYFlip = false;
     mDataIsPremultiplied = true;
     void *texture = mDrawTarget->GetNativeSurface(NativeSurfaceType::D3D10_TEXTURE);
     if (texture) {
       mTexture = static_cast<ID3D10Texture2D*>(texture);
       NS_ASSERTION(!aData.mGLContext,
                    "CanvasLayer can't have both DrawTarget and WebGLContext/Surface");
       mBounds.SetRect(0, 0, aData.mSize.width, aData.mSize.height);
       device()->CreateShaderResourceView(mTexture, nullptr, getter_AddRefs(mSRView));
       return;
     }
     // XXX we should store mDrawTarget and use it directly in UpdateSurface,
     // bypassing Thebes
     mSurface = mDrawTarget->Snapshot();
   } else {
     NS_ERROR("CanvasLayer created without mSurface, mDrawTarget or mGLContext?");
   }
   mBounds.SetRect(0, 0, aData.mSize.width, aData.mSize.height);
   mIsD2DTexture = false;
   // Create a texture in case we need to readback.
   CD3D10_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, mBounds.width, mBounds.height, 1, 1);
   desc.Usage = D3D10_USAGE_DYNAMIC;
   desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
   HRESULT hr = device()->CreateTexture2D(&desc, nullptr, getter_AddRefs(mTexture));
   if (FAILED(hr)) {
     NS_WARNING("Failed to create texture for CanvasLayer!");
     return;
   }
   device()->CreateShaderResourceView(mTexture, nullptr, getter_AddRefs(mUploadSRView));
 }
 void
 CanvasLayerD3D10::UpdateSurface()
 {
   if (!IsDirty())
     return;
   Painted();
   if (mDrawTarget) {
     mDrawTarget->Flush();
   } else if (mIsD2DTexture) {
     return;
   }
   if (!mTexture) {
     return;
   }
   if (mGLContext) {
     SharedSurface_GL* surf = mGLContext->RequestFrame();
     if (!surf) {
       return;
     }
     switch (surf->Type()) {
       case SharedSurfaceType::EGLSurfaceANGLE: {
         SharedSurface_ANGLEShareHandle* shareSurf = SharedSurface_ANGLEShareHandle::Cast(surf);
         mSRView = shareSurf->GetSRV();
         return;
       }
       case SharedSurfaceType::Basic: {
         SharedSurface_Basic* shareSurf = SharedSurface_Basic::Cast(surf);
         // WebGL reads entire surface.
         D3D10_MAPPED_TEXTURE2D map;
         HRESULT hr = mTexture->Map(0, D3D10_MAP_WRITE_DISCARD, 0, &map);
         if (FAILED(hr)) {
           NS_WARNING("Failed to map CanvasLayer texture.");
           return;
         }
         DataSourceSurface* frameData = shareSurf->GetData();
         // Scope for DrawTarget, so it's destroyed before Unmap.
         {
           IntSize boundsSize(mBounds.width, mBounds.height);
           RefPtr<DrawTarget> mapDt = Factory::CreateDrawTargetForData(BackendType::CAIRO,
                                                                       (uint8_t*)map.pData,
                                                                       boundsSize,
                                                                       map.RowPitch,
                                                                       SurfaceFormat::B8G8R8A8);
           Rect drawRect(0, 0, frameData->GetSize().width, frameData->GetSize().height);
           mapDt->DrawSurface(frameData, drawRect, drawRect,
                              DrawSurfaceOptions(),  DrawOptions(1.0F, CompositionOp::OP_SOURCE));
           mapDt->Flush();
         }
         mTexture->Unmap(0);
         mSRView = mUploadSRView;
         break;
       }
       default:
         MOZ_CRASH("Unhandled SharedSurfaceType.");
     }
   } else if (mSurface) {
     D3D10_MAPPED_TEXTURE2D map;
     HRESULT hr = mTexture->Map(0, D3D10_MAP_WRITE_DISCARD, 0, &map);
     if (FAILED(hr)) {
       NS_WARNING("Failed to lock CanvasLayer texture.");
       return;
     }
     RefPtr<DrawTarget> destTarget =
       Factory::CreateDrawTargetForD3D10Texture(mTexture,
                                                SurfaceFormat::R8G8B8A8);
     Rect r(Point(0, 0), ToRect(mBounds).Size());
     destTarget->DrawSurface(mSurface, r, r, DrawSurfaceOptions(),
                             DrawOptions(1.0F, CompositionOp::OP_SOURCE));
     mTexture->Unmap(0);
     mSRView = mUploadSRView;
   }
 }
 Layer*
 CanvasLayerD3D10::GetLayer()
 {
   return this;
 }
 void
 CanvasLayerD3D10::RenderLayer()
 {
   FirePreTransactionCallback();
   UpdateSurface();
   FireDidTransactionCallback();
   if (!mTexture)
     return;
   nsIntRect visibleRect = mVisibleRegion.GetBounds();
   SetEffectTransformAndOpacity();
   uint8_t shaderFlags = 0;
   shaderFlags |= LoadMaskTexture();
   shaderFlags |= mDataIsPremultiplied
                 ? SHADER_PREMUL : SHADER_NON_PREMUL | SHADER_RGBA;
   shaderFlags |= mHasAlpha ? SHADER_RGBA : SHADER_RGB;
   shaderFlags |= mFilter == GraphicsFilter::FILTER_NEAREST
                 ? SHADER_POINT : SHADER_LINEAR;
   ID3D10EffectTechnique* technique = SelectShader(shaderFlags);
   if (mSRView) {
     effect()->GetVariableByName("tRGB")->AsShaderResource()->SetResource(mSRView);
   }
   effect()->GetVariableByName("vLayerQuad")->AsVector()->SetFloatVector(
     ShaderConstantRectD3D10(
       (float)mBounds.x,
       (float)mBounds.y,
       (float)mBounds.width,
       (float)mBounds.height)
     );
   if (mNeedsYFlip) {
     effect()->GetVariableByName("vTextureCoords")->AsVector()->SetFloatVector(
       ShaderConstantRectD3D10(
 ,
 .0f,
 .0f,
         -1.0f)
       );
   }
   technique->GetPassByIndex(0)->Apply(0);
   device()->Draw(4, 0);
   if (mNeedsYFlip) {
     effect()->GetVariableByName("vTextureCoords")->AsVector()->
       SetFloatVector(ShaderConstantRectD3D10(0, 0, 1.0f, 1.0f));
   }
 }
 } /* namespace layers */
 } /* namespace mozilla */

The Tor Browser / annotate

gfx/layers/d3d10/CanvasLayerD3D10.cpp@6474c204b198 (annotated)

gfx/layers/d3d10/CanvasLayerD3D10.cpp