import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

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);
+  }
+}