diff options
Diffstat (limited to 'gfx/2d/DrawTargetD2D1.cpp')
| -rw-r--r-- | gfx/2d/DrawTargetD2D1.cpp | 1931 |
1 files changed, 1931 insertions, 0 deletions
diff --git a/gfx/2d/DrawTargetD2D1.cpp b/gfx/2d/DrawTargetD2D1.cpp new file mode 100644 index 000000000..d9deb4c10 --- /dev/null +++ b/gfx/2d/DrawTargetD2D1.cpp @@ -0,0 +1,1931 @@ +/* -*- 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 <initguid.h> +#include "DrawTargetD2D1.h" +#include "FilterNodeSoftware.h" +#include "GradientStopsD2D.h" +#include "SourceSurfaceD2D1.h" +#include "RadialGradientEffectD2D1.h" + +#include "HelpersD2D.h" +#include "FilterNodeD2D1.h" +#include "ExtendInputEffectD2D1.h" +#include "Tools.h" + +using namespace std; + +// decltype is not usable for overloaded functions. +typedef HRESULT (WINAPI*D2D1CreateFactoryFunc)( + D2D1_FACTORY_TYPE factoryType, + REFIID iid, + CONST D2D1_FACTORY_OPTIONS *pFactoryOptions, + void **factory +); + +namespace mozilla { +namespace gfx { + +uint64_t DrawTargetD2D1::mVRAMUsageDT; +uint64_t DrawTargetD2D1::mVRAMUsageSS; +IDWriteFactory *DrawTargetD2D1::mDWriteFactory; +ID2D1Factory1* DrawTargetD2D1::mFactory = nullptr; + +ID2D1Factory1 *D2DFactory1() +{ + return DrawTargetD2D1::factory(); +} + +DrawTargetD2D1::DrawTargetD2D1() + : mPushedLayers(1) + , mUsedCommandListsSincePurge(0) + , mDidComplexBlendWithListInList(false) +{ +} + +DrawTargetD2D1::~DrawTargetD2D1() +{ + PopAllClips(); + + if (mSnapshot) { + // We may hold the only reference. MarkIndependent will clear mSnapshot; + // keep the snapshot object alive so it doesn't get destroyed while + // MarkIndependent is running. + RefPtr<SourceSurfaceD2D1> deathGrip = mSnapshot; + // mSnapshot can be treated as independent of this DrawTarget since we know + // this DrawTarget won't change again. + deathGrip->MarkIndependent(); + // mSnapshot will be cleared now. + } + + if (mDC) { + // The only way mDC can be null is if Init failed, but it can happen and the + // destructor is the only place where we need to check for it since the + // DrawTarget will destroyed right after Init fails. + mDC->EndDraw(); + } + + // Targets depending on us can break that dependency, since we're obviously not going to + // be modified in the future. + for (auto iter = mDependentTargets.begin(); + iter != mDependentTargets.end(); iter++) { + (*iter)->mDependingOnTargets.erase(this); + } + // Our dependencies on other targets no longer matter. + for (TargetSet::iterator iter = mDependingOnTargets.begin(); + iter != mDependingOnTargets.end(); iter++) { + (*iter)->mDependentTargets.erase(this); + } +} + +already_AddRefed<SourceSurface> +DrawTargetD2D1::Snapshot() +{ + if (mSnapshot) { + RefPtr<SourceSurface> snapshot(mSnapshot); + return snapshot.forget(); + } + PopAllClips(); + + Flush(); + + mSnapshot = new SourceSurfaceD2D1(mBitmap, mDC, mFormat, mSize, this); + + RefPtr<SourceSurface> snapshot(mSnapshot); + return snapshot.forget(); +} + +// Command lists are kept around by device contexts until EndDraw is called, +// this can cause issues with memory usage (see bug 1238328). EndDraw/BeginDraw +// are expensive though, especially relatively when little work is done, so +// we try to reduce the amount of times we execute these purges. +static const uint32_t kPushedLayersBeforePurge = 25; + +void +DrawTargetD2D1::Flush() +{ + if ((mUsedCommandListsSincePurge >= kPushedLayersBeforePurge) && + mPushedLayers.size() == 1) { + // It's important to pop all clips as otherwise layers can forget about + // their clip when doing an EndDraw. When we have layers pushed we cannot + // easily pop all underlying clips to delay the purge until we have no + // layers pushed. + PopAllClips(); + mUsedCommandListsSincePurge = 0; + mDC->EndDraw(); + mDC->BeginDraw(); + } else { + mDC->Flush(); + } + + // We no longer depend on any target. + for (TargetSet::iterator iter = mDependingOnTargets.begin(); + iter != mDependingOnTargets.end(); iter++) { + (*iter)->mDependentTargets.erase(this); + } + mDependingOnTargets.clear(); +} + +void +DrawTargetD2D1::DrawSurface(SourceSurface *aSurface, + const Rect &aDest, + const Rect &aSource, + const DrawSurfaceOptions &aSurfOptions, + const DrawOptions &aOptions) +{ + PrepareForDrawing(aOptions.mCompositionOp, ColorPattern(Color())); + + D2D1_RECT_F samplingBounds; + + if (aSurfOptions.mSamplingBounds == SamplingBounds::BOUNDED) { + samplingBounds = D2DRect(aSource); + } else { + samplingBounds = D2D1::RectF(0, 0, Float(aSurface->GetSize().width), Float(aSurface->GetSize().height)); + } + + Float xScale = aDest.width / aSource.width; + Float yScale = aDest.height / aSource.height; + + RefPtr<ID2D1ImageBrush> brush; + + // Here we scale the source pattern up to the size and position where we want + // it to be. + Matrix transform; + transform.PreTranslate(aDest.x - aSource.x * xScale, aDest.y - aSource.y * yScale); + transform.PreScale(xScale, yScale); + + RefPtr<ID2D1Image> image = GetImageForSurface(aSurface, transform, ExtendMode::CLAMP); + + if (!image) { + gfxWarning() << *this << ": Unable to get D2D image for surface."; + return; + } + + RefPtr<ID2D1Bitmap> bitmap; + if (aSurface->GetType() == SurfaceType::D2D1_1_IMAGE) { + // If this is called with a DataSourceSurface it might do a partial upload + // that our DrawBitmap call doesn't support. + image->QueryInterface((ID2D1Bitmap**)getter_AddRefs(bitmap)); + } + + if (bitmap && aSurfOptions.mSamplingBounds == SamplingBounds::UNBOUNDED) { + mDC->DrawBitmap(bitmap, D2DRect(aDest), aOptions.mAlpha, + D2DFilter(aSurfOptions.mSamplingFilter), D2DRect(aSource)); + } else { + // This has issues ignoring the alpha channel on windows 7 with images marked opaque. + MOZ_ASSERT(aSurface->GetFormat() != SurfaceFormat::B8G8R8X8); + + // Bug 1275478 - D2D1 cannot draw A8 surface correctly. + MOZ_ASSERT(aSurface->GetFormat() != SurfaceFormat::A8); + + mDC->CreateImageBrush(image, + D2D1::ImageBrushProperties(samplingBounds, + D2D1_EXTEND_MODE_CLAMP, + D2D1_EXTEND_MODE_CLAMP, + D2DInterpolationMode(aSurfOptions.mSamplingFilter)), + D2D1::BrushProperties(aOptions.mAlpha, D2DMatrix(transform)), + getter_AddRefs(brush)); + mDC->FillRectangle(D2DRect(aDest), brush); + } + + FinalizeDrawing(aOptions.mCompositionOp, ColorPattern(Color())); +} + +void +DrawTargetD2D1::DrawFilter(FilterNode *aNode, + const Rect &aSourceRect, + const Point &aDestPoint, + const DrawOptions &aOptions) +{ + if (aNode->GetBackendType() != FILTER_BACKEND_DIRECT2D1_1) { + gfxWarning() << *this << ": Incompatible filter passed to DrawFilter."; + return; + } + + PrepareForDrawing(aOptions.mCompositionOp, ColorPattern(Color())); + + mDC->SetAntialiasMode(D2DAAMode(aOptions.mAntialiasMode)); + + FilterNodeD2D1* node = static_cast<FilterNodeD2D1*>(aNode); + node->WillDraw(this); + + mDC->DrawImage(node->OutputEffect(), D2DPoint(aDestPoint), D2DRect(aSourceRect)); + + FinalizeDrawing(aOptions.mCompositionOp, ColorPattern(Color())); +} + +void +DrawTargetD2D1::DrawSurfaceWithShadow(SourceSurface *aSurface, + const Point &aDest, + const Color &aColor, + const Point &aOffset, + Float aSigma, + CompositionOp aOperator) +{ + MarkChanged(); + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + Matrix mat; + RefPtr<ID2D1Image> image = GetImageForSurface(aSurface, mat, ExtendMode::CLAMP); + + if (!image) { + gfxWarning() << "Couldn't get image for surface."; + return; + } + + if (!mat.IsIdentity()) { + gfxDebug() << *this << ": At this point complex partial uploads are not supported for Shadow surfaces."; + return; + } + + // Step 1, create the shadow effect. + RefPtr<ID2D1Effect> shadowEffect; + HRESULT hr = mDC->CreateEffect(CLSID_D2D1Shadow, getter_AddRefs(shadowEffect)); + if (FAILED(hr) || !shadowEffect) { + gfxWarning() << "Failed to create shadow effect. Code: " << hexa(hr); + return; + } + shadowEffect->SetInput(0, image); + shadowEffect->SetValue(D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION, aSigma); + D2D1_VECTOR_4F color = { aColor.r, aColor.g, aColor.b, aColor.a }; + shadowEffect->SetValue(D2D1_SHADOW_PROP_COLOR, color); + + D2D1_POINT_2F shadowPoint = D2DPoint(aDest + aOffset); + mDC->DrawImage(shadowEffect, &shadowPoint, nullptr, D2D1_INTERPOLATION_MODE_LINEAR, D2DCompositionMode(aOperator)); + + D2D1_POINT_2F imgPoint = D2DPoint(aDest); + mDC->DrawImage(image, &imgPoint, nullptr, D2D1_INTERPOLATION_MODE_LINEAR, D2DCompositionMode(aOperator)); +} + +void +DrawTargetD2D1::ClearRect(const Rect &aRect) +{ + MarkChanged(); + + PopAllClips(); + + PushClipRect(aRect); + + if (mTransformDirty || + !mTransform.IsIdentity()) { + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + } + + D2D1_RECT_F clipRect; + bool isPixelAligned; + if (mTransform.IsRectilinear() && + GetDeviceSpaceClipRect(clipRect, isPixelAligned)) { + mDC->PushAxisAlignedClip(clipRect, isPixelAligned ? D2D1_ANTIALIAS_MODE_ALIASED : D2D1_ANTIALIAS_MODE_PER_PRIMITIVE); + mDC->Clear(); + mDC->PopAxisAlignedClip(); + + PopClip(); + return; + } + + RefPtr<ID2D1CommandList> list; + mUsedCommandListsSincePurge++; + mDC->CreateCommandList(getter_AddRefs(list)); + mDC->SetTarget(list); + + IntRect addClipRect; + RefPtr<ID2D1Geometry> geom = GetClippedGeometry(&addClipRect); + + RefPtr<ID2D1SolidColorBrush> brush; + mDC->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::White), getter_AddRefs(brush)); + mDC->PushAxisAlignedClip(D2D1::RectF(addClipRect.x, addClipRect.y, addClipRect.XMost(), addClipRect.YMost()), D2D1_ANTIALIAS_MODE_PER_PRIMITIVE); + mDC->FillGeometry(geom, brush); + mDC->PopAxisAlignedClip(); + + mDC->SetTarget(CurrentTarget()); + list->Close(); + + mDC->DrawImage(list, D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, D2D1_COMPOSITE_MODE_DESTINATION_OUT); + + PopClip(); + + return; +} + +void +DrawTargetD2D1::MaskSurface(const Pattern &aSource, + SourceSurface *aMask, + Point aOffset, + const DrawOptions &aOptions) +{ + MarkChanged(); + + RefPtr<ID2D1Bitmap> bitmap; + + Matrix mat = Matrix::Translation(aOffset); + RefPtr<ID2D1Image> image = GetImageForSurface(aMask, mat, ExtendMode::CLAMP, nullptr); + + MOZ_ASSERT(!mat.HasNonTranslation()); + aOffset.x = mat._31; + aOffset.y = mat._32; + + if (!image) { + gfxWarning() << "Failed to get image for surface."; + return; + } + + PrepareForDrawing(aOptions.mCompositionOp, aSource); + + // FillOpacityMask only works if the antialias mode is MODE_ALIASED + mDC->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED); + + image->QueryInterface((ID2D1Bitmap**)getter_AddRefs(bitmap)); + if (!bitmap) { + gfxWarning() << "FillOpacityMask only works with Bitmap source surfaces."; + return; + } + + IntSize size = IntSize::Truncate(bitmap->GetSize().width, bitmap->GetSize().height); + + Rect maskRect = Rect(0.f, 0.f, Float(size.width), Float(size.height)); + + Rect dest = Rect(aOffset.x, aOffset.y, Float(size.width), Float(size.height)); + RefPtr<ID2D1Brush> brush = CreateBrushForPattern(aSource, aOptions.mAlpha); + mDC->FillOpacityMask(bitmap, brush, D2D1_OPACITY_MASK_CONTENT_GRAPHICS, D2DRect(dest), D2DRect(maskRect)); + + mDC->SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE); + + FinalizeDrawing(aOptions.mCompositionOp, aSource); +} + +void +DrawTargetD2D1::CopySurface(SourceSurface *aSurface, + const IntRect &aSourceRect, + const IntPoint &aDestination) +{ + MarkChanged(); + + PopAllClips(); + + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + Matrix mat = Matrix::Translation(aDestination.x - aSourceRect.x, aDestination.y - aSourceRect.y); + RefPtr<ID2D1Image> image = GetImageForSurface(aSurface, mat, ExtendMode::CLAMP); + + if (!image) { + gfxWarning() << "Couldn't get image for surface."; + return; + } + + if (mat.HasNonIntegerTranslation()) { + gfxDebug() << *this << ": At this point scaled partial uploads are not supported for CopySurface."; + return; + } + + IntRect sourceRect = aSourceRect; + sourceRect.x += (aDestination.x - aSourceRect.x) - mat._31; + sourceRect.width -= (aDestination.x - aSourceRect.x) - mat._31; + sourceRect.y += (aDestination.y - aSourceRect.y) - mat._32; + sourceRect.height -= (aDestination.y - aSourceRect.y) - mat._32; + + RefPtr<ID2D1Bitmap> bitmap; + image->QueryInterface((ID2D1Bitmap**)getter_AddRefs(bitmap)); + + if (bitmap && mFormat == SurfaceFormat::A8) { + RefPtr<ID2D1SolidColorBrush> brush; + mDC->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::White), + D2D1::BrushProperties(), getter_AddRefs(brush)); + mDC->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED); + mDC->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_COPY); + mDC->FillOpacityMask(bitmap, brush, D2D1_OPACITY_MASK_CONTENT_GRAPHICS); + mDC->SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE); + mDC->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_SOURCE_OVER); + return; + } + + Rect srcRect(Float(sourceRect.x), Float(sourceRect.y), + Float(aSourceRect.width), Float(aSourceRect.height)); + + Rect dstRect(Float(aDestination.x), Float(aDestination.y), + Float(aSourceRect.width), Float(aSourceRect.height)); + + if (bitmap) { + mDC->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_COPY); + mDC->DrawBitmap(bitmap, D2DRect(dstRect), 1.0f, + D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, + D2DRect(srcRect)); + mDC->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_SOURCE_OVER); + return; + } + + mDC->DrawImage(image, D2D1::Point2F(Float(aDestination.x), Float(aDestination.y)), + D2DRect(srcRect), D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, + D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY); +} + +void +DrawTargetD2D1::FillRect(const Rect &aRect, + const Pattern &aPattern, + const DrawOptions &aOptions) +{ + PrepareForDrawing(aOptions.mCompositionOp, aPattern); + + mDC->SetAntialiasMode(D2DAAMode(aOptions.mAntialiasMode)); + + RefPtr<ID2D1Brush> brush = CreateBrushForPattern(aPattern, aOptions.mAlpha); + mDC->FillRectangle(D2DRect(aRect), brush); + + FinalizeDrawing(aOptions.mCompositionOp, aPattern); +} + +void +DrawTargetD2D1::StrokeRect(const Rect &aRect, + const Pattern &aPattern, + const StrokeOptions &aStrokeOptions, + const DrawOptions &aOptions) +{ + PrepareForDrawing(aOptions.mCompositionOp, aPattern); + + mDC->SetAntialiasMode(D2DAAMode(aOptions.mAntialiasMode)); + + RefPtr<ID2D1Brush> brush = CreateBrushForPattern(aPattern, aOptions.mAlpha); + RefPtr<ID2D1StrokeStyle> strokeStyle = CreateStrokeStyleForOptions(aStrokeOptions); + + mDC->DrawRectangle(D2DRect(aRect), brush, aStrokeOptions.mLineWidth, strokeStyle); + + FinalizeDrawing(aOptions.mCompositionOp, aPattern); +} + +void +DrawTargetD2D1::StrokeLine(const Point &aStart, + const Point &aEnd, + const Pattern &aPattern, + const StrokeOptions &aStrokeOptions, + const DrawOptions &aOptions) +{ + PrepareForDrawing(aOptions.mCompositionOp, aPattern); + + mDC->SetAntialiasMode(D2DAAMode(aOptions.mAntialiasMode)); + + RefPtr<ID2D1Brush> brush = CreateBrushForPattern(aPattern, aOptions.mAlpha); + RefPtr<ID2D1StrokeStyle> strokeStyle = CreateStrokeStyleForOptions(aStrokeOptions); + + mDC->DrawLine(D2DPoint(aStart), D2DPoint(aEnd), brush, aStrokeOptions.mLineWidth, strokeStyle); + + FinalizeDrawing(aOptions.mCompositionOp, aPattern); +} + +void +DrawTargetD2D1::Stroke(const Path *aPath, + const Pattern &aPattern, + const StrokeOptions &aStrokeOptions, + const DrawOptions &aOptions) +{ + if (aPath->GetBackendType() != BackendType::DIRECT2D1_1) { + gfxDebug() << *this << ": Ignoring drawing call for incompatible path."; + return; + } + const PathD2D *d2dPath = static_cast<const PathD2D*>(aPath); + + PrepareForDrawing(aOptions.mCompositionOp, aPattern); + + mDC->SetAntialiasMode(D2DAAMode(aOptions.mAntialiasMode)); + + RefPtr<ID2D1Brush> brush = CreateBrushForPattern(aPattern, aOptions.mAlpha); + RefPtr<ID2D1StrokeStyle> strokeStyle = CreateStrokeStyleForOptions(aStrokeOptions); + + mDC->DrawGeometry(d2dPath->mGeometry, brush, aStrokeOptions.mLineWidth, strokeStyle); + + FinalizeDrawing(aOptions.mCompositionOp, aPattern); +} + +void +DrawTargetD2D1::Fill(const Path *aPath, + const Pattern &aPattern, + const DrawOptions &aOptions) +{ + if (!aPath || aPath->GetBackendType() != BackendType::DIRECT2D1_1) { + gfxDebug() << *this << ": Ignoring drawing call for incompatible path."; + return; + } + const PathD2D *d2dPath = static_cast<const PathD2D*>(aPath); + + PrepareForDrawing(aOptions.mCompositionOp, aPattern); + + mDC->SetAntialiasMode(D2DAAMode(aOptions.mAntialiasMode)); + + RefPtr<ID2D1Brush> brush = CreateBrushForPattern(aPattern, aOptions.mAlpha); + + mDC->FillGeometry(d2dPath->mGeometry, brush); + + FinalizeDrawing(aOptions.mCompositionOp, aPattern); +} + +void +DrawTargetD2D1::FillGlyphs(ScaledFont *aFont, + const GlyphBuffer &aBuffer, + const Pattern &aPattern, + const DrawOptions &aOptions, + const GlyphRenderingOptions *aRenderingOptions) +{ + if (aFont->GetType() != FontType::DWRITE) { + gfxDebug() << *this << ": Ignoring drawing call for incompatible font."; + return; + } + + ScaledFontDWrite *font = static_cast<ScaledFontDWrite*>(aFont); + + IDWriteRenderingParams *params = nullptr; + if (aRenderingOptions) { + if (aRenderingOptions->GetType() != FontType::DWRITE) { + gfxDebug() << *this << ": Ignoring incompatible GlyphRenderingOptions."; + // This should never happen. + MOZ_ASSERT(false); + } else { + params = static_cast<const GlyphRenderingOptionsDWrite*>(aRenderingOptions)->mParams; + } + } + + AntialiasMode aaMode = font->GetDefaultAAMode(); + + if (aOptions.mAntialiasMode != AntialiasMode::DEFAULT) { + aaMode = aOptions.mAntialiasMode; + } + + PrepareForDrawing(aOptions.mCompositionOp, aPattern); + + bool forceClearType = false; + if (!CurrentLayer().mIsOpaque && mPermitSubpixelAA && + aOptions.mCompositionOp == CompositionOp::OP_OVER && aaMode == AntialiasMode::SUBPIXEL) { + forceClearType = true; + } + + + D2D1_TEXT_ANTIALIAS_MODE d2dAAMode = D2D1_TEXT_ANTIALIAS_MODE_DEFAULT; + + switch (aaMode) { + case AntialiasMode::NONE: + d2dAAMode = D2D1_TEXT_ANTIALIAS_MODE_ALIASED; + break; + case AntialiasMode::GRAY: + d2dAAMode = D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE; + break; + case AntialiasMode::SUBPIXEL: + d2dAAMode = D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE; + break; + default: + d2dAAMode = D2D1_TEXT_ANTIALIAS_MODE_DEFAULT; + } + + if (d2dAAMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE && + !CurrentLayer().mIsOpaque && !forceClearType) { + d2dAAMode = D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE; + } + + mDC->SetTextAntialiasMode(d2dAAMode); + + if (params != mTextRenderingParams) { + mDC->SetTextRenderingParams(params); + mTextRenderingParams = params; + } + + RefPtr<ID2D1Brush> brush = CreateBrushForPattern(aPattern, aOptions.mAlpha); + + AutoDWriteGlyphRun autoRun; + DWriteGlyphRunFromGlyphs(aBuffer, font, &autoRun); + + bool needsRepushedLayers = false; + if (forceClearType) { + D2D1_RECT_F rect; + bool isAligned; + needsRepushedLayers = CurrentLayer().mPushedClips.size() && !GetDeviceSpaceClipRect(rect, isAligned); + + // If we have a complex clip in our stack and we have a transparent + // background, and subpixel AA is permitted, we need to repush our layer + // stack limited by the glyph run bounds initializing our layers for + // subpixel AA. + if (needsRepushedLayers) { + mDC->GetGlyphRunWorldBounds(D2D1::Point2F(), &autoRun, + DWRITE_MEASURING_MODE_NATURAL, &rect); + rect.left = std::floor(rect.left); + rect.right = std::ceil(rect.right); + rect.top = std::floor(rect.top); + rect.bottom = std::ceil(rect.bottom); + + PopAllClips(); + + if (!mTransform.IsRectilinear()) { + // We must limit the pixels we touch to the -user space- bounds of + // the glyphs being drawn. In order not to get transparent pixels + // copied up in our pushed layer stack. + D2D1_RECT_F userRect; + mDC->SetTransform(D2D1::IdentityMatrix()); + mDC->GetGlyphRunWorldBounds(D2D1::Point2F(), &autoRun, + DWRITE_MEASURING_MODE_NATURAL, &userRect); + + RefPtr<ID2D1PathGeometry> path; + factory()->CreatePathGeometry(getter_AddRefs(path)); + RefPtr<ID2D1GeometrySink> sink; + path->Open(getter_AddRefs(sink)); + AddRectToSink(sink, userRect); + sink->Close(); + + mDC->PushLayer(D2D1::LayerParameters1(D2D1::InfiniteRect(), path, D2D1_ANTIALIAS_MODE_ALIASED, + D2DMatrix(mTransform), 1.0f, nullptr, + D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND | + D2D1_LAYER_OPTIONS1_IGNORE_ALPHA), nullptr); + } + + PushClipsToDC(mDC, true, rect); + mDC->SetTransform(D2DMatrix(mTransform)); + } + } + + if (brush) { + mDC->DrawGlyphRun(D2D1::Point2F(), &autoRun, brush); + } + + if (needsRepushedLayers) { + PopClipsFromDC(mDC); + + if (!mTransform.IsRectilinear()) { + mDC->PopLayer(); + } + } + + FinalizeDrawing(aOptions.mCompositionOp, aPattern); +} + +void +DrawTargetD2D1::Mask(const Pattern &aSource, + const Pattern &aMask, + const DrawOptions &aOptions) +{ + PrepareForDrawing(aOptions.mCompositionOp, aSource); + + RefPtr<ID2D1Brush> source = CreateBrushForPattern(aSource, aOptions.mAlpha); + RefPtr<ID2D1Brush> mask = CreateBrushForPattern(aMask, 1.0f); + mDC->PushLayer(D2D1::LayerParameters(D2D1::InfiniteRect(), nullptr, + D2D1_ANTIALIAS_MODE_PER_PRIMITIVE, + D2D1::IdentityMatrix(), + 1.0f, mask), + nullptr); + + Rect rect(0, 0, (Float)mSize.width, (Float)mSize.height); + Matrix mat = mTransform; + mat.Invert(); + + mDC->FillRectangle(D2DRect(mat.TransformBounds(rect)), source); + + mDC->PopLayer(); + + FinalizeDrawing(aOptions.mCompositionOp, aSource); +} + +void +DrawTargetD2D1::PushClipGeometry(ID2D1Geometry* aGeometry, + const D2D1_MATRIX_3X2_F& aTransform, + bool aPixelAligned) +{ + mCurrentClippedGeometry = nullptr; + + PushedClip clip; + clip.mGeometry = aGeometry; + clip.mTransform = aTransform; + clip.mIsPixelAligned = aPixelAligned; + + aGeometry->GetBounds(aTransform, &clip.mBounds); + + CurrentLayer().mPushedClips.push_back(clip); + + // The transform of clips is relative to the world matrix, since we use the total + // transform for the clips, make the world matrix identity. + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + if (CurrentLayer().mClipsArePushed) { + PushD2DLayer(mDC, clip.mGeometry, clip.mTransform, clip.mIsPixelAligned); + } +} + +void +DrawTargetD2D1::PushClip(const Path *aPath) +{ + if (aPath->GetBackendType() != BackendType::DIRECT2D1_1) { + gfxDebug() << *this << ": Ignoring clipping call for incompatible path."; + return; + } + + RefPtr<PathD2D> pathD2D = static_cast<PathD2D*>(const_cast<Path*>(aPath)); + + PushClipGeometry(pathD2D->GetGeometry(), D2DMatrix(mTransform)); +} + +void +DrawTargetD2D1::PushClipRect(const Rect &aRect) +{ + if (!mTransform.IsRectilinear()) { + // Whoops, this isn't a rectangle in device space, Direct2D will not deal + // with this transform the way we want it to. + // See remarks: http://msdn.microsoft.com/en-us/library/dd316860%28VS.85%29.aspx + RefPtr<ID2D1Geometry> geom = ConvertRectToGeometry(D2DRect(aRect)); + return PushClipGeometry(geom, D2DMatrix(mTransform)); + } + + mCurrentClippedGeometry = nullptr; + + PushedClip clip; + Rect rect = mTransform.TransformBounds(aRect); + IntRect intRect; + clip.mIsPixelAligned = rect.ToIntRect(&intRect); + + // Do not store the transform, just store the device space rectangle directly. + clip.mBounds = D2DRect(rect); + + CurrentLayer().mPushedClips.push_back(clip); + + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + if (CurrentLayer().mClipsArePushed) { + mDC->PushAxisAlignedClip(clip.mBounds, clip.mIsPixelAligned ? D2D1_ANTIALIAS_MODE_ALIASED : D2D1_ANTIALIAS_MODE_PER_PRIMITIVE); + } +} + +void +DrawTargetD2D1::PushDeviceSpaceClipRects(const IntRect* aRects, uint32_t aCount) +{ + // Build a path for the union of the rects. + RefPtr<ID2D1PathGeometry> path; + factory()->CreatePathGeometry(getter_AddRefs(path)); + RefPtr<ID2D1GeometrySink> sink; + path->Open(getter_AddRefs(sink)); + sink->SetFillMode(D2D1_FILL_MODE_WINDING); + for (uint32_t i = 0; i < aCount; i++) { + const IntRect& rect = aRects[i]; + sink->BeginFigure(D2DPoint(rect.TopLeft()), D2D1_FIGURE_BEGIN_FILLED); + D2D1_POINT_2F lines[3] = { D2DPoint(rect.TopRight()), D2DPoint(rect.BottomRight()), D2DPoint(rect.BottomLeft()) }; + sink->AddLines(lines, 3); + sink->EndFigure(D2D1_FIGURE_END_CLOSED); + } + sink->Close(); + + // The path is in device-space, so there is no transform needed, + // and all rects are pixel aligned. + PushClipGeometry(path, D2D1::IdentityMatrix(), true); +} + +void +DrawTargetD2D1::PopClip() +{ + mCurrentClippedGeometry = nullptr; + if (CurrentLayer().mPushedClips.empty()) { + gfxDevCrash(LogReason::UnbalancedClipStack) << "DrawTargetD2D1::PopClip: No clip to pop."; + return; + } + + if (CurrentLayer().mClipsArePushed) { + if (CurrentLayer().mPushedClips.back().mGeometry) { + mDC->PopLayer(); + } else { + mDC->PopAxisAlignedClip(); + } + } + CurrentLayer().mPushedClips.pop_back(); +} + +void +DrawTargetD2D1::PushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask, + const Matrix& aMaskTransform, const IntRect& aBounds, + bool aCopyBackground) +{ + D2D1_LAYER_OPTIONS1 options = D2D1_LAYER_OPTIONS1_NONE; + + if (aOpaque) { + options |= D2D1_LAYER_OPTIONS1_IGNORE_ALPHA; + } + if (aCopyBackground) { + options |= D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND; + } + + RefPtr<ID2D1BitmapBrush> mask; + + Matrix maskTransform = aMaskTransform; + + RefPtr<ID2D1PathGeometry> clip; + if (aMask) { + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + RefPtr<ID2D1Image> image = GetImageForSurface(aMask, maskTransform, ExtendMode::CLAMP); + + // The mask is given in user space. Our layer will apply it in device space. + maskTransform = maskTransform * mTransform; + + if (image) { + RefPtr<ID2D1Bitmap> bitmap; + image->QueryInterface((ID2D1Bitmap**)getter_AddRefs(bitmap)); + + mDC->CreateBitmapBrush(bitmap, D2D1::BitmapBrushProperties(), D2D1::BrushProperties(1.0f, D2DMatrix(maskTransform)), getter_AddRefs(mask)); + MOZ_ASSERT(bitmap); // This should always be true since it was created for a surface. + + factory()->CreatePathGeometry(getter_AddRefs(clip)); + RefPtr<ID2D1GeometrySink> sink; + clip->Open(getter_AddRefs(sink)); + AddRectToSink(sink, D2D1::RectF(0, 0, aMask->GetSize().width, aMask->GetSize().height)); + sink->Close(); + } else { + gfxCriticalError() << "Failed to get image for mask surface!"; + } + } + + PushAllClips(); + + mDC->PushLayer(D2D1::LayerParameters1(D2D1::InfiniteRect(), clip, D2D1_ANTIALIAS_MODE_ALIASED, D2DMatrix(maskTransform), aOpacity, mask, options), nullptr); + PushedLayer pushedLayer; + pushedLayer.mClipsArePushed = false; + pushedLayer.mIsOpaque = aOpaque; + pushedLayer.mOldPermitSubpixelAA = mPermitSubpixelAA; + mPermitSubpixelAA = aOpaque; + + mDC->CreateCommandList(getter_AddRefs(pushedLayer.mCurrentList)); + mPushedLayers.push_back(pushedLayer); + + mDC->SetTarget(CurrentTarget()); + + mUsedCommandListsSincePurge++; +} + +void +DrawTargetD2D1::PopLayer() +{ + MOZ_ASSERT(CurrentLayer().mPushedClips.size() == 0); + + RefPtr<ID2D1CommandList> list = CurrentLayer().mCurrentList; + mPermitSubpixelAA = CurrentLayer().mOldPermitSubpixelAA; + + mPushedLayers.pop_back(); + mDC->SetTarget(CurrentTarget()); + + list->Close(); + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + DCCommandSink sink(mDC); + list->Stream(&sink); + + mDC->PopLayer(); +} + +already_AddRefed<SourceSurface> +DrawTargetD2D1::CreateSourceSurfaceFromData(unsigned char *aData, + const IntSize &aSize, + int32_t aStride, + SurfaceFormat aFormat) const +{ + RefPtr<ID2D1Bitmap1> bitmap; + + HRESULT hr = mDC->CreateBitmap(D2DIntSize(aSize), aData, aStride, + D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_NONE, D2DPixelFormat(aFormat)), + getter_AddRefs(bitmap)); + + if (FAILED(hr) || !bitmap) { + gfxCriticalError(CriticalLog::DefaultOptions(Factory::ReasonableSurfaceSize(aSize))) << "[D2D1.1] 1CreateBitmap failure " << aSize << " Code: " << hexa(hr) << " format " << (int)aFormat; + return nullptr; + } + + return MakeAndAddRef<SourceSurfaceD2D1>(bitmap.get(), mDC, aFormat, aSize); +} + +already_AddRefed<DrawTarget> +DrawTargetD2D1::CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const +{ + RefPtr<DrawTargetD2D1> dt = new DrawTargetD2D1(); + + if (!dt->Init(aSize, aFormat)) { + return nullptr; + } + + return dt.forget(); +} + +already_AddRefed<PathBuilder> +DrawTargetD2D1::CreatePathBuilder(FillRule aFillRule) const +{ + RefPtr<ID2D1PathGeometry> path; + HRESULT hr = factory()->CreatePathGeometry(getter_AddRefs(path)); + + if (FAILED(hr)) { + gfxWarning() << *this << ": Failed to create Direct2D Path Geometry. Code: " << hexa(hr); + return nullptr; + } + + RefPtr<ID2D1GeometrySink> sink; + hr = path->Open(getter_AddRefs(sink)); + if (FAILED(hr)) { + gfxWarning() << *this << ": Failed to access Direct2D Path Geometry. Code: " << hexa(hr); + return nullptr; + } + + if (aFillRule == FillRule::FILL_WINDING) { + sink->SetFillMode(D2D1_FILL_MODE_WINDING); + } + + return MakeAndAddRef<PathBuilderD2D>(sink, path, aFillRule, BackendType::DIRECT2D1_1); +} + +already_AddRefed<GradientStops> +DrawTargetD2D1::CreateGradientStops(GradientStop *rawStops, uint32_t aNumStops, ExtendMode aExtendMode) const +{ + if (aNumStops == 0) { + gfxWarning() << *this << ": Failed to create GradientStopCollection with no stops."; + return nullptr; + } + + D2D1_GRADIENT_STOP *stops = new D2D1_GRADIENT_STOP[aNumStops]; + + for (uint32_t i = 0; i < aNumStops; i++) { + stops[i].position = rawStops[i].offset; + stops[i].color = D2DColor(rawStops[i].color); + } + + RefPtr<ID2D1GradientStopCollection> stopCollection; + + HRESULT hr = + mDC->CreateGradientStopCollection(stops, aNumStops, + D2D1_GAMMA_2_2, D2DExtend(aExtendMode, Axis::BOTH), + getter_AddRefs(stopCollection)); + delete [] stops; + + if (FAILED(hr)) { + gfxWarning() << *this << ": Failed to create GradientStopCollection. Code: " << hexa(hr); + return nullptr; + } + + return MakeAndAddRef<GradientStopsD2D>(stopCollection, Factory::GetDirect3D11Device()); +} + +already_AddRefed<FilterNode> +DrawTargetD2D1::CreateFilter(FilterType aType) +{ + return FilterNodeD2D1::Create(mDC, aType); +} + +void +DrawTargetD2D1::GetGlyphRasterizationMetrics(ScaledFont *aScaledFont, const uint16_t* aGlyphIndices, + uint32_t aNumGlyphs, GlyphMetrics* aGlyphMetrics) +{ + MOZ_ASSERT(aScaledFont->GetType() == FontType::DWRITE); + + aScaledFont->GetGlyphDesignMetrics(aGlyphIndices, aNumGlyphs, aGlyphMetrics); + + // GetDesignGlyphMetrics returns 'ideal' glyph metrics, we need to pad to + // account for antialiasing. + for (uint32_t i = 0; i < aNumGlyphs; i++) { + if (aGlyphMetrics[i].mWidth > 0 && aGlyphMetrics[i].mHeight > 0) { + aGlyphMetrics[i].mWidth += 2.0f; + aGlyphMetrics[i].mXBearing -= 1.0f; + } + } +} + +bool +DrawTargetD2D1::Init(ID3D11Texture2D* aTexture, SurfaceFormat aFormat) +{ + HRESULT hr; + + ID2D1Device* device = Factory::GetD2D1Device(); + if (!device) { + gfxCriticalNote << "[D2D1.1] Failed to obtain a device for DrawTargetD2D1::Init(ID3D11Texture2D*, SurfaceFormat)."; + return false; + } + + hr = device->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS, getter_AddRefs(mDC)); + + if (FAILED(hr)) { + gfxCriticalError() <<"[D2D1.1] 1Failed to create a DeviceContext, code: " << hexa(hr) << " format " << (int)aFormat; + return false; + } + + RefPtr<IDXGISurface> dxgiSurface; + aTexture->QueryInterface(__uuidof(IDXGISurface), + (void**)((IDXGISurface**)getter_AddRefs(dxgiSurface))); + if (!dxgiSurface) { + gfxCriticalError() <<"[D2D1.1] Failed to obtain a DXGI surface."; + return false; + } + + D2D1_BITMAP_PROPERTIES1 props; + props.dpiX = 96; + props.dpiY = 96; + props.pixelFormat = D2DPixelFormat(aFormat); + props.colorContext = nullptr; + props.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET; + hr = mDC->CreateBitmapFromDxgiSurface(dxgiSurface, props, (ID2D1Bitmap1**)getter_AddRefs(mBitmap)); + + if (FAILED(hr)) { + gfxCriticalError() << "[D2D1.1] CreateBitmapFromDxgiSurface failure Code: " << hexa(hr) << " format " << (int)aFormat; + return false; + } + + mFormat = aFormat; + D3D11_TEXTURE2D_DESC desc; + aTexture->GetDesc(&desc); + mSize.width = desc.Width; + mSize.height = desc.Height; + + // This single solid color brush system is not very 'threadsafe', however, + // issueing multiple drawing commands simultaneously to a single drawtarget + // from multiple threads is unexpected since there's no way to guarantee + // ordering in that situation anyway. + hr = mDC->CreateSolidColorBrush(D2D1::ColorF(0, 0), getter_AddRefs(mSolidColorBrush)); + + if (FAILED(hr)) { + gfxCriticalError() << "[D2D1.1] Failure creating solid color brush (I1)."; + return false; + } + + mDC->SetTarget(CurrentTarget()); + + mDC->BeginDraw(); + + CurrentLayer().mIsOpaque = aFormat == SurfaceFormat::B8G8R8X8; + + return true; +} + +bool +DrawTargetD2D1::Init(const IntSize &aSize, SurfaceFormat aFormat) +{ + HRESULT hr; + + ID2D1Device* device = Factory::GetD2D1Device(); + if (!device) { + gfxCriticalNote << "[D2D1.1] Failed to obtain a device for DrawTargetD2D1::Init(IntSize, SurfaceFormat)."; + return false; + } + + hr = device->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS, getter_AddRefs(mDC)); + + if (FAILED(hr)) { + gfxCriticalError() <<"[D2D1.1] 2Failed to create a DeviceContext, code: " << hexa(hr) << " format " << (int)aFormat; + return false; + } + + if (mDC->GetMaximumBitmapSize() < UINT32(aSize.width) || + mDC->GetMaximumBitmapSize() < UINT32(aSize.height)) { + // This is 'ok', so don't assert + gfxCriticalNote << "[D2D1.1] Attempt to use unsupported surface size " << aSize; + return false; + } + + D2D1_BITMAP_PROPERTIES1 props; + props.dpiX = 96; + props.dpiY = 96; + props.pixelFormat = D2DPixelFormat(aFormat); + props.colorContext = nullptr; + props.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET; + hr = mDC->CreateBitmap(D2DIntSize(aSize), nullptr, 0, props, (ID2D1Bitmap1**)getter_AddRefs(mBitmap)); + + if (FAILED(hr)) { + gfxCriticalError() << "[D2D1.1] 3CreateBitmap failure " << aSize << " Code: " << hexa(hr) << " format " << (int)aFormat; + return false; + } + + mDC->SetTarget(CurrentTarget()); + + hr = mDC->CreateSolidColorBrush(D2D1::ColorF(0, 0), getter_AddRefs(mSolidColorBrush)); + + if (FAILED(hr)) { + gfxCriticalError() << "[D2D1.1] Failure creating solid color brush (I2)."; + return false; + } + + mDC->BeginDraw(); + + CurrentLayer().mIsOpaque = aFormat == SurfaceFormat::B8G8R8X8; + + mDC->Clear(); + + mFormat = aFormat; + mSize = aSize; + + return true; +} + +/** + * Private helpers. + */ +uint32_t +DrawTargetD2D1::GetByteSize() const +{ + return mSize.width * mSize.height * BytesPerPixel(mFormat); +} + +ID2D1Factory1* +DrawTargetD2D1::factory() +{ + if (mFactory) { + return mFactory; + } + + RefPtr<ID2D1Factory> factory; + D2D1CreateFactoryFunc createD2DFactory; + HMODULE d2dModule = LoadLibraryW(L"d2d1.dll"); + createD2DFactory = (D2D1CreateFactoryFunc) + GetProcAddress(d2dModule, "D2D1CreateFactory"); + + if (!createD2DFactory) { + gfxWarning() << "Failed to locate D2D1CreateFactory function."; + return nullptr; + } + + D2D1_FACTORY_OPTIONS options; +#ifdef _DEBUG + options.debugLevel = D2D1_DEBUG_LEVEL_WARNING; +#else + options.debugLevel = D2D1_DEBUG_LEVEL_NONE; +#endif + //options.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION; + + HRESULT hr = createD2DFactory(D2D1_FACTORY_TYPE_MULTI_THREADED, + __uuidof(ID2D1Factory), + &options, + getter_AddRefs(factory)); + + if (FAILED(hr) || !factory) { + gfxCriticalNote << "Failed to create a D2D1 content device: " << hexa(hr); + return nullptr; + } + + hr = factory->QueryInterface((ID2D1Factory1**)&mFactory); + if (FAILED(hr) || !mFactory) { + return nullptr; + } + + ExtendInputEffectD2D1::Register(mFactory); + RadialGradientEffectD2D1::Register(mFactory); + + return mFactory; +} + +IDWriteFactory* +DrawTargetD2D1::GetDWriteFactory() +{ + if (mDWriteFactory) { + return mDWriteFactory; + } + + decltype(DWriteCreateFactory)* createDWriteFactory; + HMODULE dwriteModule = LoadLibraryW(L"dwrite.dll"); + createDWriteFactory = (decltype(DWriteCreateFactory)*) + GetProcAddress(dwriteModule, "DWriteCreateFactory"); + + if (!createDWriteFactory) { + gfxWarning() << "Failed to locate DWriteCreateFactory function."; + return nullptr; + } + + HRESULT hr = createDWriteFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), + reinterpret_cast<IUnknown**>(&mDWriteFactory)); + + if (FAILED(hr)) { + gfxWarning() << "Failed to create DWrite Factory."; + } + + return mDWriteFactory; +} + +void +DrawTargetD2D1::CleanupD2D() +{ + if (mFactory) { + RadialGradientEffectD2D1::Unregister(mFactory); + ExtendInputEffectD2D1::Unregister(mFactory); + mFactory->Release(); + mFactory = nullptr; + } +} + +void +DrawTargetD2D1::MarkChanged() +{ + if (mSnapshot) { + if (mSnapshot->hasOneRef()) { + // Just destroy it, since no-one else knows about it. + mSnapshot = nullptr; + } else { + mSnapshot->DrawTargetWillChange(); + // The snapshot will no longer depend on this target. + MOZ_ASSERT(!mSnapshot); + } + } + if (mDependentTargets.size()) { + // Copy mDependentTargets since the Flush()es below will modify it. + TargetSet tmpTargets = mDependentTargets; + for (TargetSet::iterator iter = tmpTargets.begin(); + iter != tmpTargets.end(); iter++) { + (*iter)->Flush(); + } + // The Flush() should have broken all dependencies on this target. + MOZ_ASSERT(!mDependentTargets.size()); + } +} + +bool +DrawTargetD2D1::ShouldClipTemporarySurfaceDrawing(CompositionOp aOp, + const Pattern& aPattern, + bool aClipIsComplex) +{ + bool patternSupported = IsPatternSupportedByD2D(aPattern); + return patternSupported && !CurrentLayer().mIsOpaque && D2DSupportsCompositeMode(aOp) && + IsOperatorBoundByMask(aOp) && aClipIsComplex; +} + +void +DrawTargetD2D1::PrepareForDrawing(CompositionOp aOp, const Pattern &aPattern) +{ + MarkChanged(); + + bool patternSupported = IsPatternSupportedByD2D(aPattern); + + if (D2DSupportsPrimitiveBlendMode(aOp) && patternSupported) { + // It's important to do this before FlushTransformToDC! As this will cause + // the transform to become dirty. + PushAllClips(); + + FlushTransformToDC(); + + if (aOp != CompositionOp::OP_OVER) + mDC->SetPrimitiveBlend(D2DPrimitiveBlendMode(aOp)); + + return; + } + + HRESULT result = mDC->CreateCommandList(getter_AddRefs(mCommandList)); + mDC->SetTarget(mCommandList); + mUsedCommandListsSincePurge++; + + // This is where we should have a valid command list. If we don't, something is + // wrong, and it's likely an OOM. + if (!mCommandList) { + gfxDevCrash(LogReason::InvalidCommandList) << "Invalid D2D1.1 command list on creation " << mUsedCommandListsSincePurge << ", " << gfx::hexa(result); + } + + D2D1_RECT_F rect; + bool isAligned; + bool clipIsComplex = CurrentLayer().mPushedClips.size() && !GetDeviceSpaceClipRect(rect, isAligned); + + if (ShouldClipTemporarySurfaceDrawing(aOp, aPattern, clipIsComplex)) { + PushClipsToDC(mDC); + } + + FlushTransformToDC(); +} + +void +DrawTargetD2D1::FinalizeDrawing(CompositionOp aOp, const Pattern &aPattern) +{ + bool patternSupported = IsPatternSupportedByD2D(aPattern); + + if (D2DSupportsPrimitiveBlendMode(aOp) && patternSupported) { + if (aOp != CompositionOp::OP_OVER) + mDC->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_SOURCE_OVER); + return; + } + + D2D1_RECT_F rect; + bool isAligned; + bool clipIsComplex = CurrentLayer().mPushedClips.size() && !GetDeviceSpaceClipRect(rect, isAligned); + + if (ShouldClipTemporarySurfaceDrawing(aOp, aPattern, clipIsComplex)) { + PopClipsFromDC(mDC); + } + + mDC->SetTarget(CurrentTarget()); + if (!mCommandList) { + gfxDevCrash(LogReason::InvalidCommandList) << "Invalid D21.1 command list on finalize"; + return; + } + mCommandList->Close(); + + RefPtr<ID2D1CommandList> source = mCommandList; + mCommandList = nullptr; + + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + if (patternSupported) { + if (D2DSupportsCompositeMode(aOp)) { + RefPtr<ID2D1Image> tmpImage; + if (clipIsComplex) { + PopAllClips(); + if (!IsOperatorBoundByMask(aOp)) { + tmpImage = GetImageForLayerContent(); + } + } + mDC->DrawImage(source, D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, D2DCompositionMode(aOp)); + + if (tmpImage) { + RefPtr<ID2D1ImageBrush> brush; + RefPtr<ID2D1Geometry> inverseGeom = GetInverseClippedGeometry(); + mDC->CreateImageBrush(tmpImage, D2D1::ImageBrushProperties(D2D1::RectF(0, 0, mSize.width, mSize.height)), + getter_AddRefs(brush)); + + mDC->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_COPY); + mDC->FillGeometry(inverseGeom, brush); + mDC->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_SOURCE_OVER); + } + return; + } + + RefPtr<ID2D1Effect> blendEffect; + HRESULT hr = mDC->CreateEffect(CLSID_D2D1Blend, getter_AddRefs(blendEffect)); + + if (FAILED(hr) || !blendEffect) { + gfxWarning() << "Failed to create blend effect!"; + return; + } + + // We don't need to preserve the current content of this layer as the output + // of the blend effect should completely replace it. + RefPtr<ID2D1Image> tmpImage = GetImageForLayerContent(false); + if (!tmpImage) { + return; + } + + blendEffect->SetInput(0, tmpImage); + blendEffect->SetInput(1, source); + blendEffect->SetValue(D2D1_BLEND_PROP_MODE, D2DBlendMode(aOp)); + + mDC->DrawImage(blendEffect, D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY); + + // This may seem a little counter intuitive. If this is false, we go through the regular + // codepaths and set it to true. When this was true, GetImageForLayerContent will return + // a bitmap for the current command list and we will no longer have a complex blend + // with a list for tmpImage. Therefore we can set it to false again. + mDidComplexBlendWithListInList = !mDidComplexBlendWithListInList; + + return; + } + + const RadialGradientPattern *pat = static_cast<const RadialGradientPattern*>(&aPattern); + if (pat->mCenter1 == pat->mCenter2 && pat->mRadius1 == pat->mRadius2) { + // Draw nothing! + return; + } + + if (!pat->mStops) { + // Draw nothing because of no color stops + return; + } + + RefPtr<ID2D1Effect> radialGradientEffect; + + HRESULT hr = mDC->CreateEffect(CLSID_RadialGradientEffect, getter_AddRefs(radialGradientEffect)); + if (FAILED(hr) || !radialGradientEffect) { + gfxWarning() << "Failed to create radial gradient effect. Code: " << hexa(hr); + return; + } + + radialGradientEffect->SetValue(RADIAL_PROP_STOP_COLLECTION, + static_cast<const GradientStopsD2D*>(pat->mStops.get())->mStopCollection); + radialGradientEffect->SetValue(RADIAL_PROP_CENTER_1, D2D1::Vector2F(pat->mCenter1.x, pat->mCenter1.y)); + radialGradientEffect->SetValue(RADIAL_PROP_CENTER_2, D2D1::Vector2F(pat->mCenter2.x, pat->mCenter2.y)); + radialGradientEffect->SetValue(RADIAL_PROP_RADIUS_1, pat->mRadius1); + radialGradientEffect->SetValue(RADIAL_PROP_RADIUS_2, pat->mRadius2); + radialGradientEffect->SetValue(RADIAL_PROP_RADIUS_2, pat->mRadius2); + radialGradientEffect->SetValue(RADIAL_PROP_TRANSFORM, D2DMatrix(pat->mMatrix * mTransform)); + radialGradientEffect->SetInput(0, source); + + mDC->DrawImage(radialGradientEffect, D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, D2DCompositionMode(aOp)); +} + +void +DrawTargetD2D1::AddDependencyOnSource(SourceSurfaceD2D1* aSource) +{ + if (aSource->mDrawTarget && !mDependingOnTargets.count(aSource->mDrawTarget)) { + aSource->mDrawTarget->mDependentTargets.insert(this); + mDependingOnTargets.insert(aSource->mDrawTarget); + } +} + +static D2D1_RECT_F +IntersectRect(const D2D1_RECT_F& aRect1, const D2D1_RECT_F& aRect2) +{ + D2D1_RECT_F result; + result.left = max(aRect1.left, aRect2.left); + result.top = max(aRect1.top, aRect2.top); + result.right = min(aRect1.right, aRect2.right); + result.bottom = min(aRect1.bottom, aRect2.bottom); + + result.right = max(result.right, result.left); + result.bottom = max(result.bottom, result.top); + + return result; +} + +bool +DrawTargetD2D1::GetDeviceSpaceClipRect(D2D1_RECT_F& aClipRect, bool& aIsPixelAligned) +{ + if (!CurrentLayer().mPushedClips.size()) { + return false; + } + + aIsPixelAligned = true; + aClipRect = D2D1::RectF(0, 0, mSize.width, mSize.height); + for (auto iter = CurrentLayer().mPushedClips.begin();iter != CurrentLayer().mPushedClips.end(); iter++) { + if (iter->mGeometry) { + return false; + } + aClipRect = IntersectRect(aClipRect, iter->mBounds); + if (!iter->mIsPixelAligned) { + aIsPixelAligned = false; + } + } + return true; +} + +already_AddRefed<ID2D1Image> +DrawTargetD2D1::GetImageForLayerContent(bool aShouldPreserveContent) +{ + PopAllClips(); + + if (!CurrentLayer().mCurrentList) { + RefPtr<ID2D1Bitmap> tmpBitmap; + HRESULT hr = mDC->CreateBitmap(D2DIntSize(mSize), D2D1::BitmapProperties(D2DPixelFormat(mFormat)), getter_AddRefs(tmpBitmap)); + if (FAILED(hr)) { + gfxCriticalError(CriticalLog::DefaultOptions(Factory::ReasonableSurfaceSize(mSize))) << "[D2D1.1] 6CreateBitmap failure " << mSize << " Code: " << hexa(hr) << " format " << (int)mFormat; + // If it's a recreate target error, return and handle it elsewhere. + if (hr == D2DERR_RECREATE_TARGET) { + mDC->Flush(); + return nullptr; + } + // For now, crash in other scenarios; this should happen because tmpBitmap is + // null and CopyFromBitmap call below dereferences it. + } + mDC->Flush(); + + tmpBitmap->CopyFromBitmap(nullptr, mBitmap, nullptr); + return tmpBitmap.forget(); + } else { + RefPtr<ID2D1CommandList> list = CurrentLayer().mCurrentList; + mDC->CreateCommandList(getter_AddRefs(CurrentLayer().mCurrentList)); + mDC->SetTarget(CurrentTarget()); + list->Close(); + + RefPtr<ID2D1Bitmap1> tmpBitmap; + if (mDidComplexBlendWithListInList) { + D2D1_BITMAP_PROPERTIES1 props = + D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_TARGET, + D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, + D2D1_ALPHA_MODE_PREMULTIPLIED)); + mDC->CreateBitmap(mBitmap->GetPixelSize(), nullptr, 0, &props, getter_AddRefs(tmpBitmap)); + mDC->SetTransform(D2D1::IdentityMatrix()); + mDC->SetTarget(tmpBitmap); + mDC->DrawImage(list, D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY); + mDC->SetTarget(CurrentTarget()); + } + + DCCommandSink sink(mDC); + + if (aShouldPreserveContent) { + list->Stream(&sink); + PushAllClips(); + } + + if (mDidComplexBlendWithListInList) { + return tmpBitmap.forget(); + } + + return list.forget(); + } +} + +already_AddRefed<ID2D1Geometry> +DrawTargetD2D1::GetClippedGeometry(IntRect *aClipBounds) +{ + if (mCurrentClippedGeometry) { + *aClipBounds = mCurrentClipBounds; + RefPtr<ID2D1Geometry> clippedGeometry(mCurrentClippedGeometry); + return clippedGeometry.forget(); + } + + MOZ_ASSERT(CurrentLayer().mPushedClips.size()); + + mCurrentClipBounds = IntRect(IntPoint(0, 0), mSize); + + // if pathGeom is null then pathRect represents the path. + RefPtr<ID2D1Geometry> pathGeom; + D2D1_RECT_F pathRect; + bool pathRectIsAxisAligned = false; + auto iter = CurrentLayer().mPushedClips.begin(); + + if (iter->mGeometry) { + pathGeom = GetTransformedGeometry(iter->mGeometry, iter->mTransform); + } else { + pathRect = iter->mBounds; + pathRectIsAxisAligned = iter->mIsPixelAligned; + } + + iter++; + for (;iter != CurrentLayer().mPushedClips.end(); iter++) { + // Do nothing but add it to the current clip bounds. + if (!iter->mGeometry && iter->mIsPixelAligned) { + mCurrentClipBounds.IntersectRect(mCurrentClipBounds, + IntRect(int32_t(iter->mBounds.left), int32_t(iter->mBounds.top), + int32_t(iter->mBounds.right - iter->mBounds.left), + int32_t(iter->mBounds.bottom - iter->mBounds.top))); + continue; + } + + if (!pathGeom) { + if (pathRectIsAxisAligned) { + mCurrentClipBounds.IntersectRect(mCurrentClipBounds, + IntRect(int32_t(pathRect.left), int32_t(pathRect.top), + int32_t(pathRect.right - pathRect.left), + int32_t(pathRect.bottom - pathRect.top))); + } + if (iter->mGeometry) { + // See if pathRect needs to go into the path geometry. + if (!pathRectIsAxisAligned) { + pathGeom = ConvertRectToGeometry(pathRect); + } else { + pathGeom = GetTransformedGeometry(iter->mGeometry, iter->mTransform); + } + } else { + pathRect = IntersectRect(pathRect, iter->mBounds); + pathRectIsAxisAligned = false; + continue; + } + } + + RefPtr<ID2D1PathGeometry> newGeom; + factory()->CreatePathGeometry(getter_AddRefs(newGeom)); + + RefPtr<ID2D1GeometrySink> currentSink; + newGeom->Open(getter_AddRefs(currentSink)); + + if (iter->mGeometry) { + pathGeom->CombineWithGeometry(iter->mGeometry, D2D1_COMBINE_MODE_INTERSECT, + iter->mTransform, currentSink); + } else { + RefPtr<ID2D1Geometry> rectGeom = ConvertRectToGeometry(iter->mBounds); + pathGeom->CombineWithGeometry(rectGeom, D2D1_COMBINE_MODE_INTERSECT, + D2D1::IdentityMatrix(), currentSink); + } + + currentSink->Close(); + + pathGeom = newGeom.forget(); + } + + // For now we need mCurrentClippedGeometry to always be non-nullptr. This + // method might seem a little strange but it is just fine, if pathGeom is + // nullptr pathRect will always still contain 1 clip unaccounted for + // regardless of mCurrentClipBounds. + if (!pathGeom) { + pathGeom = ConvertRectToGeometry(pathRect); + } + mCurrentClippedGeometry = pathGeom.forget(); + *aClipBounds = mCurrentClipBounds; + RefPtr<ID2D1Geometry> clippedGeometry(mCurrentClippedGeometry); + return clippedGeometry.forget(); +} + +already_AddRefed<ID2D1Geometry> +DrawTargetD2D1::GetInverseClippedGeometry() +{ + IntRect bounds; + RefPtr<ID2D1Geometry> geom = GetClippedGeometry(&bounds); + RefPtr<ID2D1RectangleGeometry> rectGeom; + RefPtr<ID2D1PathGeometry> inverseGeom; + + factory()->CreateRectangleGeometry(D2D1::RectF(0, 0, mSize.width, mSize.height), getter_AddRefs(rectGeom)); + factory()->CreatePathGeometry(getter_AddRefs(inverseGeom)); + RefPtr<ID2D1GeometrySink> sink; + inverseGeom->Open(getter_AddRefs(sink)); + rectGeom->CombineWithGeometry(geom, D2D1_COMBINE_MODE_EXCLUDE, D2D1::IdentityMatrix(), sink); + sink->Close(); + + return inverseGeom.forget(); +} + +void +DrawTargetD2D1::PopAllClips() +{ + if (CurrentLayer().mClipsArePushed) { + PopClipsFromDC(mDC); + + CurrentLayer().mClipsArePushed = false; + } +} + +void +DrawTargetD2D1::PushAllClips() +{ + if (!CurrentLayer().mClipsArePushed) { + PushClipsToDC(mDC); + + CurrentLayer().mClipsArePushed = true; + } +} + +void +DrawTargetD2D1::PushClipsToDC(ID2D1DeviceContext *aDC, bool aForceIgnoreAlpha, const D2D1_RECT_F& aMaxRect) +{ + mDC->SetTransform(D2D1::IdentityMatrix()); + mTransformDirty = true; + + for (auto iter = CurrentLayer().mPushedClips.begin(); iter != CurrentLayer().mPushedClips.end(); iter++) { + if (iter->mGeometry) { + PushD2DLayer(aDC, iter->mGeometry, iter->mTransform, iter->mIsPixelAligned, aForceIgnoreAlpha, aMaxRect); + } else { + mDC->PushAxisAlignedClip(iter->mBounds, iter->mIsPixelAligned ? D2D1_ANTIALIAS_MODE_ALIASED : D2D1_ANTIALIAS_MODE_PER_PRIMITIVE); + } + } +} + +void +DrawTargetD2D1::PopClipsFromDC(ID2D1DeviceContext *aDC) +{ + for (int i = CurrentLayer().mPushedClips.size() - 1; i >= 0; i--) { + if (CurrentLayer().mPushedClips[i].mGeometry) { + aDC->PopLayer(); + } else { + aDC->PopAxisAlignedClip(); + } + } +} + +already_AddRefed<ID2D1Brush> +DrawTargetD2D1::CreateTransparentBlackBrush() +{ + return GetSolidColorBrush(D2D1::ColorF(0, 0)); +} + +already_AddRefed<ID2D1SolidColorBrush> +DrawTargetD2D1::GetSolidColorBrush(const D2D_COLOR_F& aColor) +{ + RefPtr<ID2D1SolidColorBrush> brush = mSolidColorBrush; + brush->SetColor(aColor); + return brush.forget(); +} + +already_AddRefed<ID2D1Brush> +DrawTargetD2D1::CreateBrushForPattern(const Pattern &aPattern, Float aAlpha) +{ + if (!IsPatternSupportedByD2D(aPattern)) { + return GetSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f)); + } + + if (aPattern.GetType() == PatternType::COLOR) { + Color color = static_cast<const ColorPattern*>(&aPattern)->mColor; + return GetSolidColorBrush(D2D1::ColorF(color.r, color.g, color.b, color.a * aAlpha)); + } + if (aPattern.GetType() == PatternType::LINEAR_GRADIENT) { + RefPtr<ID2D1LinearGradientBrush> gradBrush; + const LinearGradientPattern *pat = + static_cast<const LinearGradientPattern*>(&aPattern); + + GradientStopsD2D *stops = static_cast<GradientStopsD2D*>(pat->mStops.get()); + + if (!stops) { + gfxDebug() << "No stops specified for gradient pattern."; + return CreateTransparentBlackBrush(); + } + + if (pat->mBegin == pat->mEnd) { + uint32_t stopCount = stops->mStopCollection->GetGradientStopCount(); + vector<D2D1_GRADIENT_STOP> d2dStops(stopCount); + stops->mStopCollection->GetGradientStops(&d2dStops.front(), stopCount); + d2dStops.back().color.a *= aAlpha; + return GetSolidColorBrush(d2dStops.back().color); + } + + mDC->CreateLinearGradientBrush(D2D1::LinearGradientBrushProperties(D2DPoint(pat->mBegin), + D2DPoint(pat->mEnd)), + D2D1::BrushProperties(aAlpha, D2DMatrix(pat->mMatrix)), + stops->mStopCollection, + getter_AddRefs(gradBrush)); + + if (!gradBrush) { + gfxWarning() << "Couldn't create gradient brush."; + return CreateTransparentBlackBrush(); + } + + return gradBrush.forget(); + } + if (aPattern.GetType() == PatternType::RADIAL_GRADIENT) { + RefPtr<ID2D1RadialGradientBrush> gradBrush; + const RadialGradientPattern *pat = + static_cast<const RadialGradientPattern*>(&aPattern); + + GradientStopsD2D *stops = static_cast<GradientStopsD2D*>(pat->mStops.get()); + + if (!stops) { + gfxDebug() << "No stops specified for gradient pattern."; + return CreateTransparentBlackBrush(); + } + + // This will not be a complex radial gradient brush. + mDC->CreateRadialGradientBrush( + D2D1::RadialGradientBrushProperties(D2DPoint(pat->mCenter2), + D2DPoint(pat->mCenter1 - pat->mCenter2), + pat->mRadius2, pat->mRadius2), + D2D1::BrushProperties(aAlpha, D2DMatrix(pat->mMatrix)), + stops->mStopCollection, + getter_AddRefs(gradBrush)); + + if (!gradBrush) { + gfxWarning() << "Couldn't create gradient brush."; + return CreateTransparentBlackBrush(); + } + + return gradBrush.forget(); + } + if (aPattern.GetType() == PatternType::SURFACE) { + const SurfacePattern *pat = + static_cast<const SurfacePattern*>(&aPattern); + + if (!pat->mSurface) { + gfxDebug() << "No source surface specified for surface pattern"; + return CreateTransparentBlackBrush(); + } + + D2D1_RECT_F samplingBounds; + Matrix mat = pat->mMatrix; + + MOZ_ASSERT(pat->mSurface->IsValid()); + + RefPtr<ID2D1Image> image = GetImageForSurface(pat->mSurface, mat, pat->mExtendMode, !pat->mSamplingRect.IsEmpty() ? &pat->mSamplingRect : nullptr); + + if (pat->mSurface->GetFormat() == SurfaceFormat::A8) { + // See bug 1251431, at least FillOpacityMask does not appear to allow a source bitmapbrush + // with source format A8. This creates a BGRA surface with the same alpha values that + // the A8 surface has. + RefPtr<ID2D1Bitmap> bitmap; + image->QueryInterface((ID2D1Bitmap**)getter_AddRefs(bitmap)); + if (bitmap) { + RefPtr<ID2D1Image> oldTarget; + RefPtr<ID2D1Bitmap1> tmpBitmap; + mDC->CreateBitmap(D2D1::SizeU(pat->mSurface->GetSize().width, pat->mSurface->GetSize().height), nullptr, 0, + D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_TARGET, D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED)), + getter_AddRefs(tmpBitmap)); + mDC->GetTarget(getter_AddRefs(oldTarget)); + mDC->SetTarget(tmpBitmap); + + RefPtr<ID2D1SolidColorBrush> brush; + mDC->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::White), getter_AddRefs(brush)); + mDC->FillOpacityMask(bitmap, brush); + mDC->SetTarget(oldTarget); + image = tmpBitmap; + } + } + + if (!image) { + return CreateTransparentBlackBrush(); + } + + if (pat->mSamplingRect.IsEmpty()) { + RefPtr<ID2D1Bitmap> bitmap; + image->QueryInterface((ID2D1Bitmap**)getter_AddRefs(bitmap)); + if (bitmap) { + /** + * Create the brush with the proper repeat modes. + */ + RefPtr<ID2D1BitmapBrush> bitmapBrush; + D2D1_EXTEND_MODE xRepeat = D2DExtend(pat->mExtendMode, Axis::X_AXIS); + D2D1_EXTEND_MODE yRepeat = D2DExtend(pat->mExtendMode, Axis::Y_AXIS); + + mDC->CreateBitmapBrush(bitmap, + D2D1::BitmapBrushProperties(xRepeat, yRepeat, + D2DFilter(pat->mSamplingFilter)), + D2D1::BrushProperties(aAlpha, D2DMatrix(mat)), + getter_AddRefs(bitmapBrush)); + if (!bitmapBrush) { + gfxWarning() << "Couldn't create bitmap brush!"; + return CreateTransparentBlackBrush(); + } + return bitmapBrush.forget(); + } + } + + RefPtr<ID2D1ImageBrush> imageBrush; + if (pat->mSamplingRect.IsEmpty()) { + samplingBounds = D2D1::RectF(0, 0, + Float(pat->mSurface->GetSize().width), + Float(pat->mSurface->GetSize().height)); + } else if (pat->mSurface->GetType() == SurfaceType::D2D1_1_IMAGE) { + samplingBounds = D2DRect(pat->mSamplingRect); + mat.PreTranslate(pat->mSamplingRect.x, pat->mSamplingRect.y); + } else { + // We will do a partial upload of the sampling restricted area from GetImageForSurface. + samplingBounds = D2D1::RectF(0, 0, pat->mSamplingRect.width, pat->mSamplingRect.height); + } + + D2D1_EXTEND_MODE xRepeat = D2DExtend(pat->mExtendMode, Axis::X_AXIS); + D2D1_EXTEND_MODE yRepeat = D2DExtend(pat->mExtendMode, Axis::Y_AXIS); + + mDC->CreateImageBrush(image, + D2D1::ImageBrushProperties(samplingBounds, + xRepeat, + yRepeat, + D2DInterpolationMode(pat->mSamplingFilter)), + D2D1::BrushProperties(aAlpha, D2DMatrix(mat)), + getter_AddRefs(imageBrush)); + + if (!imageBrush) { + gfxWarning() << "Couldn't create image brush!"; + return CreateTransparentBlackBrush(); + } + + return imageBrush.forget(); + } + + gfxWarning() << "Invalid pattern type detected."; + return CreateTransparentBlackBrush(); +} + +already_AddRefed<ID2D1Image> +DrawTargetD2D1::GetImageForSurface(SourceSurface *aSurface, Matrix &aSourceTransform, + ExtendMode aExtendMode, const IntRect* aSourceRect) +{ + RefPtr<ID2D1Image> image; + + switch (aSurface->GetType()) { + case SurfaceType::D2D1_1_IMAGE: + { + SourceSurfaceD2D1 *surf = static_cast<SourceSurfaceD2D1*>(aSurface); + image = surf->GetImage(); + AddDependencyOnSource(surf); + } + break; + default: + { + RefPtr<DataSourceSurface> dataSurf = aSurface->GetDataSurface(); + if (!dataSurf) { + gfxWarning() << "Invalid surface type."; + return nullptr; + } + return CreatePartialBitmapForSurface(dataSurf, mTransform, mSize, aExtendMode, + aSourceTransform, mDC, aSourceRect); + } + break; + } + + return image.forget(); +} + +already_AddRefed<SourceSurface> +DrawTargetD2D1::OptimizeSourceSurface(SourceSurface* aSurface) const +{ + if (aSurface->GetType() == SurfaceType::D2D1_1_IMAGE) { + RefPtr<SourceSurface> surface(aSurface); + return surface.forget(); + } + + RefPtr<DataSourceSurface> data = aSurface->GetDataSurface(); + + RefPtr<ID2D1Bitmap1> bitmap; + { + DataSourceSurface::ScopedMap map(data, DataSourceSurface::READ); + if (MOZ2D_WARN_IF(!map.IsMapped())) { + return nullptr; + } + + HRESULT hr = mDC->CreateBitmap(D2DIntSize(data->GetSize()), map.GetData(), map.GetStride(), + D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_NONE, D2DPixelFormat(data->GetFormat())), + getter_AddRefs(bitmap)); + + if (FAILED(hr)) { + gfxCriticalError(CriticalLog::DefaultOptions(Factory::ReasonableSurfaceSize(data->GetSize()))) << "[D2D1.1] 4CreateBitmap failure " << data->GetSize() << " Code: " << hexa(hr) << " format " << (int)data->GetFormat(); + } + } + + if (!bitmap) { + return data.forget(); + } + + return MakeAndAddRef<SourceSurfaceD2D1>(bitmap.get(), mDC, data->GetFormat(), data->GetSize()); +} + +void +DrawTargetD2D1::PushD2DLayer(ID2D1DeviceContext *aDC, ID2D1Geometry *aGeometry, const D2D1_MATRIX_3X2_F &aTransform, + bool aPixelAligned, bool aForceIgnoreAlpha, const D2D1_RECT_F& aMaxRect) +{ + D2D1_LAYER_OPTIONS1 options = D2D1_LAYER_OPTIONS1_NONE; + + if (CurrentLayer().mIsOpaque || aForceIgnoreAlpha) { + options = D2D1_LAYER_OPTIONS1_IGNORE_ALPHA | D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND; + } + + D2D1_ANTIALIAS_MODE antialias = + aPixelAligned ? D2D1_ANTIALIAS_MODE_ALIASED : D2D1_ANTIALIAS_MODE_PER_PRIMITIVE; + + mDC->PushLayer(D2D1::LayerParameters1(aMaxRect, aGeometry, antialias, aTransform, + 1.0, nullptr, options), nullptr); +} + +} +} |