From 0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 03:47:29 +0200 Subject: Adding upstream version 115.8.0esr. Signed-off-by: Daniel Baumann --- image/encoders/webp/moz.build | 15 ++ image/encoders/webp/nsWebPEncoder.cpp | 342 ++++++++++++++++++++++++++++++++++ image/encoders/webp/nsWebPEncoder.h | 63 +++++++ 3 files changed, 420 insertions(+) create mode 100644 image/encoders/webp/moz.build create mode 100644 image/encoders/webp/nsWebPEncoder.cpp create mode 100644 image/encoders/webp/nsWebPEncoder.h (limited to 'image/encoders/webp') diff --git a/image/encoders/webp/moz.build b/image/encoders/webp/moz.build new file mode 100644 index 0000000000..4363caa79f --- /dev/null +++ b/image/encoders/webp/moz.build @@ -0,0 +1,15 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +SOURCES += [ + "nsWebPEncoder.cpp", +] + +LOCAL_INCLUDES += [ + "/image", +] + +FINAL_LIBRARY = "xul" diff --git a/image/encoders/webp/nsWebPEncoder.cpp b/image/encoders/webp/nsWebPEncoder.cpp new file mode 100644 index 0000000000..72ac1388e9 --- /dev/null +++ b/image/encoders/webp/nsWebPEncoder.cpp @@ -0,0 +1,342 @@ +/* -*- 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 "ImageLogging.h" +#include "nsCRT.h" +#include "nsWebPEncoder.h" +#include "nsStreamUtils.h" +#include "nsString.h" +#include "prprf.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/UniquePtrExtensions.h" + +using namespace mozilla; + +// static LazyLogModule sWEBPEncoderLog("WEBPEncoder"); + +NS_IMPL_ISUPPORTS(nsWebPEncoder, imgIEncoder, nsIInputStream, + nsIAsyncInputStream) + +nsWebPEncoder::nsWebPEncoder() + : mFinished(false), + mImageBuffer(nullptr), + mImageBufferSize(0), + mImageBufferUsed(0), + mImageBufferReadPoint(0), + mCallback(nullptr), + mCallbackTarget(nullptr), + mNotifyThreshold(0), + mReentrantMonitor("nsWebPEncoder.mReentrantMonitor") {} + +nsWebPEncoder::~nsWebPEncoder() { + if (mImageBuffer) { + WebPFree(mImageBuffer); + mImageBuffer = nullptr; + mImageBufferSize = 0; + mImageBufferUsed = 0; + mImageBufferReadPoint = 0; + } +} + +// nsWebPEncoder::InitFromData +// +// One output option is supported: "quality=X" where X is an integer in the +// range 0-100. Higher values for X give better quality. + +NS_IMETHODIMP +nsWebPEncoder::InitFromData(const uint8_t* aData, + uint32_t aLength, // (unused, req'd by JS) + uint32_t aWidth, uint32_t aHeight, uint32_t aStride, + uint32_t aInputFormat, + const nsAString& aOutputOptions) { + NS_ENSURE_ARG(aData); + + // validate input format + if (aInputFormat != INPUT_FORMAT_RGB && aInputFormat != INPUT_FORMAT_RGBA && + aInputFormat != INPUT_FORMAT_HOSTARGB) + return NS_ERROR_INVALID_ARG; + + // Stride is the padded width of each row, so it better be longer (I'm afraid + // people will not understand what stride means, so check it well) + if ((aInputFormat == INPUT_FORMAT_RGB && aStride < aWidth * 3) || + ((aInputFormat == INPUT_FORMAT_RGBA || + aInputFormat == INPUT_FORMAT_HOSTARGB) && + aStride < aWidth * 4)) { + NS_WARNING("Invalid stride for InitFromData"); + return NS_ERROR_INVALID_ARG; + } + + // can't initialize more than once + if (mImageBuffer != nullptr) { + return NS_ERROR_ALREADY_INITIALIZED; + } + + // options: we only have one option so this is easy + int quality = 92; + if (aOutputOptions.Length() > 0) { + // have options string + const nsString qualityPrefix(u"quality="_ns); + if (aOutputOptions.Length() > qualityPrefix.Length() && + StringBeginsWith(aOutputOptions, qualityPrefix)) { + // have quality string + nsCString value = NS_ConvertUTF16toUTF8( + Substring(aOutputOptions, qualityPrefix.Length())); + int newquality = -1; + if (PR_sscanf(value.get(), "%d", &newquality) == 1) { + if (newquality >= 0 && newquality <= 100) { + quality = newquality; + } else { + NS_WARNING( + "Quality value out of range, should be 0-100," + " using default"); + } + } else { + NS_WARNING( + "Quality value invalid, should be integer 0-100," + " using default"); + } + } else { + return NS_ERROR_INVALID_ARG; + } + } + + size_t size = 0; + + CheckedInt32 width = CheckedInt32(aWidth); + CheckedInt32 height = CheckedInt32(aHeight); + CheckedInt32 stride = CheckedInt32(aStride); + if (!width.isValid() || !height.isValid() || !stride.isValid() || + !(CheckedUint32(aStride) * CheckedUint32(aHeight)).isValid()) { + return NS_ERROR_INVALID_ARG; + } + + if (aInputFormat == INPUT_FORMAT_RGB) { + size = quality == 100 + ? WebPEncodeLosslessRGB(aData, width.value(), height.value(), + stride.value(), &mImageBuffer) + : WebPEncodeRGB(aData, width.value(), height.value(), + stride.value(), quality, &mImageBuffer); + } else if (aInputFormat == INPUT_FORMAT_RGBA) { + size = quality == 100 + ? WebPEncodeLosslessRGBA(aData, width.value(), height.value(), + stride.value(), &mImageBuffer) + : WebPEncodeRGBA(aData, width.value(), height.value(), + stride.value(), quality, &mImageBuffer); + } else if (aInputFormat == INPUT_FORMAT_HOSTARGB) { + UniquePtr aDest = + MakeUniqueFallible(aStride * aHeight); + if (NS_WARN_IF(!aDest)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + for (uint32_t y = 0; y < aHeight; y++) { + for (uint32_t x = 0; x < aWidth; x++) { + const uint32_t& pixelIn = + ((const uint32_t*)(aData))[y * aStride / 4 + x]; + uint8_t* pixelOut = &aDest[y * aStride + x * 4]; + + uint8_t alpha = (pixelIn & 0xff000000) >> 24; + pixelOut[3] = alpha; + if (alpha == 255) { + pixelOut[0] = (pixelIn & 0xff0000) >> 16; + pixelOut[1] = (pixelIn & 0x00ff00) >> 8; + pixelOut[2] = (pixelIn & 0x0000ff); + } else if (alpha == 0) { + pixelOut[0] = pixelOut[1] = pixelOut[2] = 0; + } else { + pixelOut[0] = + (((pixelIn & 0xff0000) >> 16) * 255 + alpha / 2) / alpha; + pixelOut[1] = (((pixelIn & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha; + pixelOut[2] = (((pixelIn & 0x0000ff)) * 255 + alpha / 2) / alpha; + } + } + } + + size = + quality == 100 + ? WebPEncodeLosslessRGBA(aDest.get(), width.value(), height.value(), + stride.value(), &mImageBuffer) + : WebPEncodeRGBA(aDest.get(), width.value(), height.value(), + stride.value(), quality, &mImageBuffer); + } + + mFinished = true; + + if (size == 0) { + return NS_ERROR_FAILURE; + } + + mImageBufferUsed = size; + + return NS_OK; +} + +// nsWebPEncoder::StartImageEncode +// +// +// See ::InitFromData for other info. +NS_IMETHODIMP +nsWebPEncoder::StartImageEncode(uint32_t aWidth, uint32_t aHeight, + uint32_t aInputFormat, + const nsAString& aOutputOptions) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +// Returns the number of bytes in the image buffer used. +NS_IMETHODIMP +nsWebPEncoder::GetImageBufferUsed(uint32_t* aOutputSize) { + NS_ENSURE_ARG_POINTER(aOutputSize); + *aOutputSize = mImageBufferUsed; + return NS_OK; +} + +// Returns a pointer to the start of the image buffer +NS_IMETHODIMP +nsWebPEncoder::GetImageBuffer(char** aOutputBuffer) { + NS_ENSURE_ARG_POINTER(aOutputBuffer); + *aOutputBuffer = reinterpret_cast(mImageBuffer); + return NS_OK; +} + +NS_IMETHODIMP +nsWebPEncoder::AddImageFrame(const uint8_t* aData, + uint32_t aLength, // (unused, req'd by JS) + uint32_t aWidth, uint32_t aHeight, + uint32_t aStride, uint32_t aInputFormat, + const nsAString& aFrameOptions) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsWebPEncoder::EndImageEncode() { return NS_ERROR_NOT_IMPLEMENTED; } + +NS_IMETHODIMP +nsWebPEncoder::Close() { + if (mImageBuffer) { + WebPFree(mImageBuffer); + mImageBuffer = nullptr; + mImageBufferSize = 0; + mImageBufferUsed = 0; + mImageBufferReadPoint = 0; + } + return NS_OK; +} + +NS_IMETHODIMP +nsWebPEncoder::Available(uint64_t* _retval) { + if (!mImageBuffer) { + return NS_BASE_STREAM_CLOSED; + } + + *_retval = mImageBufferUsed - mImageBufferReadPoint; + return NS_OK; +} + +NS_IMETHODIMP +nsWebPEncoder::StreamStatus() { + return mImageBuffer ? NS_OK : NS_BASE_STREAM_CLOSED; +} + +NS_IMETHODIMP +nsWebPEncoder::Read(char* aBuf, uint32_t aCount, uint32_t* _retval) { + return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, _retval); +} + +NS_IMETHODIMP +nsWebPEncoder::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* _retval) { + // Avoid another thread reallocing the buffer underneath us + ReentrantMonitorAutoEnter autoEnter(mReentrantMonitor); + + uint32_t maxCount = mImageBufferUsed - mImageBufferReadPoint; + if (maxCount == 0) { + *_retval = 0; + return mFinished ? NS_OK : NS_BASE_STREAM_WOULD_BLOCK; + } + + if (aCount > maxCount) { + aCount = maxCount; + } + nsresult rv = aWriter( + this, aClosure, + reinterpret_cast(mImageBuffer + mImageBufferReadPoint), 0, + aCount, _retval); + if (NS_SUCCEEDED(rv)) { + NS_ASSERTION(*_retval <= aCount, "bad write count"); + mImageBufferReadPoint += *_retval; + } + + // errors returned from the writer end here! + return NS_OK; +} + +NS_IMETHODIMP +nsWebPEncoder::IsNonBlocking(bool* _retval) { + *_retval = true; + return NS_OK; +} + +NS_IMETHODIMP +nsWebPEncoder::AsyncWait(nsIInputStreamCallback* aCallback, uint32_t aFlags, + uint32_t aRequestedCount, nsIEventTarget* aTarget) { + if (aFlags != 0) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + if (mCallback || mCallbackTarget) { + return NS_ERROR_UNEXPECTED; + } + + mCallbackTarget = aTarget; + // 0 means "any number of bytes except 0" + mNotifyThreshold = aRequestedCount; + if (!aRequestedCount) { + mNotifyThreshold = 1024; // 1 KB seems good. We don't want to + // notify incessantly + } + + // We set the callback absolutely last, because NotifyListener uses it to + // determine if someone needs to be notified. If we don't set it last, + // NotifyListener might try to fire off a notification to a null target + // which will generally cause non-threadsafe objects to be used off the + // main thread + mCallback = aCallback; + + // What we are being asked for may be present already + NotifyListener(); + return NS_OK; +} + +NS_IMETHODIMP +nsWebPEncoder::CloseWithStatus(nsresult aStatus) { return Close(); } + +void nsWebPEncoder::NotifyListener() { + // We might call this function on multiple threads (any threads that call + // AsyncWait and any that do encoding) so we lock to avoid notifying the + // listener twice about the same data (which generally leads to a truncated + // image). + ReentrantMonitorAutoEnter autoEnter(mReentrantMonitor); + + if (mCallback && + (mImageBufferUsed - mImageBufferReadPoint >= mNotifyThreshold || + mFinished)) { + nsCOMPtr callback; + if (mCallbackTarget) { + callback = NS_NewInputStreamReadyEvent("nsWebPEncoder::NotifyListener", + mCallback, mCallbackTarget); + } else { + callback = mCallback; + } + + NS_ASSERTION(callback, "Shouldn't fail to make the callback"); + // Null the callback first because OnInputStreamReady could reenter + // AsyncWait + mCallback = nullptr; + mCallbackTarget = nullptr; + mNotifyThreshold = 0; + + callback->OnInputStreamReady(this); + } +} diff --git a/image/encoders/webp/nsWebPEncoder.h b/image/encoders/webp/nsWebPEncoder.h new file mode 100644 index 0000000000..8628d12388 --- /dev/null +++ b/image/encoders/webp/nsWebPEncoder.h @@ -0,0 +1,63 @@ +/* -*- 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/. */ + +#ifndef mozilla_image_encoders_webp_nsWebPEncoder_h +#define mozilla_image_encoders_webp_nsWebPEncoder_h + +#include "webp/encode.h" + +#include "imgIEncoder.h" +#include "nsCOMPtr.h" + +#include "mozilla/Attributes.h" +#include "mozilla/ReentrantMonitor.h" + +#define NS_WEBPENCODER_CID \ + { /* a8e5a8e5-bebf-4512-9f50-e41e4748ce28 */ \ + 0xa8e5a8e5, 0xbebf, 0x4512, { \ + 0x9f, 0x50, 0xe4, 0x1e, 0x47, 0x48, 0xce, 0x28 \ + } \ + } + +// Provides WEBP encoding functionality. Use InitFromData() to do the +// encoding. See that function definition for encoding options. + +class nsWebPEncoder final : public imgIEncoder { + typedef mozilla::ReentrantMonitor ReentrantMonitor; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_IMGIENCODER + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIASYNCINPUTSTREAM + + nsWebPEncoder(); + + protected: + ~nsWebPEncoder(); + + void NotifyListener(); + + bool mFinished; + + // image buffer + uint8_t* mImageBuffer; + uint32_t mImageBufferSize; + uint32_t mImageBufferUsed; + + uint32_t mImageBufferReadPoint; + + nsCOMPtr mCallback; + nsCOMPtr mCallbackTarget; + uint32_t mNotifyThreshold; + + // nsWebPEncoder is designed to allow one thread to pump data into it while + // another reads from it. We lock to ensure that the buffer remains + // append-only while we read from it (that it is not realloced) and to + // ensure that only one thread dispatches a callback for each call to + // AsyncWait. + ReentrantMonitor mReentrantMonitor MOZ_UNANNOTATED; +}; +#endif // mozilla_image_encoders_webp_nsWebPEncoder_h -- cgit v1.2.3