image/DynamicImage.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "DynamicImage.h"
   7 #include "gfxContext.h"
   8 #include "gfxPlatform.h"
   9 #include "gfxUtils.h"
  10 #include "mozilla/gfx/2D.h"
  11 #include "mozilla/gfx/Logging.h"
  12 #include "mozilla/RefPtr.h"
  13 #include "mozilla/SVGImageContext.h"
  14 #include "ImageRegion.h"
  15 #include "Orientation.h"
  16 #include "mozilla/image/Resolution.h"
  17
  18 #include "mozilla/MemoryReporting.h"
  19
  20 using namespace mozilla;
  21 using namespace mozilla::gfx;
  22 using mozilla::layers::ImageContainer;
  23
  24 namespace mozilla {
  25 namespace image {
  26
  27 // Inherited methods from Image.
  28
  29 already_AddRefed<ProgressTracker> DynamicImage::GetProgressTracker() {
  30   return nullptr;
  31 }
  32
  33 size_t DynamicImage::SizeOfSourceWithComputedFallback(
  34     SizeOfState& aState) const {
  35   return 0;
  36 }
  37
  38 void DynamicImage::CollectSizeOfSurfaces(
  39     nsTArray<SurfaceMemoryCounter>& aCounters,
  40     MallocSizeOf aMallocSizeOf) const {
  41   // We can't report anything useful because gfxDrawable doesn't expose this
  42   // information.
  43 }
  44
  45 void DynamicImage::IncrementAnimationConsumers() {}
  46
  47 void DynamicImage::DecrementAnimationConsumers() {}
  48
  49 #ifdef DEBUG
  50 uint32_t DynamicImage::GetAnimationConsumers() { return 0; }
  51 #endif
  52
  53 nsresult DynamicImage::OnImageDataAvailable(nsIRequest* aRequest,
  54                                             nsIInputStream* aInStr,
  55                                             uint64_t aSourceOffset,
  56                                             uint32_t aCount) {
  57   return NS_OK;
  58 }
  59
  60 nsresult DynamicImage::OnImageDataComplete(nsIRequest* aRequest,
  61                                            nsresult aStatus, bool aLastPart) {
  62   return NS_OK;
  63 }
  64
  65 void DynamicImage::OnSurfaceDiscarded(const SurfaceKey& aSurfaceKey) {}
  66
  67 void DynamicImage::SetInnerWindowID(uint64_t aInnerWindowId) {}
  68
  69 uint64_t DynamicImage::InnerWindowID() const { return 0; }
  70
  71 bool DynamicImage::HasError() { return !mDrawable; }
  72
  73 void DynamicImage::SetHasError() {}
  74
  75 nsIURI* DynamicImage::GetURI() const { return nullptr; }
  76
  77 // Methods inherited from XPCOM interfaces.
  78
  79 NS_IMPL_ISUPPORTS(DynamicImage, imgIContainer)
  80
  81 NS_IMETHODIMP
  82 DynamicImage::GetWidth(int32_t* aWidth) {
  83   *aWidth = mDrawable->Size().width;
  84   return NS_OK;
  85 }
  86
  87 NS_IMETHODIMP
  88 DynamicImage::GetHeight(int32_t* aHeight) {
  89   *aHeight = mDrawable->Size().height;
  90   return NS_OK;
  91 }
  92
  93 nsresult DynamicImage::GetNativeSizes(nsTArray<IntSize>& aNativeSizes) const {
  94   return NS_ERROR_NOT_IMPLEMENTED;
  95 }
  96
  97 size_t DynamicImage::GetNativeSizesLength() const { return 0; }
  98
  99 NS_IMETHODIMP
 100 DynamicImage::GetIntrinsicSize(nsSize* aSize) {
 101   IntSize intSize(mDrawable->Size());
 102   *aSize = nsSize(intSize.width, intSize.height);
 103   return NS_OK;
 104 }
 105
 106 Maybe<AspectRatio> DynamicImage::GetIntrinsicRatio() {
 107   auto size = mDrawable->Size();
 108   return Some(AspectRatio::FromSize(size.width, size.height));
 109 }
 110
 111 NS_IMETHODIMP_(Orientation)
 112 DynamicImage::GetOrientation() { return Orientation(); }
 113
 114 NS_IMETHODIMP_(Resolution)
 115 DynamicImage::GetResolution() { return {}; }
 116
 117 NS_IMETHODIMP
 118 DynamicImage::GetType(uint16_t* aType) {
 119   *aType = imgIContainer::TYPE_RASTER;
 120   return NS_OK;
 121 }
 122
 123 NS_IMETHODIMP
 124 DynamicImage::GetProviderId(uint32_t* aId) {
 125   *aId = 0;
 126   return NS_OK;
 127 }
 128
 129 NS_IMETHODIMP
 130 DynamicImage::GetAnimated(bool* aAnimated) {
 131   *aAnimated = false;
 132   return NS_OK;
 133 }
 134
 135 NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
 136 DynamicImage::GetFrame(uint32_t aWhichFrame, uint32_t aFlags) {
 137   IntSize size(mDrawable->Size());
 138   return GetFrameAtSize(IntSize(size.width, size.height), aWhichFrame, aFlags);
 139 }
 140
 141 NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
 142 DynamicImage::GetFrameAtSize(const IntSize& aSize, uint32_t aWhichFrame,
 143                              uint32_t aFlags) {
 144   RefPtr<DrawTarget> dt =
 145       gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
 146           aSize, SurfaceFormat::OS_RGBA);
 147   if (!dt || !dt->IsValid()) {
 148     gfxWarning()
 149         << "DynamicImage::GetFrame failed in CreateOffscreenContentDrawTarget";
 150     return nullptr;
 151   }
 152   RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt);
 153   MOZ_ASSERT(context);  // already checked the draw target above
 154
 155   auto result = Draw(context, aSize, ImageRegion::Create(aSize), aWhichFrame,
 156                      SamplingFilter::POINT, Nothing(), aFlags, 1.0);
 157
 158   return result == ImgDrawResult::SUCCESS ? dt->Snapshot() : nullptr;
 159 }
 160
 161 NS_IMETHODIMP_(bool)
 162 DynamicImage::WillDrawOpaqueNow() { return false; }
 163
 164 NS_IMETHODIMP_(bool)
 165 DynamicImage::IsImageContainerAvailable(WindowRenderer* aRenderer,
 166                                         uint32_t aFlags) {
 167   return false;
 168 }
 169
 170 NS_IMETHODIMP_(ImgDrawResult)
 171 DynamicImage::GetImageProvider(WindowRenderer* aRenderer,
 172                                const gfx::IntSize& aSize,
 173                                const Maybe<SVGImageContext>& aSVGContext,
 174                                const Maybe<ImageIntRegion>& aRegion,
 175                                uint32_t aFlags,
 176                                WebRenderImageProvider** aProvider) {
 177   return ImgDrawResult::NOT_SUPPORTED;
 178 }
 179
 180 NS_IMETHODIMP_(ImgDrawResult)
 181 DynamicImage::Draw(gfxContext* aContext, const nsIntSize& aSize,
 182                    const ImageRegion& aRegion, uint32_t aWhichFrame,
 183                    SamplingFilter aSamplingFilter,
 184                    const Maybe<SVGImageContext>& aSVGContext, uint32_t aFlags,
 185                    float aOpacity) {
 186   MOZ_ASSERT(!aSize.IsEmpty(), "Unexpected empty size");
 187
 188   IntSize drawableSize(mDrawable->Size());
 189
 190   if (aSize == drawableSize) {
 191     gfxUtils::DrawPixelSnapped(aContext, mDrawable, SizeDouble(drawableSize),
 192                                aRegion, SurfaceFormat::OS_RGBA, aSamplingFilter,
 193                                aOpacity);
 194     return ImgDrawResult::SUCCESS;
 195   }
 196
 197   gfxSize scale(double(aSize.width) / drawableSize.width,
 198                 double(aSize.height) / drawableSize.height);
 199
 200   ImageRegion region(aRegion);
 201   region.Scale(1.0 / scale.width, 1.0 / scale.height);
 202
 203   gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
 204   aContext->Multiply(gfxMatrix::Scaling(scale.width, scale.height));
 205
 206   gfxUtils::DrawPixelSnapped(aContext, mDrawable, SizeDouble(drawableSize),
 207                              region, SurfaceFormat::OS_RGBA, aSamplingFilter,
 208                              aOpacity);
 209   return ImgDrawResult::SUCCESS;
 210 }
 211
 212 NS_IMETHODIMP
 213 DynamicImage::StartDecoding(uint32_t aFlags, uint32_t aWhichFrame) {
 214   return NS_OK;
 215 }
 216
 217 bool DynamicImage::StartDecodingWithResult(uint32_t aFlags,
 218                                            uint32_t aWhichFrame) {
 219   return true;
 220 }
 221
 222 imgIContainer::DecodeResult DynamicImage::RequestDecodeWithResult(
 223     uint32_t aFlags, uint32_t aWhichFrame) {
 224   return imgIContainer::DECODE_SURFACE_AVAILABLE;
 225 }
 226
 227 NS_IMETHODIMP
 228 DynamicImage::RequestDecodeForSize(const nsIntSize& aSize, uint32_t aFlags,
 229                                    uint32_t aWhichFrame) {
 230   return NS_OK;
 231 }
 232
 233 NS_IMETHODIMP
 234 DynamicImage::LockImage() { return NS_OK; }
 235
 236 NS_IMETHODIMP
 237 DynamicImage::UnlockImage() { return NS_OK; }
 238
 239 NS_IMETHODIMP
 240 DynamicImage::RequestDiscard() { return NS_OK; }
 241
 242 NS_IMETHODIMP_(void)
 243 DynamicImage::RequestRefresh(const mozilla::TimeStamp& aTime) {}
 244
 245 NS_IMETHODIMP
 246 DynamicImage::GetAnimationMode(uint16_t* aAnimationMode) {
 247   *aAnimationMode = kNormalAnimMode;
 248   return NS_OK;
 249 }
 250
 251 NS_IMETHODIMP
 252 DynamicImage::SetAnimationMode(uint16_t aAnimationMode) { return NS_OK; }
 253
 254 NS_IMETHODIMP
 255 DynamicImage::ResetAnimation() { return NS_OK; }
 256
 257 NS_IMETHODIMP_(float)
 258 DynamicImage::GetFrameIndex(uint32_t aWhichFrame) { return 0; }
 259
 260 NS_IMETHODIMP_(int32_t)
 261 DynamicImage::GetFirstFrameDelay() { return 0; }
 262
 263 NS_IMETHODIMP_(void)
 264 DynamicImage::SetAnimationStartTime(const mozilla::TimeStamp& aTime) {}
 265
 266 nsIntSize DynamicImage::OptimalImageSizeForDest(const gfxSize& aDest,
 267                                                 uint32_t aWhichFrame,
 268                                                 SamplingFilter aSamplingFilter,
 269                                                 uint32_t aFlags) {
 270   IntSize size(mDrawable->Size());
 271   return nsIntSize(size.width, size.height);
 272 }
 273
 274 NS_IMETHODIMP_(nsIntRect)
 275 DynamicImage::GetImageSpaceInvalidationRect(const nsIntRect& aRect) {
 276   return aRect;
 277 }
 278
 279 already_AddRefed<imgIContainer> DynamicImage::Unwrap() {
 280   nsCOMPtr<imgIContainer> self(this);
 281   return self.forget();
 282 }
 283
 284 void DynamicImage::PropagateUseCounters(dom::Document*) {
 285   // No use counters.
 286 }
 287
 288 nsresult DynamicImage::GetHotspotX(int32_t* aX) {
 289   return Image::GetHotspotX(aX);
 290 }
 291
 292 nsresult DynamicImage::GetHotspotY(int32_t* aY) {
 293   return Image::GetHotspotY(aY);
 294 }
 295
 296 }  // namespace image
 297 }  // namespace mozilla