mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
0576fa76c9
CLOSED TREE Backed out changeset aafd6db2fbb4 (bug 1207355) Backed out changeset 9dd950b837fb (bug 1207355) Backed out changeset e941e0e106a1 (bug 1207355) Backed out changeset ecebca101fcb (bug 1207355) Backed out changeset 08f2017137e1 (bug 1207355) Backed out changeset 3dc69e37c9b4 (bug 1207355) Backed out changeset bcdf51edb121 (bug 1207355) Backed out changeset 1d4c00dbf49a (bug 1207355)
348 lines
7.3 KiB
C++
348 lines
7.3 KiB
C++
/* -*- Mode: C++; tab-width: 2; 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 "DynamicImage.h"
|
|
#include "gfxPlatform.h"
|
|
#include "gfxUtils.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/RefPtr.h"
|
|
#include "ImageRegion.h"
|
|
#include "Orientation.h"
|
|
#include "SVGImageContext.h"
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::gfx;
|
|
using mozilla::layers::LayerManager;
|
|
using mozilla::layers::ImageContainer;
|
|
|
|
namespace mozilla {
|
|
namespace image {
|
|
|
|
// Inherited methods from Image.
|
|
|
|
already_AddRefed<ProgressTracker>
|
|
DynamicImage::GetProgressTracker()
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
size_t
|
|
DynamicImage::SizeOfSourceWithComputedFallback(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
DynamicImage::CollectSizeOfSurfaces(nsTArray<SurfaceMemoryCounter>& aCounters,
|
|
MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
// We can't report anything useful because gfxDrawable doesn't expose this
|
|
// information.
|
|
}
|
|
|
|
void
|
|
DynamicImage::IncrementAnimationConsumers()
|
|
{ }
|
|
|
|
void
|
|
DynamicImage::DecrementAnimationConsumers()
|
|
{ }
|
|
|
|
#ifdef DEBUG
|
|
uint32_t
|
|
DynamicImage::GetAnimationConsumers()
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
nsresult
|
|
DynamicImage::OnImageDataAvailable(nsIRequest* aRequest,
|
|
nsISupports* aContext,
|
|
nsIInputStream* aInStr,
|
|
uint64_t aSourceOffset,
|
|
uint32_t aCount)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
DynamicImage::OnImageDataComplete(nsIRequest* aRequest,
|
|
nsISupports* aContext,
|
|
nsresult aStatus,
|
|
bool aLastPart)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
DynamicImage::OnSurfaceDiscarded()
|
|
{ }
|
|
|
|
void
|
|
DynamicImage::SetInnerWindowID(uint64_t aInnerWindowId)
|
|
{ }
|
|
|
|
uint64_t
|
|
DynamicImage::InnerWindowID() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
DynamicImage::HasError()
|
|
{
|
|
return !mDrawable;
|
|
}
|
|
|
|
void
|
|
DynamicImage::SetHasError()
|
|
{ }
|
|
|
|
ImageURL*
|
|
DynamicImage::GetURI()
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
// Methods inherited from XPCOM interfaces.
|
|
|
|
NS_IMPL_ISUPPORTS(DynamicImage, imgIContainer)
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::GetWidth(int32_t* aWidth)
|
|
{
|
|
*aWidth = mDrawable->Size().width;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::GetHeight(int32_t* aHeight)
|
|
{
|
|
*aHeight = mDrawable->Size().height;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::GetIntrinsicSize(nsSize* aSize)
|
|
{
|
|
IntSize intSize(mDrawable->Size());
|
|
*aSize = nsSize(intSize.width, intSize.height);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::GetIntrinsicRatio(nsSize* aSize)
|
|
{
|
|
IntSize intSize(mDrawable->Size());
|
|
*aSize = nsSize(intSize.width, intSize.height);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP_(Orientation)
|
|
DynamicImage::GetOrientation()
|
|
{
|
|
return Orientation();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::GetType(uint16_t* aType)
|
|
{
|
|
*aType = imgIContainer::TYPE_RASTER;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::GetAnimated(bool* aAnimated)
|
|
{
|
|
*aAnimated = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
|
|
DynamicImage::GetFrame(uint32_t aWhichFrame,
|
|
uint32_t aFlags)
|
|
{
|
|
IntSize size(mDrawable->Size());
|
|
return GetFrameAtSize(IntSize(size.width, size.height),
|
|
aWhichFrame,
|
|
aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
|
|
DynamicImage::GetFrameAtSize(const IntSize& aSize,
|
|
uint32_t aWhichFrame,
|
|
uint32_t aFlags)
|
|
{
|
|
RefPtr<DrawTarget> dt = gfxPlatform::GetPlatform()->
|
|
CreateOffscreenContentDrawTarget(aSize, SurfaceFormat::B8G8R8A8);
|
|
if (!dt) {
|
|
gfxWarning() <<
|
|
"DynamicImage::GetFrame failed in CreateOffscreenContentDrawTarget";
|
|
return nullptr;
|
|
}
|
|
RefPtr<gfxContext> context = new gfxContext(dt);
|
|
|
|
auto result = Draw(context, aSize, ImageRegion::Create(aSize),
|
|
aWhichFrame, Filter::POINT, Nothing(), aFlags);
|
|
|
|
return result == DrawResult::SUCCESS ? dt->Snapshot() : nullptr;
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
DynamicImage::IsOpaque()
|
|
{
|
|
// XXX(seth): For performance reasons it'd be better to return true here, but
|
|
// I'm not sure how we can guarantee it for an arbitrary gfxDrawable.
|
|
return false;
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
DynamicImage::IsImageContainerAvailable(LayerManager* aManager, uint32_t aFlags)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
|
|
DynamicImage::GetImageContainer(LayerManager* aManager, uint32_t aFlags)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
NS_IMETHODIMP_(DrawResult)
|
|
DynamicImage::Draw(gfxContext* aContext,
|
|
const nsIntSize& aSize,
|
|
const ImageRegion& aRegion,
|
|
uint32_t aWhichFrame,
|
|
Filter aFilter,
|
|
const Maybe<SVGImageContext>& aSVGContext,
|
|
uint32_t aFlags)
|
|
{
|
|
MOZ_ASSERT(!aSize.IsEmpty(), "Unexpected empty size");
|
|
|
|
IntSize drawableSize(mDrawable->Size());
|
|
|
|
if (aSize == drawableSize) {
|
|
gfxUtils::DrawPixelSnapped(aContext, mDrawable, drawableSize, aRegion,
|
|
SurfaceFormat::B8G8R8A8, aFilter);
|
|
return DrawResult::SUCCESS;
|
|
}
|
|
|
|
gfxSize scale(double(aSize.width) / drawableSize.width,
|
|
double(aSize.height) / drawableSize.height);
|
|
|
|
ImageRegion region(aRegion);
|
|
region.Scale(1.0 / scale.width, 1.0 / scale.height);
|
|
|
|
gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
|
|
aContext->Multiply(gfxMatrix::Scaling(scale.width, scale.height));
|
|
|
|
gfxUtils::DrawPixelSnapped(aContext, mDrawable, drawableSize, region,
|
|
SurfaceFormat::B8G8R8A8, aFilter);
|
|
return DrawResult::SUCCESS;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::StartDecoding()
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::RequestDecodeForSize(const nsIntSize& aSize, uint32_t aFlags)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::LockImage()
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::UnlockImage()
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::RequestDiscard()
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP_(void)
|
|
DynamicImage::RequestRefresh(const mozilla::TimeStamp& aTime)
|
|
{ }
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::GetAnimationMode(uint16_t* aAnimationMode)
|
|
{
|
|
*aAnimationMode = kNormalAnimMode;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::SetAnimationMode(uint16_t aAnimationMode)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
DynamicImage::ResetAnimation()
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP_(float)
|
|
DynamicImage::GetFrameIndex(uint32_t aWhichFrame)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
NS_IMETHODIMP_(int32_t)
|
|
DynamicImage::GetFirstFrameDelay()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
NS_IMETHODIMP_(void)
|
|
DynamicImage::SetAnimationStartTime(const mozilla::TimeStamp& aTime)
|
|
{ }
|
|
|
|
nsIntSize
|
|
DynamicImage::OptimalImageSizeForDest(const gfxSize& aDest,
|
|
uint32_t aWhichFrame,
|
|
Filter aFilter, uint32_t aFlags)
|
|
{
|
|
IntSize size(mDrawable->Size());
|
|
return nsIntSize(size.width, size.height);
|
|
}
|
|
|
|
NS_IMETHODIMP_(nsIntRect)
|
|
DynamicImage::GetImageSpaceInvalidationRect(const nsIntRect& aRect)
|
|
{
|
|
return aRect;
|
|
}
|
|
|
|
already_AddRefed<imgIContainer>
|
|
DynamicImage::Unwrap()
|
|
{
|
|
nsCOMPtr<imgIContainer> self(this);
|
|
return self.forget();
|
|
}
|
|
|
|
void
|
|
DynamicImage::PropagateUseCounters(nsIDocument*)
|
|
{
|
|
// No use counters.
|
|
}
|
|
|
|
} // namespace image
|
|
} // namespace mozilla
|