summaryrefslogtreecommitdiffstats
path: root/image/encoders/jpeg
diff options
context:
space:
mode:
Diffstat (limited to 'image/encoders/jpeg')
-rw-r--r--image/encoders/jpeg/moz.build11
-rw-r--r--image/encoders/jpeg/nsJPEGEncoder.cpp532
-rw-r--r--image/encoders/jpeg/nsJPEGEncoder.h84
3 files changed, 627 insertions, 0 deletions
diff --git a/image/encoders/jpeg/moz.build b/image/encoders/jpeg/moz.build
new file mode 100644
index 000000000..9e5551ce6
--- /dev/null
+++ b/image/encoders/jpeg/moz.build
@@ -0,0 +1,11 @@
+# -*- 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 += [
+ 'nsJPEGEncoder.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
diff --git a/image/encoders/jpeg/nsJPEGEncoder.cpp b/image/encoders/jpeg/nsJPEGEncoder.cpp
new file mode 100644
index 000000000..04cfef07b
--- /dev/null
+++ b/image/encoders/jpeg/nsJPEGEncoder.cpp
@@ -0,0 +1,532 @@
+/* -*- 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 "nsJPEGEncoder.h"
+#include "prprf.h"
+#include "nsString.h"
+#include "nsStreamUtils.h"
+#include "gfxColor.h"
+
+#include <setjmp.h>
+#include "jerror.h"
+
+using namespace mozilla;
+
+NS_IMPL_ISUPPORTS(nsJPEGEncoder, imgIEncoder, nsIInputStream,
+ nsIAsyncInputStream)
+
+// used to pass error info through the JPEG library
+struct encoder_error_mgr {
+ jpeg_error_mgr pub;
+ jmp_buf setjmp_buffer;
+};
+
+nsJPEGEncoder::nsJPEGEncoder()
+ : mFinished(false),
+ mImageBuffer(nullptr),
+ mImageBufferSize(0),
+ mImageBufferUsed(0),
+ mImageBufferReadPoint(0),
+ mCallback(nullptr),
+ mCallbackTarget(nullptr),
+ mNotifyThreshold(0),
+ mReentrantMonitor("nsJPEGEncoder.mReentrantMonitor")
+{
+}
+
+nsJPEGEncoder::~nsJPEGEncoder()
+{
+ if (mImageBuffer) {
+ free(mImageBuffer);
+ mImageBuffer = nullptr;
+ }
+}
+
+
+// nsJPEGEncoder::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.
+//
+// Transparency is always discarded.
+
+NS_IMETHODIMP
+nsJPEGEncoder::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(NS_LITERAL_STRING("quality="));
+ 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;
+ }
+ }
+
+ jpeg_compress_struct cinfo;
+
+ // We set up the normal JPEG error routines, then override error_exit.
+ // This must be done before the call to create_compress
+ encoder_error_mgr errmgr;
+ cinfo.err = jpeg_std_error(&errmgr.pub);
+ errmgr.pub.error_exit = errorExit;
+ // Establish the setjmp return context for my_error_exit to use.
+ if (setjmp(errmgr.setjmp_buffer)) {
+ // If we get here, the JPEG code has signaled an error.
+ // We need to clean up the JPEG object, close the input file, and return.
+ return NS_ERROR_FAILURE;
+ }
+
+ jpeg_create_compress(&cinfo);
+ cinfo.image_width = aWidth;
+ cinfo.image_height = aHeight;
+ cinfo.input_components = 3;
+ cinfo.in_color_space = JCS_RGB;
+ cinfo.data_precision = 8;
+
+ jpeg_set_defaults(&cinfo);
+ jpeg_set_quality(&cinfo, quality, 1); // quality here is 0-100
+ if (quality >= 90) {
+ int i;
+ for (i=0; i < MAX_COMPONENTS; i++) {
+ cinfo.comp_info[i].h_samp_factor=1;
+ cinfo.comp_info[i].v_samp_factor=1;
+ }
+ }
+
+ // set up the destination manager
+ jpeg_destination_mgr destmgr;
+ destmgr.init_destination = initDestination;
+ destmgr.empty_output_buffer = emptyOutputBuffer;
+ destmgr.term_destination = termDestination;
+ cinfo.dest = &destmgr;
+ cinfo.client_data = this;
+
+ jpeg_start_compress(&cinfo, 1);
+
+ // feed it the rows
+ if (aInputFormat == INPUT_FORMAT_RGB) {
+ while (cinfo.next_scanline < cinfo.image_height) {
+ const uint8_t* row = &aData[cinfo.next_scanline * aStride];
+ jpeg_write_scanlines(&cinfo, const_cast<uint8_t**>(&row), 1);
+ }
+ } else if (aInputFormat == INPUT_FORMAT_RGBA) {
+ UniquePtr<uint8_t[]> rowptr = MakeUnique<uint8_t[]>(aWidth * 3);
+ uint8_t* row = rowptr.get();
+ while (cinfo.next_scanline < cinfo.image_height) {
+ ConvertRGBARow(&aData[cinfo.next_scanline * aStride], row, aWidth);
+ jpeg_write_scanlines(&cinfo, &row, 1);
+ }
+ } else if (aInputFormat == INPUT_FORMAT_HOSTARGB) {
+ UniquePtr<uint8_t[]> rowptr = MakeUnique<uint8_t[]>(aWidth * 3);
+ uint8_t* row = rowptr.get();
+ while (cinfo.next_scanline < cinfo.image_height) {
+ ConvertHostARGBRow(&aData[cinfo.next_scanline * aStride], row, aWidth);
+ jpeg_write_scanlines(&cinfo, &row, 1);
+ }
+ }
+
+ jpeg_finish_compress(&cinfo);
+ jpeg_destroy_compress(&cinfo);
+
+ mFinished = true;
+ NotifyListener();
+
+ // if output callback can't get enough memory, it will free our buffer
+ if (!mImageBuffer) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsJPEGEncoder::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
+nsJPEGEncoder::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
+nsJPEGEncoder::GetImageBuffer(char** aOutputBuffer)
+{
+ NS_ENSURE_ARG_POINTER(aOutputBuffer);
+ *aOutputBuffer = reinterpret_cast<char*>(mImageBuffer);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJPEGEncoder::AddImageFrame(const uint8_t* aData,
+ uint32_t aLength,
+ uint32_t aWidth,
+ uint32_t aHeight,
+ uint32_t aStride,
+ uint32_t aFrameFormat,
+ const nsAString& aFrameOptions)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsJPEGEncoder::EndImageEncode()
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsJPEGEncoder::Close()
+{
+ if (mImageBuffer != nullptr) {
+ free(mImageBuffer);
+ mImageBuffer = nullptr;
+ mImageBufferSize = 0;
+ mImageBufferUsed = 0;
+ mImageBufferReadPoint = 0;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJPEGEncoder::Available(uint64_t* _retval)
+{
+ if (!mImageBuffer) {
+ return NS_BASE_STREAM_CLOSED;
+ }
+
+ *_retval = mImageBufferUsed - mImageBufferReadPoint;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJPEGEncoder::Read(char* aBuf, uint32_t aCount, uint32_t* _retval)
+{
+ return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, _retval);
+}
+
+NS_IMETHODIMP
+nsJPEGEncoder::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<const char*>
+ (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
+nsJPEGEncoder::IsNonBlocking(bool* _retval)
+{
+ *_retval = true;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJPEGEncoder::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
+nsJPEGEncoder::CloseWithStatus(nsresult aStatus)
+{
+ return Close();
+}
+
+
+
+// nsJPEGEncoder::ConvertHostARGBRow
+//
+// Our colors are stored with premultiplied alphas, but we need
+// an output with no alpha in machine-independent byte order.
+//
+// See gfx/cairo/cairo/src/cairo-png.c
+void
+nsJPEGEncoder::ConvertHostARGBRow(const uint8_t* aSrc, uint8_t* aDest,
+ uint32_t aPixelWidth)
+{
+ for (uint32_t x = 0; x < aPixelWidth; x++) {
+ const uint32_t& pixelIn = ((const uint32_t*)(aSrc))[x];
+ uint8_t* pixelOut = &aDest[x * 3];
+
+ pixelOut[0] = (pixelIn & 0xff0000) >> 16;
+ pixelOut[1] = (pixelIn & 0x00ff00) >> 8;
+ pixelOut[2] = (pixelIn & 0x0000ff) >> 0;
+ }
+}
+
+/**
+ * nsJPEGEncoder::ConvertRGBARow
+ *
+ * Input is RGBA, output is RGB, so we should alpha-premultiply.
+ */
+void
+nsJPEGEncoder::ConvertRGBARow(const uint8_t* aSrc, uint8_t* aDest,
+ uint32_t aPixelWidth)
+{
+ for (uint32_t x = 0; x < aPixelWidth; x++) {
+ const uint8_t* pixelIn = &aSrc[x * 4];
+ uint8_t* pixelOut = &aDest[x * 3];
+
+ uint8_t alpha = pixelIn[3];
+ pixelOut[0] = gfxPreMultiply(pixelIn[0], alpha);
+ pixelOut[1] = gfxPreMultiply(pixelIn[1], alpha);
+ pixelOut[2] = gfxPreMultiply(pixelIn[2], alpha);
+ }
+}
+
+// nsJPEGEncoder::initDestination
+//
+// Initialize destination. This is called by jpeg_start_compress() before
+// any data is actually written. It must initialize next_output_byte and
+// free_in_buffer. free_in_buffer must be initialized to a positive value.
+
+void // static
+nsJPEGEncoder::initDestination(jpeg_compress_struct* cinfo)
+{
+ nsJPEGEncoder* that = static_cast<nsJPEGEncoder*>(cinfo->client_data);
+ NS_ASSERTION(!that->mImageBuffer, "Image buffer already initialized");
+
+ that->mImageBufferSize = 8192;
+ that->mImageBuffer = (uint8_t*)malloc(that->mImageBufferSize);
+ that->mImageBufferUsed = 0;
+
+ cinfo->dest->next_output_byte = that->mImageBuffer;
+ cinfo->dest->free_in_buffer = that->mImageBufferSize;
+}
+
+
+// nsJPEGEncoder::emptyOutputBuffer
+//
+// This is called whenever the buffer has filled (free_in_buffer reaches
+// zero). In typical applications, it should write out the *entire* buffer
+// (use the saved start address and buffer length; ignore the current state
+// of next_output_byte and free_in_buffer). Then reset the pointer & count
+// to the start of the buffer, and return TRUE indicating that the buffer
+// has been dumped. free_in_buffer must be set to a positive value when
+// TRUE is returned. A FALSE return should only be used when I/O suspension
+// is desired (this operating mode is discussed in the next section).
+
+boolean // static
+nsJPEGEncoder::emptyOutputBuffer(jpeg_compress_struct* cinfo)
+{
+ nsJPEGEncoder* that = static_cast<nsJPEGEncoder*>(cinfo->client_data);
+ NS_ASSERTION(that->mImageBuffer, "No buffer to empty!");
+
+ // When we're reallocing the buffer we need to take the lock to ensure
+ // that nobody is trying to read from the buffer we are destroying
+ ReentrantMonitorAutoEnter autoEnter(that->mReentrantMonitor);
+
+ that->mImageBufferUsed = that->mImageBufferSize;
+
+ // expand buffer, just double size each time
+ that->mImageBufferSize *= 2;
+
+ uint8_t* newBuf = (uint8_t*)realloc(that->mImageBuffer,
+ that->mImageBufferSize);
+ if (!newBuf) {
+ // can't resize, just zero (this will keep us from writing more)
+ free(that->mImageBuffer);
+ that->mImageBuffer = nullptr;
+ that->mImageBufferSize = 0;
+ that->mImageBufferUsed = 0;
+
+ // This seems to be the only way to do errors through the JPEG library. We
+ // pass an nsresult masquerading as an int, which works because the
+ // setjmp() caller casts it back.
+ longjmp(((encoder_error_mgr*)(cinfo->err))->setjmp_buffer,
+ static_cast<int>(NS_ERROR_OUT_OF_MEMORY));
+ }
+ that->mImageBuffer = newBuf;
+
+ cinfo->dest->next_output_byte = &that->mImageBuffer[that->mImageBufferUsed];
+ cinfo->dest->free_in_buffer = that->mImageBufferSize - that->mImageBufferUsed;
+ return 1;
+}
+
+
+// nsJPEGEncoder::termDestination
+//
+// Terminate destination --- called by jpeg_finish_compress() after all data
+// has been written. In most applications, this must flush any data
+// remaining in the buffer. Use either next_output_byte or free_in_buffer
+// to determine how much data is in the buffer.
+
+void // static
+nsJPEGEncoder::termDestination(jpeg_compress_struct* cinfo)
+{
+ nsJPEGEncoder* that = static_cast<nsJPEGEncoder*>(cinfo->client_data);
+ if (!that->mImageBuffer) {
+ return;
+ }
+ that->mImageBufferUsed = cinfo->dest->next_output_byte - that->mImageBuffer;
+ NS_ASSERTION(that->mImageBufferUsed < that->mImageBufferSize,
+ "JPEG library busted, got a bad image buffer size");
+ that->NotifyListener();
+}
+
+
+// nsJPEGEncoder::errorExit
+//
+// Override the standard error method in the IJG JPEG decoder code. This
+// was mostly copied from nsJPEGDecoder.cpp
+
+void // static
+nsJPEGEncoder::errorExit(jpeg_common_struct* cinfo)
+{
+ nsresult error_code;
+ encoder_error_mgr* err = (encoder_error_mgr*) cinfo->err;
+
+ // Convert error to a browser error code
+ switch (cinfo->err->msg_code) {
+ case JERR_OUT_OF_MEMORY:
+ error_code = NS_ERROR_OUT_OF_MEMORY;
+ break;
+ default:
+ error_code = NS_ERROR_FAILURE;
+ }
+
+ // Return control to the setjmp point. We pass an nsresult masquerading as
+ // an int, which works because the setjmp() caller casts it back.
+ longjmp(err->setjmp_buffer, static_cast<int>(error_code));
+}
+
+void
+nsJPEGEncoder::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<nsIInputStreamCallback> callback;
+ if (mCallbackTarget) {
+ callback = NS_NewInputStreamReadyEvent(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/jpeg/nsJPEGEncoder.h b/image/encoders/jpeg/nsJPEGEncoder.h
new file mode 100644
index 000000000..2bcf5c2f3
--- /dev/null
+++ b/image/encoders/jpeg/nsJPEGEncoder.h
@@ -0,0 +1,84 @@
+/* -*- 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_jpeg_nsJPEGEncoder_h
+#define mozilla_image_encoders_jpeg_nsJPEGEncoder_h
+
+#include "imgIEncoder.h"
+
+#include "mozilla/ReentrantMonitor.h"
+#include "mozilla/Attributes.h"
+
+#include "nsCOMPtr.h"
+
+// needed for JPEG library
+#include <stdio.h>
+
+extern "C" {
+#include "jpeglib.h"
+}
+
+#define NS_JPEGENCODER_CID \
+{ \
+ /* ac2bb8fe-eeeb-4572-b40f-be03932b56e0 */ \
+ 0xac2bb8fe, \
+ 0xeeeb, \
+ 0x4572, \
+ {0xb4, 0x0f, 0xbe, 0x03, 0x93, 0x2b, 0x56, 0xe0} \
+}
+
+// Provides JPEG encoding functionality. Use InitFromData() to do the
+// encoding. See that function definition for encoding options.
+
+class nsJPEGEncoder final : public imgIEncoder
+{
+ typedef mozilla::ReentrantMonitor ReentrantMonitor;
+public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_IMGIENCODER
+ NS_DECL_NSIINPUTSTREAM
+ NS_DECL_NSIASYNCINPUTSTREAM
+
+ nsJPEGEncoder();
+
+private:
+ ~nsJPEGEncoder();
+
+protected:
+
+ void ConvertHostARGBRow(const uint8_t* aSrc, uint8_t* aDest,
+ uint32_t aPixelWidth);
+ void ConvertRGBARow(const uint8_t* aSrc, uint8_t* aDest,
+ uint32_t aPixelWidth);
+
+ static void initDestination(jpeg_compress_struct* cinfo);
+ static boolean emptyOutputBuffer(jpeg_compress_struct* cinfo);
+ static void termDestination(jpeg_compress_struct* cinfo);
+
+ static void errorExit(jpeg_common_struct* cinfo);
+
+ void NotifyListener();
+
+ bool mFinished;
+
+ // image buffer
+ uint8_t* mImageBuffer;
+ uint32_t mImageBufferSize;
+ uint32_t mImageBufferUsed;
+
+ uint32_t mImageBufferReadPoint;
+
+ nsCOMPtr<nsIInputStreamCallback> mCallback;
+ nsCOMPtr<nsIEventTarget> mCallbackTarget;
+ uint32_t mNotifyThreshold;
+
+ // nsJPEGEncoder 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;
+};
+
+#endif // mozilla_image_encoders_jpeg_nsJPEGEncoder_h
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-02 13:01:51 +0000