diff options
Diffstat (limited to 'gfx/thebes/gfxUtils.cpp')
| -rw-r--r-- | gfx/thebes/gfxUtils.cpp | 1822 |
1 files changed, 1822 insertions, 0 deletions
diff --git a/gfx/thebes/gfxUtils.cpp b/gfx/thebes/gfxUtils.cpp new file mode 100644 index 0000000000..ad3ab14f8b --- /dev/null +++ b/gfx/thebes/gfxUtils.cpp @@ -0,0 +1,1822 @@ +/* -*- 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 "gfxUtils.h" + +#include "cairo.h" +#include "gfxContext.h" +#include "gfxEnv.h" +#include "gfxImageSurface.h" +#include "gfxPlatform.h" +#include "gfxDrawable.h" +#include "gfxQuad.h" +#include "imgIEncoder.h" +#include "mozilla/Base64.h" +#include "mozilla/StyleColorInlines.h" +#include "mozilla/Components.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/ImageEncoder.h" +#include "mozilla/dom/WorkerPrivate.h" +#include "mozilla/dom/WorkerRunnable.h" +#include "mozilla/ipc/CrossProcessSemaphore.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/DataSurfaceHelpers.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/PathHelpers.h" +#include "mozilla/gfx/Swizzle.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/image/nsBMPEncoder.h" +#include "mozilla/image/nsICOEncoder.h" +#include "mozilla/image/nsJPEGEncoder.h" +#include "mozilla/image/nsPNGEncoder.h" +#include "mozilla/layers/SynchronousTask.h" +#include "mozilla/Maybe.h" +#include "mozilla/Preferences.h" +#include "mozilla/ProfilerLabels.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ServoStyleConsts.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/StaticPrefs_layout.h" +#include "mozilla/UniquePtrExtensions.h" +#include "mozilla/Unused.h" +#include "mozilla/webrender/webrender_ffi.h" +#include "nsAppRunner.h" +#include "nsComponentManagerUtils.h" +#include "nsIClipboardHelper.h" +#include "nsIFile.h" +#include "nsIGfxInfo.h" +#include "nsMimeTypes.h" +#include "nsPresContext.h" +#include "nsRegion.h" +#include "nsServiceManagerUtils.h" +#include "nsRFPService.h" +#include "ImageContainer.h" +#include "ImageRegion.h" +#include "gfx2DGlue.h" + +#ifdef XP_WIN +# include "gfxWindowsPlatform.h" +#endif + +using namespace mozilla; +using namespace mozilla::image; +using namespace mozilla::layers; +using namespace mozilla::gfx; + +#undef compress +#include "mozilla/Compression.h" + +using namespace mozilla::Compression; +extern "C" { + +/** + * Dump a raw image to the default log. This function is exported + * from libxul, so it can be called from any library in addition to + * (of course) from a debugger. + * + * Note: this helper currently assumes that all 2-bytepp images are + * r5g6b5, and that all 4-bytepp images are r8g8b8a8. + */ +NS_EXPORT +void mozilla_dump_image(void* bytes, int width, int height, int bytepp, + int strideBytes) { + if (0 == strideBytes) { + strideBytes = width * bytepp; + } + SurfaceFormat format; + // TODO more flexible; parse string? + switch (bytepp) { + case 2: + format = SurfaceFormat::R5G6B5_UINT16; + break; + case 4: + default: + format = SurfaceFormat::R8G8B8A8; + break; + } + + RefPtr<DataSourceSurface> surf = Factory::CreateWrappingDataSourceSurface( + (uint8_t*)bytes, strideBytes, IntSize(width, height), format); + gfxUtils::DumpAsDataURI(surf); +} +} + +static bool MapSrcDest(DataSourceSurface* srcSurf, DataSourceSurface* destSurf, + DataSourceSurface::MappedSurface* out_srcMap, + DataSourceSurface::MappedSurface* out_destMap) { + MOZ_ASSERT(srcSurf && destSurf); + MOZ_ASSERT(out_srcMap && out_destMap); + + if (srcSurf->GetSize() != destSurf->GetSize()) { + MOZ_ASSERT(false, "Width and height must match."); + return false; + } + + if (srcSurf == destSurf) { + DataSourceSurface::MappedSurface map; + if (!srcSurf->Map(DataSourceSurface::MapType::READ_WRITE, &map)) { + NS_WARNING("Couldn't Map srcSurf/destSurf."); + return false; + } + + *out_srcMap = map; + *out_destMap = map; + return true; + } + + // Map src for reading. + DataSourceSurface::MappedSurface srcMap; + if (!srcSurf->Map(DataSourceSurface::MapType::READ, &srcMap)) { + NS_WARNING("Couldn't Map srcSurf."); + return false; + } + + // Map dest for writing. + DataSourceSurface::MappedSurface destMap; + if (!destSurf->Map(DataSourceSurface::MapType::WRITE, &destMap)) { + NS_WARNING("Couldn't Map aDest."); + srcSurf->Unmap(); + return false; + } + + *out_srcMap = srcMap; + *out_destMap = destMap; + return true; +} + +static void UnmapSrcDest(DataSourceSurface* srcSurf, + DataSourceSurface* destSurf) { + if (srcSurf == destSurf) { + srcSurf->Unmap(); + } else { + srcSurf->Unmap(); + destSurf->Unmap(); + } +} + +bool gfxUtils::PremultiplyDataSurface(DataSourceSurface* srcSurf, + DataSourceSurface* destSurf) { + MOZ_ASSERT(srcSurf && destSurf); + + DataSourceSurface::MappedSurface srcMap; + DataSourceSurface::MappedSurface destMap; + if (!MapSrcDest(srcSurf, destSurf, &srcMap, &destMap)) return false; + + PremultiplyData(srcMap.mData, srcMap.mStride, srcSurf->GetFormat(), + destMap.mData, destMap.mStride, destSurf->GetFormat(), + srcSurf->GetSize()); + + UnmapSrcDest(srcSurf, destSurf); + return true; +} + +bool gfxUtils::UnpremultiplyDataSurface(DataSourceSurface* srcSurf, + DataSourceSurface* destSurf) { + MOZ_ASSERT(srcSurf && destSurf); + + DataSourceSurface::MappedSurface srcMap; + DataSourceSurface::MappedSurface destMap; + if (!MapSrcDest(srcSurf, destSurf, &srcMap, &destMap)) return false; + + UnpremultiplyData(srcMap.mData, srcMap.mStride, srcSurf->GetFormat(), + destMap.mData, destMap.mStride, destSurf->GetFormat(), + srcSurf->GetSize()); + + UnmapSrcDest(srcSurf, destSurf); + return true; +} + +static bool MapSrcAndCreateMappedDest( + DataSourceSurface* srcSurf, RefPtr<DataSourceSurface>* out_destSurf, + DataSourceSurface::MappedSurface* out_srcMap, + DataSourceSurface::MappedSurface* out_destMap) { + MOZ_ASSERT(srcSurf); + MOZ_ASSERT(out_destSurf && out_srcMap && out_destMap); + + // Ok, map source for reading. + DataSourceSurface::MappedSurface srcMap; + if (!srcSurf->Map(DataSourceSurface::MapType::READ, &srcMap)) { + MOZ_ASSERT(false, "Couldn't Map srcSurf."); + return false; + } + + // Make our dest surface based on the src. + RefPtr<DataSourceSurface> destSurf = + Factory::CreateDataSourceSurfaceWithStride( + srcSurf->GetSize(), srcSurf->GetFormat(), srcMap.mStride); + if (NS_WARN_IF(!destSurf)) { + return false; + } + + DataSourceSurface::MappedSurface destMap; + if (!destSurf->Map(DataSourceSurface::MapType::WRITE, &destMap)) { + MOZ_ASSERT(false, "Couldn't Map destSurf."); + srcSurf->Unmap(); + return false; + } + + *out_destSurf = destSurf; + *out_srcMap = srcMap; + *out_destMap = destMap; + return true; +} + +already_AddRefed<DataSourceSurface> gfxUtils::CreatePremultipliedDataSurface( + DataSourceSurface* srcSurf) { + RefPtr<DataSourceSurface> destSurf; + DataSourceSurface::MappedSurface srcMap; + DataSourceSurface::MappedSurface destMap; + if (!MapSrcAndCreateMappedDest(srcSurf, &destSurf, &srcMap, &destMap)) { + MOZ_ASSERT(false, "MapSrcAndCreateMappedDest failed."); + RefPtr<DataSourceSurface> surface(srcSurf); + return surface.forget(); + } + + PremultiplyData(srcMap.mData, srcMap.mStride, srcSurf->GetFormat(), + destMap.mData, destMap.mStride, destSurf->GetFormat(), + srcSurf->GetSize()); + + UnmapSrcDest(srcSurf, destSurf); + return destSurf.forget(); +} + +already_AddRefed<DataSourceSurface> gfxUtils::CreateUnpremultipliedDataSurface( + DataSourceSurface* srcSurf) { + RefPtr<DataSourceSurface> destSurf; + DataSourceSurface::MappedSurface srcMap; + DataSourceSurface::MappedSurface destMap; + if (!MapSrcAndCreateMappedDest(srcSurf, &destSurf, &srcMap, &destMap)) { + MOZ_ASSERT(false, "MapSrcAndCreateMappedDest failed."); + RefPtr<DataSourceSurface> surface(srcSurf); + return surface.forget(); + } + + UnpremultiplyData(srcMap.mData, srcMap.mStride, srcSurf->GetFormat(), + destMap.mData, destMap.mStride, destSurf->GetFormat(), + srcSurf->GetSize()); + + UnmapSrcDest(srcSurf, destSurf); + return destSurf.forget(); +} + +void gfxUtils::ConvertBGRAtoRGBA(uint8_t* aData, uint32_t aLength) { + MOZ_ASSERT((aLength % 4) == 0, "Loop below will pass srcEnd!"); + SwizzleData(aData, aLength, SurfaceFormat::B8G8R8A8, aData, aLength, + SurfaceFormat::R8G8B8A8, IntSize(aLength / 4, 1)); +} + +#if !defined(MOZ_GFX_OPTIMIZE_MOBILE) +/** + * This returns the fastest operator to use for solid surfaces which have no + * alpha channel or their alpha channel is uniformly opaque. + * This differs per render mode. + */ +static CompositionOp OptimalFillOp() { +# ifdef XP_WIN + if (gfxWindowsPlatform::GetPlatform()->IsDirect2DBackend()) { + // D2D -really- hates operator source. + return CompositionOp::OP_OVER; + } +# endif + return CompositionOp::OP_SOURCE; +} + +// EXTEND_PAD won't help us here; we have to create a temporary surface to hold +// the subimage of pixels we're allowed to sample. +static already_AddRefed<gfxDrawable> CreateSamplingRestrictedDrawable( + gfxDrawable* aDrawable, gfxContext* aContext, const ImageRegion& aRegion, + const SurfaceFormat aFormat, bool aUseOptimalFillOp) { + AUTO_PROFILER_LABEL("CreateSamplingRestrictedDrawable", GRAPHICS); + + DrawTarget* destDrawTarget = aContext->GetDrawTarget(); + // We've been not using CreateSamplingRestrictedDrawable in a bunch of places + // for a while. Let's disable it everywhere and confirm that it's ok to get + // rid of. + if (destDrawTarget->GetBackendType() == BackendType::DIRECT2D1_1 || (true)) { + return nullptr; + } + + gfxRect clipExtents = aContext->GetClipExtents(); + + // Inflate by one pixel because bilinear filtering will sample at most + // one pixel beyond the computed image pixel coordinate. + clipExtents.Inflate(1.0); + + gfxRect needed = aRegion.IntersectAndRestrict(clipExtents); + needed.RoundOut(); + + // if 'needed' is empty, nothing will be drawn since aFill + // must be entirely outside the clip region, so it doesn't + // matter what we do here, but we should avoid trying to + // create a zero-size surface. + if (needed.IsEmpty()) return nullptr; + + IntSize size(int32_t(needed.Width()), int32_t(needed.Height())); + + RefPtr<DrawTarget> target = + gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(size, + aFormat); + if (!target || !target->IsValid()) { + return nullptr; + } + + gfxContext tmpCtx(target); + + if (aUseOptimalFillOp) { + tmpCtx.SetOp(OptimalFillOp()); + } + aDrawable->Draw(&tmpCtx, needed - needed.TopLeft(), ExtendMode::REPEAT, + SamplingFilter::LINEAR, 1.0, + gfxMatrix::Translation(needed.TopLeft())); + RefPtr<SourceSurface> surface = target->Snapshot(); + + RefPtr<gfxDrawable> drawable = new gfxSurfaceDrawable( + surface, size, gfxMatrix::Translation(-needed.TopLeft())); + return drawable.forget(); +} +#endif // !MOZ_GFX_OPTIMIZE_MOBILE + +/* These heuristics are based on + * Source/WebCore/platform/graphics/skia/ImageSkia.cpp:computeResamplingMode() + */ +#ifdef MOZ_GFX_OPTIMIZE_MOBILE +static SamplingFilter ReduceResamplingFilter(SamplingFilter aSamplingFilter, + int aImgWidth, int aImgHeight, + float aSourceWidth, + float aSourceHeight) { + // Images smaller than this in either direction are considered "small" and + // are not resampled ever (see below). + const int kSmallImageSizeThreshold = 8; + + // The amount an image can be stretched in a single direction before we + // say that it is being stretched so much that it must be a line or + // background that doesn't need resampling. + const float kLargeStretch = 3.0f; + + if (aImgWidth <= kSmallImageSizeThreshold || + aImgHeight <= kSmallImageSizeThreshold) { + // Never resample small images. These are often used for borders and + // rules (think 1x1 images used to make lines). + return SamplingFilter::POINT; + } + + if (aImgHeight * kLargeStretch <= aSourceHeight || + aImgWidth * kLargeStretch <= aSourceWidth) { + // Large image tiling detected. + + // Don't resample if it is being tiled a lot in only one direction. + // This is trying to catch cases where somebody has created a border + // (which might be large) and then is stretching it to fill some part + // of the page. + if (fabs(aSourceWidth - aImgWidth) / aImgWidth < 0.5 || + fabs(aSourceHeight - aImgHeight) / aImgHeight < 0.5) + return SamplingFilter::POINT; + + // The image is growing a lot and in more than one direction. Resampling + // is slow and doesn't give us very much when growing a lot. + return aSamplingFilter; + } + + /* Some notes on other heuristics: + The Skia backend also uses nearest for backgrounds that are stretched by + a large amount. I'm not sure this is common enough for us to worry about + now. It also uses nearest for backgrounds/avoids high quality for images + that are very slightly scaled. I'm also not sure that very slightly + scaled backgrounds are common enough us to worry about. + + We don't currently have much support for doing high quality interpolation. + The only place this currently happens is on Quartz and we don't have as + much control over it as would be needed. Webkit avoids using high quality + resampling during load. It also avoids high quality if the transformation + is not just a scale and translation + + WebKit bug #40045 added code to avoid resampling different parts + of an image with different methods by using a resampling hint size. + It currently looks unused in WebKit but it's something to watch out for. + */ + + return aSamplingFilter; +} +#else +static SamplingFilter ReduceResamplingFilter(SamplingFilter aSamplingFilter, + int aImgWidth, int aImgHeight, + int aSourceWidth, + int aSourceHeight) { + // Just pass the filter through unchanged + return aSamplingFilter; +} +#endif + +#ifdef MOZ_WIDGET_COCOA +// Only prescale a temporary surface if we're going to repeat it often. +// Scaling is expensive on OS X and without prescaling, we'd scale +// every tile of the repeated rect. However, using a temp surface also +// potentially uses more memory if the scaled image is large. So only prescale +// on a temp surface if we know we're going to repeat the image in either the X +// or Y axis multiple times. +static bool ShouldUseTempSurface(Rect aImageRect, Rect aNeededRect) { + int repeatX = aNeededRect.width / aImageRect.width; + int repeatY = aNeededRect.height / aImageRect.height; + return (repeatX >= 5) || (repeatY >= 5); +} + +static bool PrescaleAndTileDrawable(gfxDrawable* aDrawable, + gfxContext* aContext, + const ImageRegion& aRegion, Rect aImageRect, + const SamplingFilter aSamplingFilter, + const SurfaceFormat aFormat, + gfxFloat aOpacity, ExtendMode aExtendMode) { + MatrixScales scaleFactor = + aContext->CurrentMatrix().ScaleFactors().ConvertTo<float>(); + Matrix scaleMatrix = Matrix::Scaling(scaleFactor.xScale, scaleFactor.yScale); + const float fuzzFactor = 0.01; + + // If we aren't scaling or translating, don't go down this path + if ((FuzzyEqual(scaleFactor.xScale, 1.0f, fuzzFactor) && + FuzzyEqual(scaleFactor.yScale, 1.0f, fuzzFactor)) || + aContext->CurrentMatrix().HasNonAxisAlignedTransform()) { + return false; + } + + gfxRect clipExtents = aContext->GetClipExtents(); + + // Inflate by one pixel because bilinear filtering will sample at most + // one pixel beyond the computed image pixel coordinate. + clipExtents.Inflate(1.0); + + gfxRect needed = aRegion.IntersectAndRestrict(clipExtents); + Rect scaledNeededRect = scaleMatrix.TransformBounds(ToRect(needed)); + scaledNeededRect.RoundOut(); + if (scaledNeededRect.IsEmpty()) { + return false; + } + + Rect scaledImageRect = scaleMatrix.TransformBounds(aImageRect); + if (!ShouldUseTempSurface(scaledImageRect, scaledNeededRect)) { + return false; + } + + IntSize scaledImageSize((int32_t)scaledImageRect.width, + (int32_t)scaledImageRect.height); + if (scaledImageSize.width != scaledImageRect.width || + scaledImageSize.height != scaledImageRect.height) { + // If the scaled image isn't pixel aligned, we'll get artifacts + // so we have to take the slow path. + return false; + } + + RefPtr<DrawTarget> scaledDT = + gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget( + scaledImageSize, aFormat); + if (!scaledDT || !scaledDT->IsValid()) { + return false; + } + + gfxContext tmpCtx(scaledDT); + + scaledDT->SetTransform(scaleMatrix); + gfxRect gfxImageRect(aImageRect.x, aImageRect.y, aImageRect.width, + aImageRect.height); + + // Since this is just the scaled image, we don't want to repeat anything yet. + aDrawable->Draw(&tmpCtx, gfxImageRect, ExtendMode::CLAMP, aSamplingFilter, + 1.0, gfxMatrix()); + + RefPtr<SourceSurface> scaledImage = scaledDT->Snapshot(); + + { + gfxContextMatrixAutoSaveRestore autoSR(aContext); + Matrix withoutScale = aContext->CurrentMatrix(); + DrawTarget* destDrawTarget = aContext->GetDrawTarget(); + + // The translation still is in scaled units + withoutScale.PreScale(1.0f / scaleFactor.xScale, 1.0f / scaleFactor.yScale); + aContext->SetMatrix(withoutScale); + + DrawOptions drawOptions(aOpacity, aContext->CurrentOp(), + aContext->CurrentAntialiasMode()); + + SurfacePattern scaledImagePattern(scaledImage, aExtendMode, Matrix(), + aSamplingFilter); + destDrawTarget->FillRect(scaledNeededRect, scaledImagePattern, drawOptions); + } + return true; +} +#endif // MOZ_WIDGET_COCOA + +/* static */ +void gfxUtils::DrawPixelSnapped(gfxContext* aContext, gfxDrawable* aDrawable, + const gfxSize& aImageSize, + const ImageRegion& aRegion, + const SurfaceFormat aFormat, + SamplingFilter aSamplingFilter, + uint32_t aImageFlags, gfxFloat aOpacity, + bool aUseOptimalFillOp) { + AUTO_PROFILER_LABEL("gfxUtils::DrawPixelSnapped", GRAPHICS); + + gfxRect imageRect(gfxPoint(0, 0), aImageSize); + gfxRect region(aRegion.Rect()); + ExtendMode extendMode = aRegion.GetExtendMode(); + + RefPtr<gfxDrawable> drawable = aDrawable; + + aSamplingFilter = ReduceResamplingFilter(aSamplingFilter, imageRect.Width(), + imageRect.Height(), region.Width(), + region.Height()); + + // OK now, the hard part left is to account for the subimage sampling + // restriction. If all the transforms involved are just integer + // translations, then we assume no resampling will occur so there's + // nothing to do. + // XXX if only we had source-clipping in cairo! + + if (aContext->CurrentMatrix().HasNonIntegerTranslation()) { + if ((extendMode != ExtendMode::CLAMP) || + !aRegion.RestrictionContains(imageRect)) { + if (drawable->DrawWithSamplingRect( + aContext->GetDrawTarget(), aContext->CurrentOp(), + aContext->CurrentAntialiasMode(), aRegion.Rect(), + aRegion.Restriction(), extendMode, aSamplingFilter, aOpacity)) { + return; + } + +#ifdef MOZ_WIDGET_COCOA + if (PrescaleAndTileDrawable(aDrawable, aContext, aRegion, + ToRect(imageRect), aSamplingFilter, aFormat, + aOpacity, extendMode)) { + return; + } +#endif + + // On Mobile, we don't ever want to do this; it has the potential for + // allocating very large temporary surfaces, especially since we'll + // do full-page snapshots often (see bug 749426). +#if !defined(MOZ_GFX_OPTIMIZE_MOBILE) + RefPtr<gfxDrawable> restrictedDrawable = CreateSamplingRestrictedDrawable( + aDrawable, aContext, aRegion, aFormat, aUseOptimalFillOp); + if (restrictedDrawable) { + drawable.swap(restrictedDrawable); + + // We no longer need to tile: Either we never needed to, or we already + // filled a surface with the tiled pattern; this surface can now be + // drawn without tiling. + extendMode = ExtendMode::CLAMP; + } +#endif + } + } + + drawable->Draw(aContext, aRegion.Rect(), extendMode, aSamplingFilter, + aOpacity, gfxMatrix()); +} + +/* static */ +int gfxUtils::ImageFormatToDepth(gfxImageFormat aFormat) { + switch (aFormat) { + case SurfaceFormat::A8R8G8B8_UINT32: + return 32; + case SurfaceFormat::X8R8G8B8_UINT32: + return 24; + case SurfaceFormat::R5G6B5_UINT16: + return 16; + default: + break; + } + return 0; +} + +/*static*/ +void gfxUtils::ClipToRegion(gfxContext* aContext, const nsIntRegion& aRegion) { + aContext->NewPath(); + for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) { + const IntRect& r = iter.Get(); + aContext->Rectangle(gfxRect(r.X(), r.Y(), r.Width(), r.Height())); + } + aContext->Clip(); +} + +/*static*/ +void gfxUtils::ClipToRegion(DrawTarget* aTarget, const nsIntRegion& aRegion) { + uint32_t numRects = aRegion.GetNumRects(); + // If there is only one rect, then the region bounds are equivalent to the + // contents. So just use push a single clip rect with the bounds. + if (numRects == 1) { + aTarget->PushClipRect(Rect(aRegion.GetBounds())); + return; + } + + // Check if the target's transform will preserve axis-alignment and + // pixel-alignment for each rect. For now, just handle the common case + // of integer translations. + Matrix transform = aTarget->GetTransform(); + if (transform.IsIntegerTranslation()) { + IntPoint translation = RoundedToInt(transform.GetTranslation()); + AutoTArray<IntRect, 16> rects; + rects.SetLength(numRects); + uint32_t i = 0; + // Build the list of transformed rects by adding in the translation. + for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) { + IntRect rect = iter.Get(); + rect.MoveBy(translation); + rects[i++] = rect; + } + aTarget->PushDeviceSpaceClipRects(rects.Elements(), rects.Length()); + } else { + // The transform does not produce axis-aligned rects or a rect was not + // pixel-aligned. So just build a path with all the rects and clip to it + // instead. + RefPtr<PathBuilder> pathBuilder = aTarget->CreatePathBuilder(); + for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) { + AppendRectToPath(pathBuilder, Rect(iter.Get())); + } + RefPtr<Path> path = pathBuilder->Finish(); + aTarget->PushClip(path); + } +} + +/*static*/ +float gfxUtils::ClampToScaleFactor(float aVal, bool aRoundDown) { + // Arbitary scale factor limitation. We can increase this + // for better scaling performance at the cost of worse + // quality. + static const float kScaleResolution = 2; + + // Negative scaling is just a flip and irrelevant to + // our resolution calculation. + if (aVal < 0.0) { + aVal = -aVal; + } + + bool inverse = false; + if (aVal < 1.0) { + inverse = true; + aVal = 1 / aVal; + } + + float power = logf(aVal) / logf(kScaleResolution); + + // If power is within 1e-5 of an integer, round to nearest to + // prevent floating point errors, otherwise round up to the + // next integer value. + if (fabs(power - NS_round(power)) < 1e-5) { + power = NS_round(power); + // Use floor when we are either inverted or rounding down, but + // not both. + } else if (inverse != aRoundDown) { + power = floor(power); + // Otherwise, ceil when we are not inverted and not rounding + // down, or we are inverted and rounding down. + } else { + power = ceil(power); + } + + float scale = powf(kScaleResolution, power); + + if (inverse) { + scale = 1 / scale; + } + + return scale; +} + +gfxMatrix gfxUtils::TransformRectToRect(const gfxRect& aFrom, + const gfxPoint& aToTopLeft, + const gfxPoint& aToTopRight, + const gfxPoint& aToBottomRight) { + gfxMatrix m; + if (aToTopRight.y == aToTopLeft.y && aToTopRight.x == aToBottomRight.x) { + // Not a rotation, so xy and yx are zero + m._21 = m._12 = 0.0; + m._11 = (aToBottomRight.x - aToTopLeft.x) / aFrom.Width(); + m._22 = (aToBottomRight.y - aToTopLeft.y) / aFrom.Height(); + m._31 = aToTopLeft.x - m._11 * aFrom.X(); + m._32 = aToTopLeft.y - m._22 * aFrom.Y(); + } else { + NS_ASSERTION( + aToTopRight.y == aToBottomRight.y && aToTopRight.x == aToTopLeft.x, + "Destination rectangle not axis-aligned"); + m._11 = m._22 = 0.0; + m._21 = (aToBottomRight.x - aToTopLeft.x) / aFrom.Height(); + m._12 = (aToBottomRight.y - aToTopLeft.y) / aFrom.Width(); + m._31 = aToTopLeft.x - m._21 * aFrom.Y(); + m._32 = aToTopLeft.y - m._12 * aFrom.X(); + } + return m; +} + +Matrix gfxUtils::TransformRectToRect(const gfxRect& aFrom, + const IntPoint& aToTopLeft, + const IntPoint& aToTopRight, + const IntPoint& aToBottomRight) { + Matrix m; + if (aToTopRight.y == aToTopLeft.y && aToTopRight.x == aToBottomRight.x) { + // Not a rotation, so xy and yx are zero + m._12 = m._21 = 0.0; + m._11 = (aToBottomRight.x - aToTopLeft.x) / aFrom.Width(); + m._22 = (aToBottomRight.y - aToTopLeft.y) / aFrom.Height(); + m._31 = aToTopLeft.x - m._11 * aFrom.X(); + m._32 = aToTopLeft.y - m._22 * aFrom.Y(); + } else { + NS_ASSERTION( + aToTopRight.y == aToBottomRight.y && aToTopRight.x == aToTopLeft.x, + "Destination rectangle not axis-aligned"); + m._11 = m._22 = 0.0; + m._21 = (aToBottomRight.x - aToTopLeft.x) / aFrom.Height(); + m._12 = (aToBottomRight.y - aToTopLeft.y) / aFrom.Width(); + m._31 = aToTopLeft.x - m._21 * aFrom.Y(); + m._32 = aToTopLeft.y - m._12 * aFrom.X(); + } + return m; +} + +/* This function is sort of shitty. We truncate doubles + * to ints then convert those ints back to doubles to make sure that + * they equal the doubles that we got in. */ +bool gfxUtils::GfxRectToIntRect(const gfxRect& aIn, IntRect* aOut) { + *aOut = IntRect(int32_t(aIn.X()), int32_t(aIn.Y()), int32_t(aIn.Width()), + int32_t(aIn.Height())); + return gfxRect(aOut->X(), aOut->Y(), aOut->Width(), aOut->Height()) + .IsEqualEdges(aIn); +} + +/* Clamp r to CAIRO_COORD_MIN .. CAIRO_COORD_MAX + * these are to be device coordinates. + * + * Cairo is currently using 24.8 fixed point, + * so -2^24 .. 2^24-1 is our valid + */ +/*static*/ +void gfxUtils::ConditionRect(gfxRect& aRect) { +#define CAIRO_COORD_MAX (16777215.0) +#define CAIRO_COORD_MIN (-16777216.0) + // if either x or y is way out of bounds; + // note that we don't handle negative w/h here + if (aRect.X() > CAIRO_COORD_MAX) { + aRect.SetRectX(CAIRO_COORD_MAX, 0.0); + } + + if (aRect.Y() > CAIRO_COORD_MAX) { + aRect.SetRectY(CAIRO_COORD_MAX, 0.0); + } + + if (aRect.X() < CAIRO_COORD_MIN) { + aRect.SetWidth(aRect.XMost() - CAIRO_COORD_MIN); + if (aRect.Width() < 0.0) { + aRect.SetWidth(0.0); + } + aRect.MoveToX(CAIRO_COORD_MIN); + } + + if (aRect.Y() < CAIRO_COORD_MIN) { + aRect.SetHeight(aRect.YMost() - CAIRO_COORD_MIN); + if (aRect.Height() < 0.0) { + aRect.SetHeight(0.0); + } + aRect.MoveToY(CAIRO_COORD_MIN); + } + + if (aRect.XMost() > CAIRO_COORD_MAX) { + aRect.SetRightEdge(CAIRO_COORD_MAX); + } + + if (aRect.YMost() > CAIRO_COORD_MAX) { + aRect.SetBottomEdge(CAIRO_COORD_MAX); + } +#undef CAIRO_COORD_MAX +#undef CAIRO_COORD_MIN +} + +/*static*/ +gfxQuad gfxUtils::TransformToQuad(const gfxRect& aRect, + const mozilla::gfx::Matrix4x4& aMatrix) { + gfxPoint points[4]; + + points[0] = aMatrix.TransformPoint(aRect.TopLeft()); + points[1] = aMatrix.TransformPoint(aRect.TopRight()); + points[2] = aMatrix.TransformPoint(aRect.BottomRight()); + points[3] = aMatrix.TransformPoint(aRect.BottomLeft()); + + // Could this ever result in lines that intersect? I don't think so. + return gfxQuad(points[0], points[1], points[2], points[3]); +} + +Matrix4x4 gfxUtils::SnapTransformTranslation(const Matrix4x4& aTransform, + Matrix* aResidualTransform) { + if (aResidualTransform) { + *aResidualTransform = Matrix(); + } + + Matrix matrix2D; + if (aTransform.CanDraw2D(&matrix2D) && !matrix2D.HasNonTranslation() && + matrix2D.HasNonIntegerTranslation()) { + return Matrix4x4::From2D( + SnapTransformTranslation(matrix2D, aResidualTransform)); + } + + return SnapTransformTranslation3D(aTransform, aResidualTransform); +} + +Matrix gfxUtils::SnapTransformTranslation(const Matrix& aTransform, + Matrix* aResidualTransform) { + if (aResidualTransform) { + *aResidualTransform = Matrix(); + } + + if (!aTransform.HasNonTranslation() && + aTransform.HasNonIntegerTranslation()) { + auto snappedTranslation = IntPoint::Round(aTransform.GetTranslation()); + Matrix snappedMatrix = + Matrix::Translation(snappedTranslation.x, snappedTranslation.y); + if (aResidualTransform) { + // set aResidualTransform so that aResidual * snappedMatrix == matrix2D. + // (I.e., appying snappedMatrix after aResidualTransform gives the + // ideal transform.) + *aResidualTransform = + Matrix::Translation(aTransform._31 - snappedTranslation.x, + aTransform._32 - snappedTranslation.y); + } + return snappedMatrix; + } + + return aTransform; +} + +Matrix4x4 gfxUtils::SnapTransformTranslation3D(const Matrix4x4& aTransform, + Matrix* aResidualTransform) { + if (aTransform.IsSingular() || aTransform.HasPerspectiveComponent() || + aTransform.HasNonTranslation() || + !aTransform.HasNonIntegerTranslation()) { + // For a singular transform, there is no reversed matrix, so we + // don't snap it. + // For a perspective transform, the content is transformed in + // non-linear, so we don't snap it too. + return aTransform; + } + + // Snap for 3D Transforms + + Point3D transformedOrigin = aTransform.TransformPoint(Point3D()); + + // Compute the transformed snap by rounding the values of + // transformed origin. + auto transformedSnapXY = + IntPoint::Round(transformedOrigin.x, transformedOrigin.y); + Matrix4x4 inverse = aTransform; + inverse.Invert(); + // see Matrix4x4::ProjectPoint() + Float transformedSnapZ = + inverse._33 == 0 ? 0 + : (-(transformedSnapXY.x * inverse._13 + + transformedSnapXY.y * inverse._23 + inverse._43) / + inverse._33); + Point3D transformedSnap = + Point3D(transformedSnapXY.x, transformedSnapXY.y, transformedSnapZ); + if (transformedOrigin == transformedSnap) { + return aTransform; + } + + // Compute the snap from the transformed snap. + Point3D snap = inverse.TransformPoint(transformedSnap); + if (snap.z > 0.001 || snap.z < -0.001) { + // Allow some level of accumulated computation error. + MOZ_ASSERT(inverse._33 == 0.0); + return aTransform; + } + + // The difference between the origin and snap is the residual transform. + if (aResidualTransform) { + // The residual transform is to translate the snap to the origin + // of the content buffer. + *aResidualTransform = Matrix::Translation(-snap.x, -snap.y); + } + + // Translate transformed origin to transformed snap since the + // residual transform would trnslate the snap to the origin. + Point3D transformedShift = transformedSnap - transformedOrigin; + Matrix4x4 result = aTransform; + result.PostTranslate(transformedShift.x, transformedShift.y, + transformedShift.z); + + // For non-2d transform, residual translation could be more than + // 0.5 pixels for every axis. + + return result; +} + +Matrix4x4 gfxUtils::SnapTransform(const Matrix4x4& aTransform, + const gfxRect& aSnapRect, + Matrix* aResidualTransform) { + if (aResidualTransform) { + *aResidualTransform = Matrix(); + } + + Matrix matrix2D; + if (aTransform.Is2D(&matrix2D)) { + return Matrix4x4::From2D( + SnapTransform(matrix2D, aSnapRect, aResidualTransform)); + } + return aTransform; +} + +Matrix gfxUtils::SnapTransform(const Matrix& aTransform, + const gfxRect& aSnapRect, + Matrix* aResidualTransform) { + if (aResidualTransform) { + *aResidualTransform = Matrix(); + } + + if (gfxSize(1.0, 1.0) <= aSnapRect.Size() && + aTransform.PreservesAxisAlignedRectangles()) { + auto transformedTopLeft = IntPoint::Round( + aTransform.TransformPoint(ToPoint(aSnapRect.TopLeft()))); + auto transformedTopRight = IntPoint::Round( + aTransform.TransformPoint(ToPoint(aSnapRect.TopRight()))); + auto transformedBottomRight = IntPoint::Round( + aTransform.TransformPoint(ToPoint(aSnapRect.BottomRight()))); + + Matrix snappedMatrix = gfxUtils::TransformRectToRect( + aSnapRect, transformedTopLeft, transformedTopRight, + transformedBottomRight); + + if (aResidualTransform && !snappedMatrix.IsSingular()) { + // set aResidualTransform so that aResidual * snappedMatrix == matrix2D. + // (i.e., appying snappedMatrix after aResidualTransform gives the + // ideal transform. + Matrix snappedMatrixInverse = snappedMatrix; + snappedMatrixInverse.Invert(); + *aResidualTransform = aTransform * snappedMatrixInverse; + } + return snappedMatrix; + } + return aTransform; +} + +/* static */ +void gfxUtils::ClearThebesSurface(gfxASurface* aSurface) { + if (aSurface->CairoStatus()) { + return; + } + cairo_surface_t* surf = aSurface->CairoSurface(); + if (cairo_surface_status(surf)) { + return; + } + cairo_t* ctx = cairo_create(surf); + cairo_set_source_rgba(ctx, 0.0, 0.0, 0.0, 0.0); + cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE); + IntRect bounds(nsIntPoint(0, 0), aSurface->GetSize()); + cairo_rectangle(ctx, bounds.X(), bounds.Y(), bounds.Width(), bounds.Height()); + cairo_fill(ctx); + cairo_destroy(ctx); +} + +/* static */ +already_AddRefed<DataSourceSurface> +gfxUtils::CopySurfaceToDataSourceSurfaceWithFormat(SourceSurface* aSurface, + SurfaceFormat aFormat) { + MOZ_ASSERT(aFormat != aSurface->GetFormat(), + "Unnecessary - and very expersive - surface format conversion"); + + Rect bounds(0, 0, aSurface->GetSize().width, aSurface->GetSize().height); + + if (!aSurface->IsDataSourceSurface()) { + // If the surface is NOT of type DATA then its data is not mapped into main + // memory. Format conversion is probably faster on the GPU, and by doing it + // there we can avoid any expensive uploads/readbacks except for (possibly) + // a single readback due to the unavoidable GetDataSurface() call. Using + // CreateOffscreenContentDrawTarget ensures the conversion happens on the + // GPU. + RefPtr<DrawTarget> dt = + gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget( + aSurface->GetSize(), aFormat); + if (!dt) { + gfxWarning() << "gfxUtils::CopySurfaceToDataSourceSurfaceWithFormat " + "failed in CreateOffscreenContentDrawTarget"; + return nullptr; + } + + // Using DrawSurface() here rather than CopySurface() because CopySurface + // is optimized for memcpy and therefore isn't good for format conversion. + // Using OP_OVER since in our case it's equivalent to OP_SOURCE and + // generally more optimized. + dt->DrawSurface(aSurface, bounds, bounds, DrawSurfaceOptions(), + DrawOptions(1.0f, CompositionOp::OP_OVER)); + RefPtr<SourceSurface> surface = dt->Snapshot(); + return surface->GetDataSurface(); + } + + // If the surface IS of type DATA then it may or may not be in main memory + // depending on whether or not it has been mapped yet. We have no way of + // knowing, so we can't be sure if it's best to create a data wrapping + // DrawTarget for the conversion or an offscreen content DrawTarget. We could + // guess it's not mapped and create an offscreen content DrawTarget, but if + // it is then we'll end up uploading the surface data, and most likely the + // caller is going to be accessing the resulting surface data, resulting in a + // readback (both very expensive operations). Alternatively we could guess + // the data is mapped and create a data wrapping DrawTarget and, if the + // surface is not in main memory, then we will incure a readback. The latter + // of these two "wrong choices" is the least costly (a readback, vs an + // upload and a readback), and more than likely the DATA surface that we've + // been passed actually IS in main memory anyway. For these reasons it's most + // likely best to create a data wrapping DrawTarget here to do the format + // conversion. + RefPtr<DataSourceSurface> dataSurface = + Factory::CreateDataSourceSurface(aSurface->GetSize(), aFormat); + DataSourceSurface::MappedSurface map; + if (!dataSurface || + !dataSurface->Map(DataSourceSurface::MapType::READ_WRITE, &map)) { + return nullptr; + } + RefPtr<DrawTarget> dt = Factory::CreateDrawTargetForData( + BackendType::CAIRO, map.mData, dataSurface->GetSize(), map.mStride, + aFormat); + if (!dt) { + dataSurface->Unmap(); + return nullptr; + } + // Using DrawSurface() here rather than CopySurface() because CopySurface + // is optimized for memcpy and therefore isn't good for format conversion. + // Using OP_OVER since in our case it's equivalent to OP_SOURCE and + // generally more optimized. + dt->DrawSurface(aSurface, bounds, bounds, DrawSurfaceOptions(), + DrawOptions(1.0f, CompositionOp::OP_OVER)); + dataSurface->Unmap(); + return dataSurface.forget(); +} + +const uint32_t gfxUtils::sNumFrameColors = 8; + +/* static */ +const gfx::DeviceColor& gfxUtils::GetColorForFrameNumber( + uint64_t aFrameNumber) { + static bool initialized = false; + static gfx::DeviceColor colors[sNumFrameColors]; + + if (!initialized) { + // This isn't truly device color, but it is just for debug. + uint32_t i = 0; + colors[i++] = gfx::DeviceColor::FromABGR(0xffff0000); + colors[i++] = gfx::DeviceColor::FromABGR(0xffcc00ff); + colors[i++] = gfx::DeviceColor::FromABGR(0xff0066cc); + colors[i++] = gfx::DeviceColor::FromABGR(0xff00ff00); + colors[i++] = gfx::DeviceColor::FromABGR(0xff33ffff); + colors[i++] = gfx::DeviceColor::FromABGR(0xffff0099); + colors[i++] = gfx::DeviceColor::FromABGR(0xff0000ff); + colors[i++] = gfx::DeviceColor::FromABGR(0xff999999); + MOZ_ASSERT(i == sNumFrameColors); + initialized = true; + } + + return colors[aFrameNumber % sNumFrameColors]; +} + +// static +nsresult gfxUtils::EncodeSourceSurfaceAsStream(SourceSurface* aSurface, + const ImageType aImageType, + const nsAString& aOutputOptions, + nsIInputStream** aOutStream) { + const IntSize size = aSurface->GetSize(); + if (size.IsEmpty()) { + return NS_ERROR_FAILURE; + } + + RefPtr<DataSourceSurface> dataSurface; + if (aSurface->GetFormat() != SurfaceFormat::B8G8R8A8) { + // FIXME bug 995807 (B8G8R8X8), bug 831898 (R5G6B5) + dataSurface = gfxUtils::CopySurfaceToDataSourceSurfaceWithFormat( + aSurface, SurfaceFormat::B8G8R8A8); + } else { + dataSurface = aSurface->GetDataSurface(); + } + if (!dataSurface) { + return NS_ERROR_FAILURE; + } + + DataSourceSurface::MappedSurface map; + if (!dataSurface->Map(DataSourceSurface::MapType::READ, &map)) { + return NS_ERROR_FAILURE; + } + + RefPtr<imgIEncoder> encoder = nullptr; + + switch (aImageType) { + case ImageType::BMP: + encoder = MakeRefPtr<nsBMPEncoder>(); + break; + + case ImageType::ICO: + encoder = MakeRefPtr<nsICOEncoder>(); + break; + + case ImageType::JPEG: + encoder = MakeRefPtr<nsJPEGEncoder>(); + break; + + case ImageType::PNG: + encoder = MakeRefPtr<nsPNGEncoder>(); + break; + + default: + break; + } + + MOZ_RELEASE_ASSERT(encoder != nullptr); + + nsresult rv = encoder->InitFromData( + map.mData, BufferSizeFromStrideAndHeight(map.mStride, size.height), + size.width, size.height, map.mStride, imgIEncoder::INPUT_FORMAT_HOSTARGB, + aOutputOptions); + dataSurface->Unmap(); + if (NS_FAILED(rv)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIInputStream> imgStream(encoder); + if (!imgStream) { + return NS_ERROR_FAILURE; + } + + imgStream.forget(aOutStream); + + return NS_OK; +} + +// static +Maybe<nsTArray<uint8_t>> gfxUtils::EncodeSourceSurfaceAsBytes( + SourceSurface* aSurface, const ImageType aImageType, + const nsAString& aOutputOptions) { + nsCOMPtr<nsIInputStream> imgStream; + nsresult rv = EncodeSourceSurfaceAsStream( + aSurface, aImageType, aOutputOptions, getter_AddRefs(imgStream)); + if (NS_FAILED(rv)) { + return Nothing(); + } + + uint64_t bufSize64; + rv = imgStream->Available(&bufSize64); + if (NS_FAILED(rv) || bufSize64 > UINT32_MAX) { + return Nothing(); + } + + uint32_t bytesLeft = static_cast<uint32_t>(bufSize64); + + nsTArray<uint8_t> imgData; + imgData.SetLength(bytesLeft); + uint8_t* bytePtr = imgData.Elements(); + + while (bytesLeft > 0) { + uint32_t bytesRead = 0; + rv = imgStream->Read(reinterpret_cast<char*>(bytePtr), bytesLeft, + &bytesRead); + if (NS_FAILED(rv) || bytesRead == 0) { + return Nothing(); + } + + bytePtr += bytesRead; + bytesLeft -= bytesRead; + } + +#ifdef DEBUG + + // Currently, all implementers of imgIEncoder report their exact size through + // nsIInputStream::Available(), but let's explicitly state that we rely on + // that behavior for the algorithm above. + + char dummy = 0; + uint32_t bytesRead = 0; + rv = imgStream->Read(&dummy, 1, &bytesRead); + MOZ_ASSERT(NS_SUCCEEDED(rv) && bytesRead == 0); + +#endif + + return Some(std::move(imgData)); +} + +/* static */ +nsresult gfxUtils::EncodeSourceSurface(SourceSurface* aSurface, + const ImageType aImageType, + const nsAString& aOutputOptions, + BinaryOrData aBinaryOrData, FILE* aFile, + nsACString* aStrOut) { + MOZ_ASSERT(aBinaryOrData == gfxUtils::eDataURIEncode || aFile || aStrOut, + "Copying binary encoding to clipboard not currently supported"); + + auto maybeImgData = + EncodeSourceSurfaceAsBytes(aSurface, aImageType, aOutputOptions); + if (!maybeImgData) { + return NS_ERROR_FAILURE; + } + + nsTArray<uint8_t>& imgData = *maybeImgData; + + if (aBinaryOrData == gfxUtils::eBinaryEncode) { + if (aFile) { + Unused << fwrite(imgData.Elements(), 1, imgData.Length(), aFile); + } + return NS_OK; + } + + nsCString stringBuf; + nsACString& dataURI = aStrOut ? *aStrOut : stringBuf; + dataURI.AppendLiteral("data:"); + + switch (aImageType) { + case ImageType::BMP: + dataURI.AppendLiteral(IMAGE_BMP); + break; + + case ImageType::ICO: + dataURI.AppendLiteral(IMAGE_ICO_MS); + break; + case ImageType::JPEG: + dataURI.AppendLiteral(IMAGE_JPEG); + break; + + case ImageType::PNG: + dataURI.AppendLiteral(IMAGE_PNG); + break; + + default: + break; + } + + dataURI.AppendLiteral(";base64,"); + nsresult rv = Base64EncodeAppend(reinterpret_cast<char*>(imgData.Elements()), + imgData.Length(), dataURI); + NS_ENSURE_SUCCESS(rv, rv); + + if (aFile) { +#ifdef ANDROID + if (aFile == stdout || aFile == stderr) { + // ADB logcat cuts off long strings so we will break it down + const char* cStr = dataURI.BeginReading(); + size_t len = strlen(cStr); + while (true) { + printf_stderr("IMG: %.140s\n", cStr); + if (len <= 140) break; + len -= 140; + cStr += 140; + } + } +#endif + fprintf(aFile, "%s", dataURI.BeginReading()); + } else if (!aStrOut) { + nsCOMPtr<nsIClipboardHelper> clipboard( + do_GetService("@mozilla.org/widget/clipboardhelper;1", &rv)); + if (clipboard) { + clipboard->CopyString(NS_ConvertASCIItoUTF16(dataURI)); + } + } + return NS_OK; +} + +static nsCString EncodeSourceSurfaceAsPNGURI(SourceSurface* aSurface) { + nsCString string; + gfxUtils::EncodeSourceSurface(aSurface, ImageType::PNG, u""_ns, + gfxUtils::eDataURIEncode, nullptr, &string); + return string; +} + +// https://jdashg.github.io/misc/colors/from-coeffs.html +const float kBT601NarrowYCbCrToRGB_RowMajor[16] = { + 1.16438f, 0.00000f, 1.59603f, -0.87420f, 1.16438f, -0.39176f, + -0.81297f, 0.53167f, 1.16438f, 2.01723f, 0.00000f, -1.08563f, + 0.00000f, 0.00000f, 0.00000f, 1.00000f}; +const float kBT709NarrowYCbCrToRGB_RowMajor[16] = { + 1.16438f, 0.00000f, 1.79274f, -0.97295f, 1.16438f, -0.21325f, + -0.53291f, 0.30148f, 1.16438f, 2.11240f, 0.00000f, -1.13340f, + 0.00000f, 0.00000f, 0.00000f, 1.00000f}; +const float kBT2020NarrowYCbCrToRGB_RowMajor[16] = { + 1.16438f, 0.00000f, 1.67867f, -0.91569f, 1.16438f, -0.18733f, + -0.65042f, 0.34746f, 1.16438f, 2.14177f, 0.00000f, -1.14815f, + 0.00000f, 0.00000f, 0.00000f, 1.00000f}; +const float kIdentityNarrowYCbCrToRGB_RowMajor[16] = { + 0.00000f, 0.00000f, 1.00000f, 0.00000f, 1.00000f, 0.00000f, + 0.00000f, 0.00000f, 0.00000f, 1.00000f, 0.00000f, 0.00000f, + 0.00000f, 0.00000f, 0.00000f, 1.00000f}; + +/* static */ const float* gfxUtils::YuvToRgbMatrix4x3RowMajor( + gfx::YUVColorSpace aYUVColorSpace) { +#define X(x) \ + { x[0], x[1], x[2], 0.0f, x[4], x[5], x[6], 0.0f, x[8], x[9], x[10], 0.0f } + + static const float rec601[12] = X(kBT601NarrowYCbCrToRGB_RowMajor); + static const float rec709[12] = X(kBT709NarrowYCbCrToRGB_RowMajor); + static const float rec2020[12] = X(kBT2020NarrowYCbCrToRGB_RowMajor); + static const float identity[12] = X(kIdentityNarrowYCbCrToRGB_RowMajor); + +#undef X + + switch (aYUVColorSpace) { + case gfx::YUVColorSpace::BT601: + return rec601; + case gfx::YUVColorSpace::BT709: + return rec709; + case gfx::YUVColorSpace::BT2020: + return rec2020; + case gfx::YUVColorSpace::Identity: + return identity; + default: + MOZ_CRASH("Bad YUVColorSpace"); + } +} + +/* static */ const float* gfxUtils::YuvToRgbMatrix3x3ColumnMajor( + gfx::YUVColorSpace aYUVColorSpace) { +#define X(x) \ + { x[0], x[4], x[8], x[1], x[5], x[9], x[2], x[6], x[10] } + + static const float rec601[9] = X(kBT601NarrowYCbCrToRGB_RowMajor); + static const float rec709[9] = X(kBT709NarrowYCbCrToRGB_RowMajor); + static const float rec2020[9] = X(kBT2020NarrowYCbCrToRGB_RowMajor); + static const float identity[9] = X(kIdentityNarrowYCbCrToRGB_RowMajor); + +#undef X + + switch (aYUVColorSpace) { + case gfx::YUVColorSpace::BT601: + return rec601; + case YUVColorSpace::BT709: + return rec709; + case YUVColorSpace::BT2020: + return rec2020; + case YUVColorSpace::Identity: + return identity; + default: + MOZ_CRASH("Bad YUVColorSpace"); + } +} + +/* static */ const float* gfxUtils::YuvToRgbMatrix4x4ColumnMajor( + YUVColorSpace aYUVColorSpace) { +#define X(x) \ + { \ + x[0], x[4], x[8], x[12], x[1], x[5], x[9], x[13], x[2], x[6], x[10], \ + x[14], x[3], x[7], x[11], x[15] \ + } + + static const float rec601[16] = X(kBT601NarrowYCbCrToRGB_RowMajor); + static const float rec709[16] = X(kBT709NarrowYCbCrToRGB_RowMajor); + static const float rec2020[16] = X(kBT2020NarrowYCbCrToRGB_RowMajor); + static const float identity[16] = X(kIdentityNarrowYCbCrToRGB_RowMajor); + +#undef X + + switch (aYUVColorSpace) { + case YUVColorSpace::BT601: + return rec601; + case YUVColorSpace::BT709: + return rec709; + case YUVColorSpace::BT2020: + return rec2020; + case YUVColorSpace::Identity: + return identity; + default: + MOZ_CRASH("Bad YUVColorSpace"); + } +} + +// Translate from CICP values to the color spaces we support, or return +// Nothing() if there is no appropriate match to let the caller choose +// a default or generate an error. +// +// See Rec. ITU-T H.273 (12/2016) for details on CICP +/* static */ Maybe<gfx::YUVColorSpace> gfxUtils::CicpToColorSpace( + const CICP::MatrixCoefficients aMatrixCoefficients, + const CICP::ColourPrimaries aColourPrimaries, LazyLogModule& aLogger) { + switch (aMatrixCoefficients) { + case CICP::MatrixCoefficients::MC_BT2020_NCL: + case CICP::MatrixCoefficients::MC_BT2020_CL: + return Some(gfx::YUVColorSpace::BT2020); + case CICP::MatrixCoefficients::MC_BT601: + return Some(gfx::YUVColorSpace::BT601); + case CICP::MatrixCoefficients::MC_BT709: + return Some(gfx::YUVColorSpace::BT709); + case CICP::MatrixCoefficients::MC_IDENTITY: + return Some(gfx::YUVColorSpace::Identity); + case CICP::MatrixCoefficients::MC_CHROMAT_NCL: + case CICP::MatrixCoefficients::MC_CHROMAT_CL: + case CICP::MatrixCoefficients::MC_UNSPECIFIED: + switch (aColourPrimaries) { + case CICP::ColourPrimaries::CP_BT601: + return Some(gfx::YUVColorSpace::BT601); + case CICP::ColourPrimaries::CP_BT709: + return Some(gfx::YUVColorSpace::BT709); + case CICP::ColourPrimaries::CP_BT2020: + return Some(gfx::YUVColorSpace::BT2020); + default: + MOZ_LOG(aLogger, LogLevel::Debug, + ("Couldn't infer color matrix from primaries: %hhu", + aColourPrimaries)); + return {}; + } + default: + MOZ_LOG(aLogger, LogLevel::Debug, + ("Unsupported color matrix value: %hhu", aMatrixCoefficients)); + return {}; + } +} + +// Translate from CICP values to the color primaries we support, or return +// Nothing() if there is no appropriate match to let the caller choose +// a default or generate an error. +// +// See Rec. ITU-T H.273 (12/2016) for details on CICP +/* static */ Maybe<gfx::ColorSpace2> gfxUtils::CicpToColorPrimaries( + const CICP::ColourPrimaries aColourPrimaries, LazyLogModule& aLogger) { + switch (aColourPrimaries) { + case CICP::ColourPrimaries::CP_BT709: + return Some(gfx::ColorSpace2::BT709); + case CICP::ColourPrimaries::CP_BT2020: + return Some(gfx::ColorSpace2::BT2020); + default: + MOZ_LOG(aLogger, LogLevel::Debug, + ("Unsupported color primaries value: %hhu", aColourPrimaries)); + return {}; + } +} + +// Translate from CICP values to the transfer functions we support, or return +// Nothing() if there is no appropriate match. +// +/* static */ Maybe<gfx::TransferFunction> gfxUtils::CicpToTransferFunction( + const CICP::TransferCharacteristics aTransferCharacteristics) { + switch (aTransferCharacteristics) { + case CICP::TransferCharacteristics::TC_BT709: + return Some(gfx::TransferFunction::BT709); + + case CICP::TransferCharacteristics::TC_SRGB: + return Some(gfx::TransferFunction::SRGB); + + case CICP::TransferCharacteristics::TC_SMPTE2084: + return Some(gfx::TransferFunction::PQ); + + case CICP::TransferCharacteristics::TC_HLG: + return Some(gfx::TransferFunction::HLG); + + default: + return {}; + } +} + +/* static */ +void gfxUtils::WriteAsPNG(SourceSurface* aSurface, const nsAString& aFile) { + WriteAsPNG(aSurface, NS_ConvertUTF16toUTF8(aFile).get()); +} + +/* static */ +void gfxUtils::WriteAsPNG(SourceSurface* aSurface, const char* aFile) { + FILE* file = fopen(aFile, "wb"); + + if (!file) { + // Maybe the directory doesn't exist; try creating it, then fopen again. + nsresult rv = NS_ERROR_FAILURE; + nsCOMPtr<nsIFile> comFile = do_CreateInstance("@mozilla.org/file/local;1"); + if (comFile) { + NS_ConvertUTF8toUTF16 utf16path((nsDependentCString(aFile))); + rv = comFile->InitWithPath(utf16path); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr<nsIFile> dirPath; + comFile->GetParent(getter_AddRefs(dirPath)); + if (dirPath) { + rv = dirPath->Create(nsIFile::DIRECTORY_TYPE, 0777); + if (NS_SUCCEEDED(rv) || rv == NS_ERROR_FILE_ALREADY_EXISTS) { + file = fopen(aFile, "wb"); + } + } + } + } + if (!file) { + NS_WARNING("Failed to open file to create PNG!"); + return; + } + } + + EncodeSourceSurface(aSurface, ImageType::PNG, u""_ns, eBinaryEncode, file); + fclose(file); +} + +/* static */ +void gfxUtils::WriteAsPNG(DrawTarget* aDT, const nsAString& aFile) { + WriteAsPNG(aDT, NS_ConvertUTF16toUTF8(aFile).get()); +} + +/* static */ +void gfxUtils::WriteAsPNG(DrawTarget* aDT, const char* aFile) { + RefPtr<SourceSurface> surface = aDT->Snapshot(); + if (surface) { + WriteAsPNG(surface, aFile); + } else { + NS_WARNING("Failed to get surface!"); + } +} + +/* static */ +void gfxUtils::DumpAsDataURI(SourceSurface* aSurface, FILE* aFile) { + EncodeSourceSurface(aSurface, ImageType::PNG, u""_ns, eDataURIEncode, aFile); +} + +/* static */ +nsCString gfxUtils::GetAsDataURI(SourceSurface* aSurface) { + return EncodeSourceSurfaceAsPNGURI(aSurface); +} + +/* static */ +void gfxUtils::DumpAsDataURI(DrawTarget* aDT, FILE* aFile) { + RefPtr<SourceSurface> surface = aDT->Snapshot(); + if (surface) { + DumpAsDataURI(surface, aFile); + } else { + NS_WARNING("Failed to get surface!"); + } +} + +/* static */ +nsCString gfxUtils::GetAsLZ4Base64Str(DataSourceSurface* aSourceSurface) { + DataSourceSurface::ScopedMap map(aSourceSurface, DataSourceSurface::READ); + int32_t dataSize = aSourceSurface->GetSize().height * map.GetStride(); + auto compressedData = MakeUnique<char[]>(LZ4::maxCompressedSize(dataSize)); + if (compressedData) { + int nDataSize = + LZ4::compress((char*)map.GetData(), dataSize, compressedData.get()); + if (nDataSize > 0) { + nsCString string; + string.AppendPrintf("data:image/lz4bgra;base64,%i,%i,%i,", + aSourceSurface->GetSize().width, map.GetStride(), + aSourceSurface->GetSize().height); + nsresult rv = Base64EncodeAppend(compressedData.get(), nDataSize, string); + if (rv == NS_OK) { + return string; + } + } + } + return {}; +} + +/* static */ +nsCString gfxUtils::GetAsDataURI(DrawTarget* aDT) { + RefPtr<SourceSurface> surface = aDT->Snapshot(); + if (surface) { + return EncodeSourceSurfaceAsPNGURI(surface); + } else { + NS_WARNING("Failed to get surface!"); + return nsCString(""); + } +} + +/* static */ +void gfxUtils::CopyAsDataURI(SourceSurface* aSurface) { + EncodeSourceSurface(aSurface, ImageType::PNG, u""_ns, eDataURIEncode, + nullptr); +} + +/* static */ +void gfxUtils::CopyAsDataURI(DrawTarget* aDT) { + RefPtr<SourceSurface> surface = aDT->Snapshot(); + if (surface) { + CopyAsDataURI(surface); + } else { + NS_WARNING("Failed to get surface!"); + } +} + +/* static */ +UniquePtr<uint8_t[]> gfxUtils::GetImageBuffer(gfx::DataSourceSurface* aSurface, + bool aIsAlphaPremultiplied, + int32_t* outFormat) { + *outFormat = 0; + + DataSourceSurface::MappedSurface map; + if (!aSurface->Map(DataSourceSurface::MapType::READ, &map)) return nullptr; + + uint32_t bufferSize = + aSurface->GetSize().width * aSurface->GetSize().height * 4; + auto imageBuffer = MakeUniqueFallible<uint8_t[]>(bufferSize); + if (!imageBuffer) { + aSurface->Unmap(); + return nullptr; + } + memcpy(imageBuffer.get(), map.mData, bufferSize); + + aSurface->Unmap(); + + int32_t format = imgIEncoder::INPUT_FORMAT_HOSTARGB; + if (!aIsAlphaPremultiplied) { + // We need to convert to INPUT_FORMAT_RGBA, otherwise + // we are automatically considered premult, and unpremult'd. + // Yes, it is THAT silly. + // Except for different lossy conversions by color, + // we could probably just change the label, and not change the data. + gfxUtils::ConvertBGRAtoRGBA(imageBuffer.get(), bufferSize); + format = imgIEncoder::INPUT_FORMAT_RGBA; + } + + *outFormat = format; + return imageBuffer; +} + +/* static */ +UniquePtr<uint8_t[]> gfxUtils::GetImageBufferWithRandomNoise( + gfx::DataSourceSurface* aSurface, bool aIsAlphaPremultiplied, + nsICookieJarSettings* aCookieJarSettings, int32_t* outFormat) { + UniquePtr<uint8_t[]> imageBuffer = + GetImageBuffer(aSurface, aIsAlphaPremultiplied, outFormat); + + nsRFPService::RandomizePixels( + aCookieJarSettings, imageBuffer.get(), aSurface->GetSize().width, + aSurface->GetSize().height, + aSurface->GetSize().width * aSurface->GetSize().height * 4, + SurfaceFormat::A8R8G8B8_UINT32); + + return imageBuffer; +} + +/* static */ +nsresult gfxUtils::GetInputStream(gfx::DataSourceSurface* aSurface, + bool aIsAlphaPremultiplied, + const char* aMimeType, + const nsAString& aEncoderOptions, + nsIInputStream** outStream) { + nsCString enccid("@mozilla.org/image/encoder;2?type="); + enccid += aMimeType; + nsCOMPtr<imgIEncoder> encoder = do_CreateInstance(enccid.get()); + if (!encoder) return NS_ERROR_FAILURE; + + int32_t format = 0; + UniquePtr<uint8_t[]> imageBuffer = + GetImageBuffer(aSurface, aIsAlphaPremultiplied, &format); + if (!imageBuffer) return NS_ERROR_FAILURE; + + return dom::ImageEncoder::GetInputStream( + aSurface->GetSize().width, aSurface->GetSize().height, imageBuffer.get(), + format, encoder, aEncoderOptions, outStream); +} + +/* static */ +nsresult gfxUtils::GetInputStreamWithRandomNoise( + gfx::DataSourceSurface* aSurface, bool aIsAlphaPremultiplied, + const char* aMimeType, const nsAString& aEncoderOptions, + nsICookieJarSettings* aCookieJarSettings, nsIInputStream** outStream) { + nsCString enccid("@mozilla.org/image/encoder;2?type="); + enccid += aMimeType; + nsCOMPtr<imgIEncoder> encoder = do_CreateInstance(enccid.get()); + if (!encoder) { + return NS_ERROR_FAILURE; + } + + int32_t format = 0; + UniquePtr<uint8_t[]> imageBuffer = + GetImageBuffer(aSurface, aIsAlphaPremultiplied, &format); + if (!imageBuffer) { + return NS_ERROR_FAILURE; + } + + nsRFPService::RandomizePixels( + aCookieJarSettings, imageBuffer.get(), aSurface->GetSize().width, + aSurface->GetSize().height, + aSurface->GetSize().width * aSurface->GetSize().height * 4, + SurfaceFormat::A8R8G8B8_UINT32); + + return dom::ImageEncoder::GetInputStream( + aSurface->GetSize().width, aSurface->GetSize().height, imageBuffer.get(), + format, encoder, aEncoderOptions, outStream); +} + +class GetFeatureStatusWorkerRunnable final + : public dom::WorkerMainThreadRunnable { + public: + GetFeatureStatusWorkerRunnable(dom::WorkerPrivate* workerPrivate, + const nsCOMPtr<nsIGfxInfo>& gfxInfo, + int32_t feature, nsACString& failureId, + int32_t* status) + : WorkerMainThreadRunnable(workerPrivate, "GFX :: GetFeatureStatus"_ns), + mGfxInfo(gfxInfo), + mFeature(feature), + mStatus(status), + mFailureId(failureId), + mNSResult(NS_OK) {} + + bool MainThreadRun() override { + if (mGfxInfo) { + mNSResult = mGfxInfo->GetFeatureStatus(mFeature, mFailureId, mStatus); + } + return true; + } + + nsresult GetNSResult() const { return mNSResult; } + + protected: + ~GetFeatureStatusWorkerRunnable() = default; + + private: + nsCOMPtr<nsIGfxInfo> mGfxInfo; + int32_t mFeature; + int32_t* mStatus; + nsACString& mFailureId; + nsresult mNSResult; +}; + +#define GFX_SHADER_CHECK_BUILD_VERSION_PREF "gfx-shader-check.build-version" +#define GFX_SHADER_CHECK_PTR_SIZE_PREF "gfx-shader-check.ptr-size" +#define GFX_SHADER_CHECK_DEVICE_ID_PREF "gfx-shader-check.device-id" +#define GFX_SHADER_CHECK_DRIVER_VERSION_PREF "gfx-shader-check.driver-version" + +/* static */ +void gfxUtils::RemoveShaderCacheFromDiskIfNecessary() { + if (!gfxVars::UseWebRenderProgramBinaryDisk()) { + return; + } + + nsCOMPtr<nsIGfxInfo> gfxInfo = components::GfxInfo::Service(); + + // Get current values + nsCString buildID(mozilla::PlatformBuildID()); + int ptrSize = sizeof(void*); + nsString deviceID, driverVersion; + gfxInfo->GetAdapterDeviceID(deviceID); + gfxInfo->GetAdapterDriverVersion(driverVersion); + + // Get pref stored values + nsAutoCString buildIDChecked; + Preferences::GetCString(GFX_SHADER_CHECK_BUILD_VERSION_PREF, buildIDChecked); + int ptrSizeChecked = Preferences::GetInt(GFX_SHADER_CHECK_PTR_SIZE_PREF, 0); + nsAutoString deviceIDChecked, driverVersionChecked; + Preferences::GetString(GFX_SHADER_CHECK_DEVICE_ID_PREF, deviceIDChecked); + Preferences::GetString(GFX_SHADER_CHECK_DRIVER_VERSION_PREF, + driverVersionChecked); + + if (buildID == buildIDChecked && ptrSize == ptrSizeChecked && + deviceID == deviceIDChecked && driverVersion == driverVersionChecked) { + return; + } + + nsAutoString path(gfx::gfxVars::ProfDirectory()); + + if (!wr::remove_program_binary_disk_cache(&path)) { + // Failed to remove program binary disk cache. The disk cache might have + // invalid data. Disable program binary disk cache usage. + gfxVars::SetUseWebRenderProgramBinaryDisk(false); + return; + } + + Preferences::SetCString(GFX_SHADER_CHECK_BUILD_VERSION_PREF, buildID); + Preferences::SetInt(GFX_SHADER_CHECK_PTR_SIZE_PREF, ptrSize); + Preferences::SetString(GFX_SHADER_CHECK_DEVICE_ID_PREF, deviceID); + Preferences::SetString(GFX_SHADER_CHECK_DRIVER_VERSION_PREF, driverVersion); +} + +/* static */ +bool gfxUtils::DumpDisplayList() { + return StaticPrefs::layout_display_list_dump() || + (StaticPrefs::layout_display_list_dump_parent() && + XRE_IsParentProcess()) || + (StaticPrefs::layout_display_list_dump_content() && + XRE_IsContentProcess()); +} + +FILE* gfxUtils::sDumpPaintFile = stderr; + +namespace mozilla { +namespace gfx { + +DeviceColor ToDeviceColor(const sRGBColor& aColor) { + // aColor is pass-by-value since to get return value optimization goodness we + // need to return the same object from all return points in this function. We + // could declare a local Color variable and use that, but we might as well + // just use aColor. + if (gfxPlatform::GetCMSMode() == CMSMode::All) { + qcms_transform* transform = gfxPlatform::GetCMSRGBTransform(); + if (transform) { + return gfxPlatform::TransformPixel(aColor, transform); + // Use the original alpha to avoid unnecessary float->byte->float + // conversion errors + } + } + return DeviceColor(aColor.r, aColor.g, aColor.b, aColor.a); +} + +DeviceColor ToDeviceColor(nscolor aColor) { + return ToDeviceColor(sRGBColor::FromABGR(aColor)); +} + +DeviceColor ToDeviceColor(const StyleAbsoluteColor& aColor) { + return ToDeviceColor(aColor.ToColor()); +} + +sRGBColor ToSRGBColor(const StyleAbsoluteColor& aColor) { + auto srgb = aColor.ToColorSpace(StyleColorSpace::Srgb); + + const auto ToComponent = [](float aF) -> float { + float component = std::min(std::max(0.0f, aF), 1.0f); + if (MOZ_UNLIKELY(!std::isfinite(component))) { + return 0.0f; + } + return component; + }; + return {ToComponent(srgb.components._0), ToComponent(srgb.components._1), + ToComponent(srgb.components._2), ToComponent(srgb.alpha)}; +} + +} // namespace gfx +} // namespace mozilla |