summaryrefslogtreecommitdiff
path: root/image/imgTools.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /image/imgTools.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloaduxp-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
Add m-esr52 at 52.6.0
Diffstat (limited to 'image/imgTools.cpp')
-rw-r--r--image/imgTools.cpp356
1 files changed, 356 insertions, 0 deletions
diff --git a/image/imgTools.cpp b/image/imgTools.cpp
new file mode 100644
index 0000000000..29905c1ab3
--- /dev/null
+++ b/image/imgTools.cpp
@@ -0,0 +1,356 @@
+/* -*- 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 "imgTools.h"
+
+#include "gfxUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
+#include "nsError.h"
+#include "imgLoader.h"
+#include "imgICache.h"
+#include "imgIContainer.h"
+#include "imgIEncoder.h"
+#include "nsStreamUtils.h"
+#include "nsContentUtils.h"
+#include "ImageFactory.h"
+#include "Image.h"
+#include "ScriptedNotificationObserver.h"
+#include "imgIScriptedNotificationObserver.h"
+#include "gfxPlatform.h"
+
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace image {
+/* ========== imgITools implementation ========== */
+
+
+
+NS_IMPL_ISUPPORTS(imgTools, imgITools)
+
+imgTools::imgTools()
+{
+ /* member initializers and constructor code */
+}
+
+imgTools::~imgTools()
+{
+ /* destructor code */
+}
+
+NS_IMETHODIMP
+imgTools::DecodeImageData(nsIInputStream* aInStr,
+ const nsACString& aMimeType,
+ imgIContainer** aContainer)
+{
+ MOZ_ASSERT(*aContainer == nullptr,
+ "Cannot provide an existing image container to DecodeImageData");
+
+ return DecodeImage(aInStr, aMimeType, aContainer);
+}
+
+NS_IMETHODIMP
+imgTools::DecodeImage(nsIInputStream* aInStr,
+ const nsACString& aMimeType,
+ imgIContainer** aContainer)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsresult rv;
+
+ NS_ENSURE_ARG_POINTER(aInStr);
+
+ // Create a new image container to hold the decoded data.
+ nsAutoCString mimeType(aMimeType);
+ RefPtr<image::Image> image = ImageFactory::CreateAnonymousImage(mimeType);
+ RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
+
+ if (image->HasError()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Prepare the input stream.
+ nsCOMPtr<nsIInputStream> inStream = aInStr;
+ if (!NS_InputStreamIsBuffered(aInStr)) {
+ nsCOMPtr<nsIInputStream> bufStream;
+ rv = NS_NewBufferedInputStream(getter_AddRefs(bufStream), aInStr, 1024);
+ if (NS_SUCCEEDED(rv)) {
+ inStream = bufStream;
+ }
+ }
+
+ // Figure out how much data we've been passed.
+ uint64_t length;
+ rv = inStream->Available(&length);
+ NS_ENSURE_SUCCESS(rv, rv);
+ NS_ENSURE_TRUE(length <= UINT32_MAX, NS_ERROR_FILE_TOO_BIG);
+
+ // Send the source data to the Image.
+ rv = image->OnImageDataAvailable(nullptr, nullptr, inStream, 0,
+ uint32_t(length));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Let the Image know we've sent all the data.
+ rv = image->OnImageDataComplete(nullptr, nullptr, NS_OK, true);
+ tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // All done.
+ NS_ADDREF(*aContainer = image.get());
+ return NS_OK;
+}
+
+/**
+ * This takes a DataSourceSurface rather than a SourceSurface because some
+ * of the callers have a DataSourceSurface and we don't want to call
+ * GetDataSurface on such surfaces since that may incure a conversion to
+ * SurfaceType::DATA which we don't need.
+ */
+static nsresult
+EncodeImageData(DataSourceSurface* aDataSurface,
+ const nsACString& aMimeType,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream)
+{
+ MOZ_ASSERT(aDataSurface->GetFormat() == SurfaceFormat::B8G8R8A8,
+ "We're assuming B8G8R8A8");
+
+ // Get an image encoder for the media type
+ nsAutoCString encoderCID(
+ NS_LITERAL_CSTRING("@mozilla.org/image/encoder;2?type=") + aMimeType);
+
+ nsCOMPtr<imgIEncoder> encoder = do_CreateInstance(encoderCID.get());
+ if (!encoder) {
+ return NS_IMAGELIB_ERROR_NO_ENCODER;
+ }
+
+ DataSourceSurface::MappedSurface map;
+ if (!aDataSurface->Map(DataSourceSurface::MapType::READ, &map)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ IntSize size = aDataSurface->GetSize();
+ uint32_t dataLength = map.mStride * size.height;
+
+ // Encode the bitmap
+ nsresult rv = encoder->InitFromData(map.mData,
+ dataLength,
+ size.width,
+ size.height,
+ map.mStride,
+ imgIEncoder::INPUT_FORMAT_HOSTARGB,
+ aOutputOptions);
+ aDataSurface->Unmap();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ encoder.forget(aStream);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgTools::EncodeImage(imgIContainer* aContainer,
+ const nsACString& aMimeType,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream)
+{
+ // Use frame 0 from the image container.
+ RefPtr<SourceSurface> frame =
+ aContainer->GetFrame(imgIContainer::FRAME_FIRST,
+ imgIContainer::FLAG_SYNC_DECODE);
+ NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
+
+ RefPtr<DataSourceSurface> dataSurface;
+
+ if (frame->GetFormat() == SurfaceFormat::B8G8R8A8) {
+ dataSurface = frame->GetDataSurface();
+ } else {
+ // Convert format to SurfaceFormat::B8G8R8A8
+ dataSurface = gfxUtils::
+ CopySurfaceToDataSourceSurfaceWithFormat(frame,
+ SurfaceFormat::B8G8R8A8);
+ }
+
+ NS_ENSURE_TRUE(dataSurface, NS_ERROR_FAILURE);
+
+ return EncodeImageData(dataSurface, aMimeType, aOutputOptions, aStream);
+}
+
+NS_IMETHODIMP
+imgTools::EncodeScaledImage(imgIContainer* aContainer,
+ const nsACString& aMimeType,
+ int32_t aScaledWidth,
+ int32_t aScaledHeight,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream)
+{
+ NS_ENSURE_ARG(aScaledWidth >= 0 && aScaledHeight >= 0);
+
+ // If no scaled size is specified, we'll just encode the image at its
+ // original size (no scaling).
+ if (aScaledWidth == 0 && aScaledHeight == 0) {
+ return EncodeImage(aContainer, aMimeType, aOutputOptions, aStream);
+ }
+
+ // Retrieve the image's size.
+ int32_t imageWidth = 0;
+ int32_t imageHeight = 0;
+ aContainer->GetWidth(&imageWidth);
+ aContainer->GetHeight(&imageHeight);
+
+ // If the given width or height is zero we'll replace it with the image's
+ // original dimensions.
+ IntSize scaledSize(aScaledWidth == 0 ? imageWidth : aScaledWidth,
+ aScaledHeight == 0 ? imageHeight : aScaledHeight);
+
+ // Use frame 0 from the image container.
+ RefPtr<SourceSurface> frame =
+ aContainer->GetFrameAtSize(scaledSize,
+ imgIContainer::FRAME_FIRST,
+ imgIContainer::FLAG_HIGH_QUALITY_SCALING |
+ imgIContainer::FLAG_SYNC_DECODE);
+ NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
+
+ RefPtr<DataSourceSurface> dataSurface =
+ Factory::CreateDataSourceSurface(scaledSize, SurfaceFormat::B8G8R8A8);
+ if (NS_WARN_IF(!dataSurface)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ DataSourceSurface::MappedSurface map;
+ if (!dataSurface->Map(DataSourceSurface::MapType::WRITE, &map)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<DrawTarget> dt =
+ Factory::CreateDrawTargetForData(BackendType::CAIRO,
+ map.mData,
+ dataSurface->GetSize(),
+ map.mStride,
+ SurfaceFormat::B8G8R8A8);
+ if (!dt) {
+ gfxWarning() << "imgTools::EncodeImage failed in CreateDrawTargetForData";
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ IntSize frameSize = frame->GetSize();
+ dt->DrawSurface(frame,
+ Rect(0, 0, scaledSize.width, scaledSize.height),
+ Rect(0, 0, frameSize.width, frameSize.height),
+ DrawSurfaceOptions(),
+ DrawOptions(1.0f, CompositionOp::OP_SOURCE));
+
+ dataSurface->Unmap();
+
+ return EncodeImageData(dataSurface, aMimeType, aOutputOptions, aStream);
+}
+
+NS_IMETHODIMP
+imgTools::EncodeCroppedImage(imgIContainer* aContainer,
+ const nsACString& aMimeType,
+ int32_t aOffsetX,
+ int32_t aOffsetY,
+ int32_t aWidth,
+ int32_t aHeight,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream)
+{
+ NS_ENSURE_ARG(aOffsetX >= 0 && aOffsetY >= 0 && aWidth >= 0 && aHeight >= 0);
+
+ // Offsets must be zero when no width and height are given or else we're out
+ // of bounds.
+ NS_ENSURE_ARG(aWidth + aHeight > 0 || aOffsetX + aOffsetY == 0);
+
+ // If no size is specified then we'll preserve the image's original dimensions
+ // and don't need to crop.
+ if (aWidth == 0 && aHeight == 0) {
+ return EncodeImage(aContainer, aMimeType, aOutputOptions, aStream);
+ }
+
+ // Use frame 0 from the image container.
+ RefPtr<SourceSurface> frame =
+ aContainer->GetFrame(imgIContainer::FRAME_FIRST,
+ imgIContainer::FLAG_SYNC_DECODE);
+ NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
+
+ int32_t frameWidth = frame->GetSize().width;
+ int32_t frameHeight = frame->GetSize().height;
+
+ // If the given width or height is zero we'll replace it with the image's
+ // original dimensions.
+ if (aWidth == 0) {
+ aWidth = frameWidth;
+ } else if (aHeight == 0) {
+ aHeight = frameHeight;
+ }
+
+ // Check that the given crop rectangle is within image bounds.
+ NS_ENSURE_ARG(frameWidth >= aOffsetX + aWidth &&
+ frameHeight >= aOffsetY + aHeight);
+
+ RefPtr<DataSourceSurface> dataSurface =
+ Factory::CreateDataSourceSurface(IntSize(aWidth, aHeight),
+ SurfaceFormat::B8G8R8A8,
+ /* aZero = */ true);
+ if (NS_WARN_IF(!dataSurface)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ DataSourceSurface::MappedSurface map;
+ if (!dataSurface->Map(DataSourceSurface::MapType::WRITE, &map)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<DrawTarget> dt =
+ Factory::CreateDrawTargetForData(BackendType::CAIRO,
+ map.mData,
+ dataSurface->GetSize(),
+ map.mStride,
+ SurfaceFormat::B8G8R8A8);
+ if (!dt) {
+ gfxWarning() <<
+ "imgTools::EncodeCroppedImage failed in CreateDrawTargetForData";
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ dt->CopySurface(frame,
+ IntRect(aOffsetX, aOffsetY, aWidth, aHeight),
+ IntPoint(0, 0));
+
+ dataSurface->Unmap();
+
+ return EncodeImageData(dataSurface, aMimeType, aOutputOptions, aStream);
+}
+
+NS_IMETHODIMP
+imgTools::CreateScriptedObserver(imgIScriptedNotificationObserver* aInner,
+ imgINotificationObserver** aObserver)
+{
+ NS_ADDREF(*aObserver = new ScriptedNotificationObserver(aInner));
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgTools::GetImgLoaderForDocument(nsIDOMDocument* aDoc, imgILoader** aLoader)
+{
+ nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
+ NS_IF_ADDREF(*aLoader = nsContentUtils::GetImgLoaderForDocument(doc));
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgTools::GetImgCacheForDocument(nsIDOMDocument* aDoc, imgICache** aCache)
+{
+ nsCOMPtr<imgILoader> loader;
+ nsresult rv = GetImgLoaderForDocument(aDoc, getter_AddRefs(loader));
+ NS_ENSURE_SUCCESS(rv, rv);
+ return CallQueryInterface(loader, aCache);
+}
+
+} // namespace image
+} // namespace mozilla