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