summaryrefslogtreecommitdiffstats
path: root/image/ImageOps.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /image/ImageOps.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'image/ImageOps.cpp')
-rw-r--r--image/ImageOps.cpp248
1 files changed, 248 insertions, 0 deletions
diff --git a/image/ImageOps.cpp b/image/ImageOps.cpp
new file mode 100644
index 0000000000..875dc7b985
--- /dev/null
+++ b/image/ImageOps.cpp
@@ -0,0 +1,248 @@
+/* -*- 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 "ImageOps.h"
+
+#include "ClippedImage.h"
+#include "Decoder.h"
+#include "DecoderFactory.h"
+#include "DynamicImage.h"
+#include "FrozenImage.h"
+#include "IDecodingTask.h"
+#include "Image.h"
+#include "ImageMetadata.h"
+#include "imgIContainer.h"
+#include "mozilla/gfx/2D.h"
+#include "nsNetUtil.h" // for NS_NewBufferedInputStream
+#include "nsStreamUtils.h"
+#include "OrientedImage.h"
+#include "SourceBuffer.h"
+
+using namespace mozilla::gfx;
+
+namespace mozilla::image {
+
+/* static */
+already_AddRefed<Image> ImageOps::Freeze(Image* aImage) {
+ RefPtr<Image> frozenImage = new FrozenImage(aImage);
+ return frozenImage.forget();
+}
+
+/* static */
+already_AddRefed<imgIContainer> ImageOps::Freeze(imgIContainer* aImage) {
+ nsCOMPtr<imgIContainer> frozenImage =
+ new FrozenImage(static_cast<Image*>(aImage));
+ return frozenImage.forget();
+}
+
+/* static */
+already_AddRefed<Image> ImageOps::Clip(Image* aImage, nsIntRect aClip,
+ const Maybe<nsSize>& aSVGViewportSize) {
+ RefPtr<Image> clippedImage =
+ new ClippedImage(aImage, aClip, aSVGViewportSize);
+ return clippedImage.forget();
+}
+
+/* static */
+already_AddRefed<imgIContainer> ImageOps::Clip(
+ imgIContainer* aImage, nsIntRect aClip,
+ const Maybe<nsSize>& aSVGViewportSize) {
+ nsCOMPtr<imgIContainer> clippedImage =
+ new ClippedImage(static_cast<Image*>(aImage), aClip, aSVGViewportSize);
+ return clippedImage.forget();
+}
+
+/* static */
+already_AddRefed<Image> ImageOps::Orient(Image* aImage,
+ Orientation aOrientation) {
+ if (aOrientation.IsIdentity()) {
+ return do_AddRef(aImage);
+ }
+ RefPtr<Image> image = new OrientedImage(aImage, aOrientation);
+ return image.forget();
+}
+
+/* static */
+already_AddRefed<imgIContainer> ImageOps::Orient(imgIContainer* aImage,
+ Orientation aOrientation) {
+ return Orient(static_cast<Image*>(aImage), aOrientation);
+}
+
+/* static */
+already_AddRefed<imgIContainer> ImageOps::Unorient(imgIContainer* aImage) {
+ return Orient(aImage, aImage->GetOrientation().Reversed());
+}
+
+/* static */
+already_AddRefed<imgIContainer> ImageOps::CreateFromDrawable(
+ gfxDrawable* aDrawable) {
+ nsCOMPtr<imgIContainer> drawableImage = new DynamicImage(aDrawable);
+ return drawableImage.forget();
+}
+
+class ImageOps::ImageBufferImpl final : public ImageOps::ImageBuffer {
+ public:
+ explicit ImageBufferImpl(already_AddRefed<SourceBuffer> aSourceBuffer)
+ : mSourceBuffer(aSourceBuffer) {}
+
+ protected:
+ ~ImageBufferImpl() override {}
+
+ already_AddRefed<SourceBuffer> GetSourceBuffer() const override {
+ RefPtr<SourceBuffer> sourceBuffer = mSourceBuffer;
+ return sourceBuffer.forget();
+ }
+
+ private:
+ RefPtr<SourceBuffer> mSourceBuffer;
+};
+
+/* static */ already_AddRefed<ImageOps::ImageBuffer>
+ImageOps::CreateImageBuffer(already_AddRefed<nsIInputStream> aInputStream) {
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
+ MOZ_ASSERT(inputStream);
+
+ nsresult rv;
+
+ // Prepare the input stream.
+ if (!NS_InputStreamIsBuffered(inputStream)) {
+ nsCOMPtr<nsIInputStream> bufStream;
+ rv = NS_NewBufferedInputStream(getter_AddRefs(bufStream),
+ inputStream.forget(), 1024);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return nullptr;
+ }
+ inputStream = std::move(bufStream);
+ }
+
+ // Figure out how much data we've been passed.
+ uint64_t length;
+ rv = inputStream->Available(&length);
+ if (NS_FAILED(rv) || length > UINT32_MAX) {
+ return nullptr;
+ }
+
+ // Write the data into a SourceBuffer.
+ RefPtr<SourceBuffer> sourceBuffer = new SourceBuffer();
+ sourceBuffer->ExpectLength(length);
+ rv = sourceBuffer->AppendFromInputStream(inputStream, length);
+ if (NS_FAILED(rv)) {
+ return nullptr;
+ }
+ // Make sure our sourceBuffer is marked as complete.
+ if (sourceBuffer->IsComplete()) {
+ NS_WARNING(
+ "The SourceBuffer was unexpectedly marked as complete. This may "
+ "indicate either an OOM condition, or that imagelib was not "
+ "initialized properly.");
+ return nullptr;
+ }
+ sourceBuffer->Complete(NS_OK);
+
+ RefPtr<ImageBuffer> imageBuffer = new ImageBufferImpl(sourceBuffer.forget());
+ return imageBuffer.forget();
+}
+
+/* static */
+nsresult ImageOps::DecodeMetadata(already_AddRefed<nsIInputStream> aInputStream,
+ const nsACString& aMimeType,
+ ImageMetadata& aMetadata) {
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
+ RefPtr<ImageBuffer> buffer = CreateImageBuffer(inputStream.forget());
+ return DecodeMetadata(buffer, aMimeType, aMetadata);
+}
+
+/* static */
+nsresult ImageOps::DecodeMetadata(ImageBuffer* aBuffer,
+ const nsACString& aMimeType,
+ ImageMetadata& aMetadata) {
+ if (!aBuffer) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<SourceBuffer> sourceBuffer = aBuffer->GetSourceBuffer();
+ if (NS_WARN_IF(!sourceBuffer)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Create a decoder.
+ DecoderType decoderType =
+ DecoderFactory::GetDecoderType(PromiseFlatCString(aMimeType).get());
+ RefPtr<Decoder> decoder = DecoderFactory::CreateAnonymousMetadataDecoder(
+ decoderType, WrapNotNull(sourceBuffer));
+ if (!decoder) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Run the decoder synchronously.
+ RefPtr<IDecodingTask> task =
+ new AnonymousDecodingTask(WrapNotNull(decoder), /* aResumable */ false);
+ task->Run();
+ if (!decoder->GetDecodeDone() || decoder->HasError()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ aMetadata = decoder->GetImageMetadata();
+ if (aMetadata.GetNativeSizes().IsEmpty() && aMetadata.HasSize()) {
+ aMetadata.AddNativeSize(aMetadata.GetSize());
+ }
+
+ return NS_OK;
+}
+
+/* static */ already_AddRefed<gfx::SourceSurface> ImageOps::DecodeToSurface(
+ already_AddRefed<nsIInputStream> aInputStream, const nsACString& aMimeType,
+ uint32_t aFlags, const Maybe<IntSize>& aSize /* = Nothing() */) {
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
+ RefPtr<ImageBuffer> buffer = CreateImageBuffer(inputStream.forget());
+ return DecodeToSurface(buffer, aMimeType, aFlags, aSize);
+}
+
+/* static */ already_AddRefed<gfx::SourceSurface> ImageOps::DecodeToSurface(
+ ImageBuffer* aBuffer, const nsACString& aMimeType, uint32_t aFlags,
+ const Maybe<IntSize>& aSize /* = Nothing() */) {
+ if (!aBuffer) {
+ return nullptr;
+ }
+
+ RefPtr<SourceBuffer> sourceBuffer = aBuffer->GetSourceBuffer();
+ if (NS_WARN_IF(!sourceBuffer)) {
+ return nullptr;
+ }
+
+ // Create a decoder.
+ DecoderType decoderType =
+ DecoderFactory::GetDecoderType(PromiseFlatCString(aMimeType).get());
+ RefPtr<Decoder> decoder = DecoderFactory::CreateAnonymousDecoder(
+ decoderType, WrapNotNull(sourceBuffer), aSize,
+ DecoderFlags::FIRST_FRAME_ONLY, ToSurfaceFlags(aFlags));
+ if (!decoder) {
+ return nullptr;
+ }
+
+ // Run the decoder synchronously.
+ RefPtr<IDecodingTask> task =
+ new AnonymousDecodingTask(WrapNotNull(decoder), /* aResumable */ false);
+ task->Run();
+ if (!decoder->GetDecodeDone() || decoder->HasError()) {
+ return nullptr;
+ }
+
+ // Pull out the surface.
+ RawAccessFrameRef frame = decoder->GetCurrentFrameRef();
+ if (!frame) {
+ return nullptr;
+ }
+
+ RefPtr<SourceSurface> surface = frame->GetSourceSurface();
+ if (!surface) {
+ return nullptr;
+ }
+
+ return surface.forget();
+}
+
+} // namespace mozilla::image