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