image/src/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/RefPtr.h"
  11 #include "ImageRegion.h"
  12 #include "Orientation.h"
  13 #include "SVGImageContext.h"
  14
  15 #include "mozilla/MemoryReporting.h"
  16
  17 using namespace mozilla;
  18 using namespace mozilla::gfx;
  19 using mozilla::layers::LayerManager;
  20 using mozilla::layers::ImageContainer;
  21
  22 namespace mozilla {
  23 namespace image {
  24
  25 // Inherited methods from Image.
  26
  27 nsresult
  28 DynamicImage::Init(const char* aMimeType, uint32_t aFlags)
  29 {
  30   return NS_OK;
  31 }
  32
  33 already_AddRefed<imgStatusTracker>
  34 DynamicImage::GetStatusTracker()
  35 {
  36   return nullptr;
  37 }
  38
  39 nsIntRect
  40 DynamicImage::FrameRect(uint32_t aWhichFrame)
  41 {
  42   gfxIntSize size(mDrawable->Size());
  43   return nsIntRect(0, 0, size.width, size.height);
  44 }
  45
  46 uint32_t
  47 DynamicImage::SizeOfData()
  48 {
  49   // We don't know the answer to this (and the same goes for the other
  50   // memory-related methods) since gfxDrawable doesn't expose a way to check.
  51   return 0;
  52 }
  53
  54 size_t
  55 DynamicImage::HeapSizeOfSourceWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const
  56 {
  57   return 0;
  58 }
  59
  60 size_t
  61 DynamicImage::HeapSizeOfDecodedWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const
  62 {
  63   return 0;
  64 }
  65
  66 size_t
  67 DynamicImage::NonHeapSizeOfDecoded() const
  68 {
  69   return 0;
  70 }
  71
  72 size_t
  73 DynamicImage::OutOfProcessSizeOfDecoded() const
  74 {
  75   return 0;
  76 }
  77
  78 size_t
  79 DynamicImage::HeapSizeOfVectorImageDocument(nsACString* aDocURL) const
  80 {
  81   return 0;
  82 }
  83
  84 void
  85 DynamicImage::IncrementAnimationConsumers()
  86 { }
  87
  88 void
  89 DynamicImage::DecrementAnimationConsumers()
  90 { }
  91
  92 #ifdef DEBUG
  93 uint32_t
  94 DynamicImage::GetAnimationConsumers()
  95 {
  96   return 0;
  97 }
  98 #endif
  99
 100 nsresult
 101 DynamicImage::OnImageDataAvailable(nsIRequest* aRequest,
 102                                    nsISupports* aContext,
 103                                    nsIInputStream* aInStr,
 104                                    uint64_t aSourceOffset,
 105                                    uint32_t aCount)
 106 {
 107   return NS_OK;
 108 }
 109
 110 nsresult
 111 DynamicImage::OnImageDataComplete(nsIRequest* aRequest,
 112                                   nsISupports* aContext,
 113                                   nsresult aStatus,
 114                                   bool aLastPart)
 115 {
 116   return NS_OK;
 117 }
 118
 119 nsresult
 120 DynamicImage::OnNewSourceData()
 121 {
 122   return NS_OK;
 123 }
 124
 125 void
 126 DynamicImage::SetInnerWindowID(uint64_t aInnerWindowId)
 127 { }
 128
 129 uint64_t
 130 DynamicImage::InnerWindowID() const
 131 {
 132   return 0;
 133 }
 134
 135 bool
 136 DynamicImage::HasError()
 137 {
 138   return !mDrawable;
 139 }
 140
 141 void
 142 DynamicImage::SetHasError()
 143 { }
 144
 145 ImageURL*
 146 DynamicImage::GetURI()
 147 {
 148   return nullptr;
 149 }
 150
 151 // Methods inherited from XPCOM interfaces.
 152
 153 NS_IMPL_ISUPPORTS(DynamicImage, imgIContainer)
 154
 155 NS_IMETHODIMP
 156 DynamicImage::GetWidth(int32_t* aWidth)
 157 {
 158   *aWidth = mDrawable->Size().width;
 159   return NS_OK;
 160 }
 161
 162 NS_IMETHODIMP
 163 DynamicImage::GetHeight(int32_t* aHeight)
 164 {
 165   *aHeight = mDrawable->Size().height;
 166   return NS_OK;
 167 }
 168
 169 NS_IMETHODIMP
 170 DynamicImage::GetIntrinsicSize(nsSize* aSize)
 171 {
 172   gfxIntSize intSize(mDrawable->Size());
 173   *aSize = nsSize(intSize.width, intSize.height);
 174   return NS_OK;
 175 }
 176
 177 NS_IMETHODIMP
 178 DynamicImage::GetIntrinsicRatio(nsSize* aSize)
 179 {
 180   gfxIntSize intSize(mDrawable->Size());
 181   *aSize = nsSize(intSize.width, intSize.height);
 182   return NS_OK;
 183 }
 184
 185 NS_IMETHODIMP_(Orientation)
 186 DynamicImage::GetOrientation()
 187 {
 188   return Orientation();
 189 }
 190
 191 NS_IMETHODIMP
 192 DynamicImage::GetType(uint16_t* aType)
 193 {
 194   *aType = imgIContainer::TYPE_RASTER;
 195   return NS_OK;
 196 }
 197
 198 NS_IMETHODIMP_(uint16_t)
 199 DynamicImage::GetType()
 200 {
 201   return imgIContainer::TYPE_RASTER;
 202 }
 203
 204 NS_IMETHODIMP
 205 DynamicImage::GetAnimated(bool* aAnimated)
 206 {
 207   *aAnimated = false;
 208   return NS_OK;
 209 }
 210
 211 NS_IMETHODIMP_(TemporaryRef<SourceSurface>)
 212 DynamicImage::GetFrame(uint32_t aWhichFrame,
 213                        uint32_t aFlags)
 214 {
 215   gfxIntSize size(mDrawable->Size());
 216
 217   RefPtr<DrawTarget> dt = gfxPlatform::GetPlatform()->
 218     CreateOffscreenContentDrawTarget(IntSize(size.width, size.height),
 219                                      SurfaceFormat::B8G8R8A8);
 220   nsRefPtr<gfxContext> context = new gfxContext(dt);
 221
 222   nsresult rv = Draw(context, size, ImageRegion::Create(size),
 223                      aWhichFrame, GraphicsFilter::FILTER_NEAREST,
 224                      Nothing(), aFlags);
 225
 226   NS_ENSURE_SUCCESS(rv, nullptr);
 227   return dt->Snapshot();
 228 }
 229
 230 NS_IMETHODIMP_(bool)
 231 DynamicImage::FrameIsOpaque(uint32_t aWhichFrame)
 232 {
 233   // XXX(seth): For performance reasons it'd be better to return true here, but
 234   // I'm not sure how we can guarantee it for an arbitrary gfxDrawable.
 235   return false;
 236 }
 237
 238 NS_IMETHODIMP
 239 DynamicImage::GetImageContainer(LayerManager* aManager, ImageContainer** _retval)
 240 {
 241   *_retval = nullptr;
 242   return NS_OK;
 243 }
 244
 245 NS_IMETHODIMP
 246 DynamicImage::Draw(gfxContext* aContext,
 247                    const nsIntSize& aSize,
 248                    const ImageRegion& aRegion,
 249                    uint32_t aWhichFrame,
 250                    GraphicsFilter aFilter,
 251                    const Maybe<SVGImageContext>& aSVGContext,
 252                    uint32_t aFlags)
 253 {
 254   MOZ_ASSERT(!aSize.IsEmpty(), "Unexpected empty size");
 255
 256   gfxIntSize drawableSize(mDrawable->Size());
 257
 258   if (aSize == drawableSize) {
 259     gfxUtils::DrawPixelSnapped(aContext, mDrawable, drawableSize, aRegion,
 260                                SurfaceFormat::B8G8R8A8, aFilter);
 261     return NS_OK;
 262   }
 263
 264   gfxSize scale(double(aSize.width) / drawableSize.width,
 265                 double(aSize.height) / drawableSize.height);
 266
 267   ImageRegion region(aRegion);
 268   region.Scale(1.0 / scale.width, 1.0 / scale.height);
 269
 270   gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
 271   aContext->Multiply(gfxMatrix::Scaling(scale.width, scale.height));
 272
 273   gfxUtils::DrawPixelSnapped(aContext, mDrawable, drawableSize, region,
 274                              SurfaceFormat::B8G8R8A8, aFilter);
 275   return NS_OK;
 276 }
 277
 278 NS_IMETHODIMP
 279 DynamicImage::RequestDecode()
 280 {
 281   return NS_OK;
 282 }
 283
 284 NS_IMETHODIMP
 285 DynamicImage::StartDecoding()
 286 {
 287   return NS_OK;
 288 }
 289
 290 bool
 291 DynamicImage::IsDecoded()
 292 {
 293   return true;
 294 }
 295
 296 NS_IMETHODIMP
 297 DynamicImage::LockImage()
 298 {
 299   return NS_OK;
 300 }
 301
 302 NS_IMETHODIMP
 303 DynamicImage::UnlockImage()
 304 {
 305   return NS_OK;
 306 }
 307
 308 NS_IMETHODIMP
 309 DynamicImage::RequestDiscard()
 310 {
 311   return NS_OK;
 312 }
 313
 314 NS_IMETHODIMP_(void)
 315 DynamicImage::RequestRefresh(const mozilla::TimeStamp& aTime)
 316 { }
 317
 318 NS_IMETHODIMP
 319 DynamicImage::GetAnimationMode(uint16_t* aAnimationMode)
 320 {
 321   *aAnimationMode = kNormalAnimMode;
 322   return NS_OK;
 323 }
 324
 325 NS_IMETHODIMP
 326 DynamicImage::SetAnimationMode(uint16_t aAnimationMode)
 327 {
 328   return NS_OK;
 329 }
 330
 331 NS_IMETHODIMP
 332 DynamicImage::ResetAnimation()
 333 {
 334   return NS_OK;
 335 }
 336
 337 NS_IMETHODIMP_(float)
 338 DynamicImage::GetFrameIndex(uint32_t aWhichFrame)
 339 {
 340   return 0;
 341 }
 342
 343 NS_IMETHODIMP_(int32_t)
 344 DynamicImage::GetFirstFrameDelay()
 345 {
 346   return 0;
 347 }
 348
 349 NS_IMETHODIMP_(void)
 350 DynamicImage::SetAnimationStartTime(const mozilla::TimeStamp& aTime)
 351 { }
 352
 353 nsIntSize
 354 DynamicImage::OptimalImageSizeForDest(const gfxSize& aDest, uint32_t aWhichFrame, GraphicsFilter aFilter, uint32_t aFlags)
 355 {
 356   gfxIntSize size(mDrawable->Size());
 357   return nsIntSize(size.width, size.height);
 358 }
 359
 360 NS_IMETHODIMP_(nsIntRect)
 361 DynamicImage::GetImageSpaceInvalidationRect(const nsIntRect& aRect)
 362 {
 363   return aRect;
 364 }
 365
 366 already_AddRefed<imgIContainer>
 367 DynamicImage::Unwrap()
 368 {
 369   nsCOMPtr<imgIContainer> self(this);
 370   return self.forget();
 371 }
 372
 373 } // namespace image
 374 } // namespace mozilla