import changes from wicknix/Arctic-Fox:

- backport of Bug 1188696 - Remove the XPCOM dependencies in nsRefPtr.h (6c2860799) - backport of Bug 1188696 - Hoist nsRefPtr.h into MFBT (e892acb58) - Backport of Bug 1138967 - Part 3: Add D3D11 YCbCr texture clients and upload on the client side (2e4218167) - Bug 1038536 - Flatten image/src/ directory (3adb2d635) - Bug 1038536 - Flatten image/public/ directory (22329f3b4) - Bug 1038536 - Flatten image/decoders/icon/qt/public/ directory. (7b5b8b2af) - Bug 1038536 - Update header guard after flatten image/build (20e1614ac) - Bug 1116905 - part 2 - add MakeAndAddRef helper function to facilitate constructing TemporaryRef (9c85f45a0) - update (ab2c6eccf) - Bug 1139781 - Implement VideoPlaybackQuality for MediaCodecReader. (1a7c6c0a7) - Bug 1138825 - Fix the crash at mAudioPromise: call decode audio data when the audio queue is empty and check the mAudioPromise is empty or not. (3f5d3a1c5) - Bug 875247 - Add support for DXVA2 via D3D11 (2ca491206) - Bug 1145513 - Upload YCbCr image data on the client side when using d3d9 layers. (50f7a69fa) - Bug 1053563 - Use a static create function to replace InitWith for TextureClient. (dd1c8fc89) - Bug 1145764 - Add some default-disabled logging to TextureClientPool (1cfc0d1b9) - Bug 1120780 - Fallback on lock_ycbcr when ColorConvertor fails (3a9b893f0) - Bug 1161815: Use a single ID2D1SolidColorBrush per DrawTarget. (a70b72ef6) - Bug 1160485 - remove implicit conversion from RefPtr<T> to TemporaryR…ef<T>; (e6e6224c5) - Bug 1116905 - part 3 - remove dependence on implicit conversion from T* to TemporaryRef<T>, gfx changes; (f71d3ffa8) - Bug 1116905 - part 1 - remove dependence on implicit conversion from T* to TemporaryRef<T>, non-gfx changes; (f66714955) - implement Event.srcElement as alias (6c1ee1c6d) - 1116905 - part 4 - remove implicit conversion from non-nullptr T* to TemporaryRef<T> (f94c680f9) - Bug 1031152 - Define a JS public API for working with SavedFrame instances (2aa41721a) - Update TLD's from ESR 60 (b9dbe0ca3) with some changes to fix building, reported to upstream: - https://github.com/wicknix/Arctic-Fox/commit/2e421816773b6a57502907ab22c285d994d8b024#r31893045 - https://github.com/wicknix/Arctic-Fox/commit/50f7a69fa9a36634aef1ae5a221415ca98284435#r31892913 - https://github.com/wicknix/Arctic-Fox/commit/f667149556ae0e64c9dbce08836bb5d957db2464#r31892928
2026-05-26 14:18:48 +00:00 · 2019-01-10 15:30:35 +08:00
parent ba81dbdaa6
commit cbd579ebc8
268 changed files with 6505 additions and 2083 deletions
@@ -0,0 +1,343 @@
+/* -*- 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.
+
+nsresult
+DynamicImage::Init(const char* aMimeType, uint32_t aFlags)
+{
+  return NS_OK;
+}
+
+already_AddRefed<ProgressTracker>
+DynamicImage::GetProgressTracker()
+{
+  return nullptr;
+}
+
+size_t
+DynamicImage::SizeOfSourceWithComputedFallback(MallocSizeOf aMallocSizeOf) const
+{
+  return 0;
+}
+
+size_t
+DynamicImage::SizeOfDecoded(gfxMemoryLocation aLocation,
+                            MallocSizeOf aMallocSizeOf) const
+{
+  // We don't know the answer since gfxDrawable doesn't expose this information.
+  return 0;
+}
+
+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)
+{
+  gfxIntSize intSize(mDrawable->Size());
+  *aSize = nsSize(intSize.width, intSize.height);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DynamicImage::GetIntrinsicRatio(nsSize* aSize)
+{
+  gfxIntSize 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_(uint16_t)
+DynamicImage::GetType()
+{
+  return imgIContainer::TYPE_RASTER;
+}
+
+NS_IMETHODIMP
+DynamicImage::GetAnimated(bool* aAnimated)
+{
+  *aAnimated = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP_(TemporaryRef<SourceSurface>)
+DynamicImage::GetFrame(uint32_t aWhichFrame,
+                       uint32_t aFlags)
+{
+  gfxIntSize size(mDrawable->Size());
+
+  RefPtr<DrawTarget> dt = gfxPlatform::GetPlatform()->
+    CreateOffscreenContentDrawTarget(IntSize(size.width, size.height),
+                                     SurfaceFormat::B8G8R8A8);
+  nsRefPtr<gfxContext> context = new gfxContext(dt);
+
+  auto result = Draw(context, size, ImageRegion::Create(size),
+                     aWhichFrame, GraphicsFilter::FILTER_NEAREST,
+                     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
+DynamicImage::GetImageContainer(LayerManager* aManager,
+                                ImageContainer** _retval)
+{
+  *_retval = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP_(DrawResult)
+DynamicImage::Draw(gfxContext* aContext,
+                   const nsIntSize& aSize,
+                   const ImageRegion& aRegion,
+                   uint32_t aWhichFrame,
+                   GraphicsFilter aFilter,
+                   const Maybe<SVGImageContext>& aSVGContext,
+                   uint32_t aFlags)
+{
+  MOZ_ASSERT(!aSize.IsEmpty(), "Unexpected empty size");
+
+  gfxIntSize 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::RequestDecode()
+{
+  return NS_OK;
+}
+
+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,
+                                      GraphicsFilter aFilter, uint32_t aFlags)
+{
+  gfxIntSize 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();
+}
+
+} // namespace image
+} // namespace mozilla