Add support for row-by-row jpeg encoding

Reland of:
https://skia-review.googlesource.com/c/14641/

Bug: 713862
Change-Id: I9dca5ede4ebf569c5f80edcfb23a506b6cfa935e
Reviewed-on: https://skia-review.googlesource.com/15144
Reviewed-by: Leon Scroggins <scroggo@google.com>
Commit-Queue: Matt Sarett <msarett@google.com>

12 files changed, 335 insertions, 124 deletions

diff --git a/gm/encode-platform.cpp b/gm/encode-platform.cpp
index f08da73ce8..f53ebc0d9a 100644
--- a/gm/encode-platform.cpp
+++ b/gm/encode-platform.cpp
@@ -11,6 +11,7 @@
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoderPriv.h"
+#include "SkJpegEncoder.h"
 #include "SkUnPreMultiply.h"
 
 namespace skiagm {
@@ -70,8 +71,10 @@ static sk_sp<SkData> encode_data(SkEncodedImageFormat type, const SkBitmap& bitm
             case SkEncodedImageFormat::kPNG:
                 return SkEncodeImageAsPNG(&buf, src, SkEncodeOptions()) ? buf.detachAsData()
                                                                         : nullptr;
-            case SkEncodedImageFormat::kJPEG:
-                return SkEncodeImageAsJPEG(&buf, src, 100) ? buf.detachAsData() : nullptr;
+            case SkEncodedImageFormat::kJPEG: {
+                bool success = SkJpegEncoder::Encode(&buf, src, SkJpegEncoder::Options());
+                return success ? buf.detachAsData() : nullptr;
+            }
             case SkEncodedImageFormat::kWEBP:
                 return SkEncodeImageAsWEBP(&buf, src, 100) ? buf.detachAsData() : nullptr;
             default:
diff --git a/gm/encode-srgb.cpp b/gm/encode-srgb.cpp
index 3015baa4a0..fef133212c 100644
--- a/gm/encode-srgb.cpp
+++ b/gm/encode-srgb.cpp
@@ -13,6 +13,7 @@
 #include "SkColorSpace_Base.h"
 #include "SkData.h"
 #include "SkImageEncoderPriv.h"
+#include "SkJpegEncoder.h"
 #include "SkPM4f.h"
 #include "SkSRGB.h"
 
@@ -128,7 +129,7 @@ static sk_sp<SkData> encode_data(const SkBitmap& bitmap, SkEncodedImageFormat fo
             SkAssertResult(SkEncodeImageAsWEBP(&buf, src, options));
             break;
         case SkEncodedImageFormat::kJPEG:
-            SkAssertResult(SkEncodeImageAsJPEG(&buf, src, options));
+            SkAssertResult(SkJpegEncoder::Encode(&buf, src, SkJpegEncoder::Options()));
             break;
         default:
             break;
diff --git a/gn/tests.gni b/gn/tests.gni
index ffd8b41317..be4389be4f 100644
--- a/gn/tests.gni
+++ b/gn/tests.gni
@@ -63,6 +63,7 @@ tests_sources = [
   "$_tests/DynamicHashTest.cpp",
   "$_tests/EGLImageTest.cpp",
   "$_tests/EmptyPathTest.cpp",
+  "$_tests/EncodeTest.cpp",
   "$_tests/ExifTest.cpp",
   "$_tests/F16StagesTest.cpp",
   "$_tests/FillPathTest.cpp",
diff --git a/src/core/SkImageInfoPriv.h b/src/core/SkImageInfoPriv.h
index 855e506bb2..a0c1b3403a 100644
--- a/src/core/SkImageInfoPriv.h
+++ b/src/core/SkImageInfoPriv.h
@@ -11,10 +11,10 @@
 #include "SkImageInfo.h"
 
 /**
- *  Returns true if |info| contains a valid combination of width, height, colorType, alphaType,
- *  colorSpace.  Returns false otherwise.
+ *  This contains shared checks on SkImageInfo.  Depending on the desired color space behavior,
+ *  the caller should choose one of the two versions below.
  */
-static inline bool SkImageInfoIsValid(const SkImageInfo& info) {
+static inline bool SkImageInfoIsValidCommon(const SkImageInfo& info) {
     if (info.width() <= 0 || info.height() <= 0) {
         return false;
     }
@@ -38,6 +38,35 @@ static inline bool SkImageInfoIsValid(const SkImageInfo& info) {
         return false;
     }
 
+    return true;
+}
+
+/**
+ *  Returns true if |info| contains a valid combination of width, height, colorType, alphaType,
+ *  colorSpace.  Allows numerical color spaces.  Returns false otherwise.
+ */
+static inline bool SkImageInfoIsValidAllowNumericalCS(const SkImageInfo& info) {
+    if (!SkImageInfoIsValidCommon(info)) {
+        return false;
+    }
+
+    SkColorSpaceTransferFn fn;
+    if (info.colorSpace() && !info.colorSpace()->isNumericalTransferFn(&fn)) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ *  Returns true if |info| contains a valid combination of width, height, colorType, alphaType,
+ *  colorSpace.  Only supports rendering color spaces.  Returns false otherwise.
+ */
+static inline bool SkImageInfoIsValidRenderingCS(const SkImageInfo& info) {
+    if (!SkImageInfoIsValidCommon(info)) {
+        return false;
+    }
+
     if (info.colorSpace() &&
        (!info.colorSpace()->gammaCloseToSRGB() && !info.colorSpace()->gammaIsLinear())) {
         return false;
@@ -65,7 +94,7 @@ static inline bool SkImageInfoIsValid(const SkImageInfo& info) {
  *      conversion is not well-defined.
  */
 static inline bool SkImageInfoValidConversion(const SkImageInfo& dst, const SkImageInfo& src) {
-    if (!SkImageInfoIsValid(dst) || !SkImageInfoIsValid(src)) {
+    if (!SkImageInfoIsValidRenderingCS(dst) || !SkImageInfoIsValidRenderingCS(src)) {
         return false;
     }
 
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 5401a10775..895fdec044 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -176,7 +176,7 @@ sk_sp<GrTextureProxy> GrUploadPixmapToTextureProxyNoCheck(GrResourceProvider* re
 sk_sp<GrTextureProxy> GrUploadPixmapToTextureProxy(GrResourceProvider* resourceProvider,
                                                    const SkPixmap& pixmap,
                                                    SkBudgeted budgeted) {
-    if (!SkImageInfoIsValid(pixmap.info())) {
+    if (!SkImageInfoIsValidRenderingCS(pixmap.info())) {
         return nullptr;
     }
 
@@ -205,7 +205,7 @@ sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrContext* ctx,
         ? SkDestinationSurfaceColorMode::kGammaAndColorSpaceAware
         : SkDestinationSurfaceColorMode::kLegacy;
 
-    if (!SkImageInfoIsValid(bitmap.info())) {
+    if (!SkImageInfoIsValidRenderingCS(bitmap.info())) {
         return nullptr;
     }
 
@@ -252,7 +252,7 @@ sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrContext* ctx, const SkImage
                                                    const GrMipLevel* texels,
                                                    int mipLevelCount,
                                                    SkDestinationSurfaceColorMode colorMode) {
-    if (!SkImageInfoIsValid(info)) {
+    if (!SkImageInfoIsValidRenderingCS(info)) {
         return nullptr;
     }
 
diff --git a/src/images/SkImageEncoder.cpp b/src/images/SkImageEncoder.cpp
index fecadbf82a..23f46e4982 100644
--- a/src/images/SkImageEncoder.cpp
+++ b/src/images/SkImageEncoder.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SkImageEncoderPriv.h"
+#include "SkJpegEncoder.h"
 
 bool SkEncodeImage(SkWStream* dst, const SkPixmap& src,
                    SkEncodedImageFormat format, int quality) {
@@ -16,8 +17,11 @@ bool SkEncodeImage(SkWStream* dst, const SkPixmap& src,
         return SkEncodeImageWithWIC(dst, src, format, quality);
     #else
         switch(format) {
-            case SkEncodedImageFormat::kJPEG:
-                return SkEncodeImageAsJPEG(dst, src, quality);
+            case SkEncodedImageFormat::kJPEG: {
+                SkJpegEncoder::Options opts;
+                opts.fQuality = quality;
+                return SkJpegEncoder::Encode(dst, src, opts);
+            }
             case SkEncodedImageFormat::kPNG:
                 return SkEncodeImageAsPNG(dst, src, SkEncodeOptions());
             case SkEncodedImageFormat::kWEBP:
diff --git a/src/images/SkImageEncoderPriv.h b/src/images/SkImageEncoderPriv.h
index 540d93093b..5e57cd128a 100644
--- a/src/images/SkImageEncoderPriv.h
+++ b/src/images/SkImageEncoderPriv.h
@@ -14,13 +14,6 @@ struct SkEncodeOptions {
     SkTransferFunctionBehavior fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
 };
 
-#ifdef SK_HAS_JPEG_LIBRARY
-    bool SkEncodeImageAsJPEG(SkWStream*, const SkPixmap&, const SkEncodeOptions&);
-    bool SkEncodeImageAsJPEG(SkWStream*, const SkPixmap&, int quality);
-#else
-    #define SkEncodeImageAsJPEG(...) false
-#endif
-
 #ifdef SK_HAS_PNG_LIBRARY
     bool SkEncodeImageAsPNG(SkWStream*, const SkPixmap&, const SkEncodeOptions&);
 #else
diff --git a/src/images/SkJPEGImageEncoder.cpp b/src/images/SkJPEGImageEncoder.cpp
index 764e9c43b0..0603447e92 100644
--- a/src/images/SkJPEGImageEncoder.cpp
+++ b/src/images/SkJPEGImageEncoder.cpp
@@ -11,6 +11,8 @@
 
 #include "SkColorPriv.h"
 #include "SkImageEncoderFns.h"
+#include "SkImageInfoPriv.h"
+#include "SkJpegEncoder.h"
 #include "SkJPEGWriteUtility.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
@@ -22,122 +24,144 @@ extern "C" {
     #include "jerror.h"
 }
 
-/**
- *  Returns true if |info| is supported by the jpeg encoder and false otherwise.
- *  |jpegColorType| will be set to the proper libjpeg-turbo type for input to the library.
- *  |numComponents| will be set to the number of components in the |jpegColorType|.
- *  |proc|          will be set if we need to pre-convert the input before passing to
- *                  libjpeg-turbo.  Otherwise will be set to nullptr.
- */
-// TODO (skbug.com/1501):
-// Should we fail on non-opaque encodes?
-// Or should we change alpha behavior (ex: unpremultiply when the input is premul)?
-// Or is ignoring the alpha type and alpha channel ok here?
-static bool set_encode_config(J_COLOR_SPACE* jpegColorType, int* numComponents,
-                              transform_scanline_proc* proc, const SkImageInfo& info) {
-    *proc = nullptr;
-    switch (info.colorType()) {
+// This warning triggers false postives way too often in here.
+#if defined(__GNUC__) && !defined(__clang__)
+    #pragma GCC diagnostic ignored "-Wclobbered"
+#endif
+
+class SkJpegEncoderMgr : SkNoncopyable {
+public:
+
+    /*
+     * Create the decode manager
+     * Does not take ownership of stream
+     */
+    static std::unique_ptr<SkJpegEncoderMgr> Make(SkWStream* stream) {
+        return std::unique_ptr<SkJpegEncoderMgr>(new SkJpegEncoderMgr(stream));
+    }
+
+    bool setParams(const SkImageInfo& srcInfo);
+
+    jpeg_compress_struct* cinfo() { return &fCInfo; }
+
+    jmp_buf& jmpBuf() { return fErrMgr.fJmpBuf; }
+
+    transform_scanline_proc proc() const { return fProc; }
+
+    ~SkJpegEncoderMgr() {
+        jpeg_destroy_compress(&fCInfo);
+    }
+
+private:
+
+    SkJpegEncoderMgr(SkWStream* stream)
+        : fDstMgr(stream)
+        , fProc(nullptr)
+    {
+        fCInfo.err = jpeg_std_error(&fErrMgr);
+        fErrMgr.error_exit = skjpeg_error_exit;
+        jpeg_create_compress(&fCInfo);
+        fCInfo.dest = &fDstMgr;
+    }
+
+    jpeg_compress_struct    fCInfo;
+    skjpeg_error_mgr        fErrMgr;
+    skjpeg_destination_mgr  fDstMgr;
+    transform_scanline_proc fProc;
+};
+
+bool SkJpegEncoderMgr::setParams(const SkImageInfo& srcInfo) {
+    J_COLOR_SPACE jpegColorType = JCS_EXT_RGBA;
+    int numComponents = 0;
+    switch (srcInfo.colorType()) {
         case kRGBA_8888_SkColorType:
-            *jpegColorType = JCS_EXT_RGBA;
-            *numComponents = 4;
-            return true;
+            jpegColorType = JCS_EXT_RGBA;
+            numComponents = 4;
+            break;
         case kBGRA_8888_SkColorType:
-            *jpegColorType = JCS_EXT_BGRA;
-            *numComponents = 4;
-            return true;
+            jpegColorType = JCS_EXT_BGRA;
+            numComponents = 4;
+            break;
         case kRGB_565_SkColorType:
-            *proc = transform_scanline_565;
-            *jpegColorType = JCS_RGB;
-            *numComponents = 3;
-            return true;
+            fProc = transform_scanline_565;
+            jpegColorType = JCS_RGB;
+            numComponents = 3;
+            break;
         case kARGB_4444_SkColorType:
-            *proc = transform_scanline_444;
-            *jpegColorType = JCS_RGB;
-            *numComponents = 3;
-            return true;
+            fProc = transform_scanline_444;
+            jpegColorType = JCS_RGB;
+            numComponents = 3;
+            break;
         case kIndex_8_SkColorType:
-            *proc = transform_scanline_index8_opaque;
-            *jpegColorType = JCS_RGB;
-            *numComponents = 3;
-            return true;
+            fProc = transform_scanline_index8_opaque;
+            jpegColorType = JCS_RGB;
+            numComponents = 3;
+            break;
         case kGray_8_SkColorType:
-            SkASSERT(info.isOpaque());
-            *jpegColorType = JCS_GRAYSCALE;
-            *numComponents = 1;
-            return true;
+            SkASSERT(srcInfo.isOpaque());
+            jpegColorType = JCS_GRAYSCALE;
+            numComponents = 1;
+            break;
         case kRGBA_F16_SkColorType:
-            if (!info.colorSpace() || !info.colorSpace()->gammaIsLinear()) {
+            if (!srcInfo.colorSpace() || !srcInfo.colorSpace()->gammaIsLinear()) {
                 return false;
             }
 
-            *proc = transform_scanline_F16_to_8888;
-            *jpegColorType = JCS_EXT_RGBA;
-            *numComponents = 4;
-            return true;
+            fProc = transform_scanline_F16_to_8888;
+            jpegColorType = JCS_EXT_RGBA;
+            numComponents = 4;
+            break;
         default:
             return false;
     }
 
+    fCInfo.image_width = srcInfo.width();
+    fCInfo.image_height = srcInfo.height();
+    fCInfo.in_color_space = jpegColorType;
+    fCInfo.input_components = numComponents;
+    jpeg_set_defaults(&fCInfo);
 
+    // Tells libjpeg-turbo to compute optimal Huffman coding tables
+    // for the image.  This improves compression at the cost of
+    // slower encode performance.
+    fCInfo.optimize_coding = TRUE;
+    return true;
 }
 
-bool SkEncodeImageAsJPEG(SkWStream* stream, const SkPixmap& pixmap, const SkEncodeOptions& opts) {
-    if (SkTransferFunctionBehavior::kRespect == opts.fUnpremulBehavior) {
-        // Respecting the transfer function requries a color space.  It's not actually critical
-        // in the jpeg case (since jpegs are opaque), but Skia color correct behavior generally
-        // requires pixels to be tagged with color spaces.
-        if (!pixmap.colorSpace() || (!pixmap.colorSpace()->gammaCloseToSRGB() &&
-                                     !pixmap.colorSpace()->gammaIsLinear())) {
-            return false;
-        }
-    }
+class SkJpegEncoder_Base : public SkJpegEncoder {
+public:
+    SkJpegEncoder_Base(std::unique_ptr<SkJpegEncoderMgr> encoderMgr, const SkPixmap& src);
 
-    return SkEncodeImageAsJPEG(stream, pixmap, 100);
-}
+    bool onEncodeRows(int numRows);
 
-bool SkEncodeImageAsJPEG(SkWStream* stream, const SkPixmap& pixmap, int quality) {
-    if (!pixmap.addr()) {
-        return false;
-    }
-    jpeg_compress_struct    cinfo;
-    skjpeg_error_mgr        sk_err;
-    skjpeg_destination_mgr  sk_wstream(stream);
+private:
+    std::unique_ptr<SkJpegEncoderMgr> fEncoderMgr;
+    SkPixmap                          fSrc;
+    int                               fCurrRow;
+    SkAutoTMalloc<uint8_t>            fStorage;
+};
 
-    // Declare before calling setjmp.
-    SkAutoTMalloc<uint8_t>  storage;
-
-    cinfo.err = jpeg_std_error(&sk_err);
-    sk_err.error_exit = skjpeg_error_exit;
-    if (setjmp(sk_err.fJmpBuf)) {
-        return false;
+std::unique_ptr<SkJpegEncoder> SkJpegEncoder::Make(SkWStream* dst, const SkPixmap& src,
+                                                   const Options& options) {
+    if (!SkImageInfoIsValidAllowNumericalCS(src.info()) || !src.addr() ||
+            src.rowBytes() < src.info().minRowBytes()) {
+        return nullptr;
     }
 
-    J_COLOR_SPACE jpegColorSpace;
-    int numComponents;
-    transform_scanline_proc proc;
-    if (!set_encode_config(&jpegColorSpace, &numComponents, &proc, pixmap.info())) {
-        return false;
+    std::unique_ptr<SkJpegEncoderMgr> encoderMgr = SkJpegEncoderMgr::Make(dst);
+    if (setjmp(encoderMgr->jmpBuf())) {
+        return nullptr;
     }
 
-    jpeg_create_compress(&cinfo);
-    cinfo.dest = &sk_wstream;
-    cinfo.image_width = pixmap.width();
-    cinfo.image_height = pixmap.height();
-    cinfo.input_components = numComponents;
-    cinfo.in_color_space = jpegColorSpace;
-
-    jpeg_set_defaults(&cinfo);
-
-    // Tells libjpeg-turbo to compute optimal Huffman coding tables
-    // for the image.  This improves compression at the cost of
-    // slower encode performance.
-    cinfo.optimize_coding = TRUE;
-    jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
+    if (!encoderMgr->setParams(src.info())) {
+        return nullptr;
+    }
 
-    jpeg_start_compress(&cinfo, TRUE);
+    jpeg_set_quality(encoderMgr->cinfo(), options.fQuality, TRUE);
+    jpeg_start_compress(encoderMgr->cinfo(), TRUE);
 
-    if (pixmap.colorSpace()) {
-        sk_sp<SkData> icc = icc_from_color_space(*pixmap.colorSpace());
+    if (src.colorSpace()) {
+        sk_sp<SkData> icc = icc_from_color_space(*src.colorSpace());
         if (icc) {
             // Create a contiguous block of memory with the icc signature followed by the profile.
             sk_sp<SkData> markerData =
@@ -149,30 +173,68 @@ bool SkEncodeImageAsJPEG(SkWStream* stream, const SkPixmap& pixmap, int quality)
             *ptr++ = 1; // Out of one total markers.
             memcpy(ptr, icc->data(), icc->size());
 
-            jpeg_write_marker(&cinfo, kICCMarker, markerData->bytes(), markerData->size());
+            jpeg_write_marker(encoderMgr->cinfo(), kICCMarker, markerData->bytes(),
+                              markerData->size());
         }
     }
 
-    if (proc) {
-        storage.reset(numComponents * pixmap.width());
+    return std::unique_ptr<SkJpegEncoder>(new SkJpegEncoder_Base(std::move(encoderMgr), src));
+}
+
+
+SkJpegEncoder_Base::SkJpegEncoder_Base(std::unique_ptr<SkJpegEncoderMgr> encoderMgr,
+                                       const SkPixmap& src)
+    : fEncoderMgr(std::move(encoderMgr))
+    , fSrc(src)
+    , fCurrRow(0)
+    , fStorage(fEncoderMgr->proc() ? fEncoderMgr->cinfo()->input_components*src.width() : 0)
+{}
+
+bool SkJpegEncoder::encodeRows(int numRows) {
+    return ((SkJpegEncoder_Base*) this)->onEncodeRows(numRows);
+}
+
+bool SkJpegEncoder_Base::onEncodeRows(int numRows) {
+    SkASSERT(numRows > 0 && fCurrRow < fSrc.height());
+    if (numRows <= 0 || fCurrRow >= fSrc.height()) {
+        return false;
+    }
+
+    if (fCurrRow + numRows > fSrc.height()) {
+        numRows = fSrc.height() - fCurrRow;
+    }
+
+    if (setjmp(fEncoderMgr->jmpBuf())) {
+        // Short circuit any future calls after failing.
+        fCurrRow = fSrc.height();
+        return false;
     }
 
-    const void* srcRow = pixmap.addr();
-    const SkPMColor* colors = pixmap.ctable() ? pixmap.ctable()->readColors() : nullptr;
-    while (cinfo.next_scanline < cinfo.image_height) {
+    const void* srcRow = fSrc.addr(0, fCurrRow);
+    const SkPMColor* colors = fSrc.ctable() ? fSrc.ctable()->readColors() : nullptr;
+    for (int i = 0; i < numRows; i++) {
         JSAMPLE* jpegSrcRow = (JSAMPLE*) srcRow;
-        if (proc) {
-            proc((char*)storage.get(), (const char*)srcRow, pixmap.width(), numComponents, colors);
-            jpegSrcRow = storage.get();
+        if (fEncoderMgr->proc()) {
+            fEncoderMgr->proc()((char*)fStorage.get(), (const char*)srcRow, fSrc.width(),
+                                fEncoderMgr->cinfo()->input_components, colors);
+            jpegSrcRow = fStorage.get();
         }
 
-        (void) jpeg_write_scanlines(&cinfo, &jpegSrcRow, 1);
-        srcRow = SkTAddOffset<const void>(srcRow, pixmap.rowBytes());
+        jpeg_write_scanlines(fEncoderMgr->cinfo(), &jpegSrcRow, 1);
+        srcRow = SkTAddOffset<const void>(srcRow, fSrc.rowBytes());
     }
 
-    jpeg_finish_compress(&cinfo);
-    jpeg_destroy_compress(&cinfo);
+    fCurrRow += numRows;
+    if (fCurrRow == fSrc.height()) {
+        jpeg_finish_compress(fEncoderMgr->cinfo());
+    }
 
     return true;
 }
+
+bool SkJpegEncoder::Encode(SkWStream* dst, const SkPixmap& src, const Options& options) {
+    auto encoder = SkJpegEncoder::Make(dst, src, options);
+    return encoder.get() && encoder->encodeRows(src.height());
+}
+
 #endif
diff --git a/src/images/SkJpegEncoder.h b/src/images/SkJpegEncoder.h
new file mode 100644
index 0000000000..21613f90f0
--- /dev/null
+++ b/src/images/SkJpegEncoder.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJpegEncoder_DEFINED
+#define SkJpegEncoder_DEFINED
+
+#include "SkPixmap.h"
+#include "SkTypes.h"
+
+class SkWStream;
+
+class SkJpegEncoder : SkNoncopyable {
+public:
+
+    // TODO (skbug.com/1501):
+    // Since jpegs are always opaque, this encoder ignores the alpha channel and treats the
+    // pixels as opaque.
+    // Another possible behavior is to blend the pixels onto opaque black.  We'll need to add
+    // an option for this - and an SkTransferFunctionBehavior.
+
+    struct Options {
+        /**
+         * |fQuality| must be in [0, 100] where 0 corresponds to the lowest quality.
+         */
+        int fQuality = 100;
+    };
+
+    /**
+     *  Encode the |src| pixels to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     */
+    static bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+
+    /**
+     *  Create a jpeg encoder that will encode the |src| pixels to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  |dst| is unowned but must remain valid for the lifetime of the object.
+     *
+     *  This returns nullptr on an invalid or unsupported |src|.
+     */
+    static std::unique_ptr<SkJpegEncoder> Make(SkWStream* dst, const SkPixmap& src,
+                                               const Options& options);
+
+    /**
+     *  Encode |numRows| rows of input.  If the caller requests more rows than are remaining
+     *  in the src, this will encode all of the remaining rows.  |numRows| must be greater
+     *  than zero.
+     */
+    bool encodeRows(int numRows);
+
+    virtual ~SkJpegEncoder() {}
+};
+
+#endif
diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index 4a135337a7..45362db72c 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -20,6 +20,7 @@
 #include "SkImageEncoderPriv.h"
 #include "SkMD5.h"
 #include "SkOSPath.h"
+#include "SkJpegEncoder.h"
 #include "SkPngChunkReader.h"
 #include "SkRandom.h"
 #include "SkStream.h"
@@ -1530,7 +1531,7 @@ static void encode_format(SkDynamicMemoryWStream* stream, const SkPixmap& pixmap
             SkEncodeImageAsPNG(stream, pixmap, opts);
             break;
         case SkEncodedImageFormat::kJPEG:
-            SkEncodeImageAsJPEG(stream, pixmap, opts);
+            SkJpegEncoder::Encode(stream, pixmap, SkJpegEncoder::Options());
             break;
         case SkEncodedImageFormat::kWEBP:
             SkEncodeImageAsWEBP(stream, pixmap, opts);
diff --git a/tests/EncodeTest.cpp b/tests/EncodeTest.cpp
new file mode 100644
index 0000000000..9db5039d59
--- /dev/null
+++ b/tests/EncodeTest.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Resources.h"
+#include "Test.h"
+
+#include "SkBitmap.h"
+#include "SkJpegEncoder.h"
+#include "SkStream.h"
+
+DEF_TEST(Encode_Jpeg, r) {
+    SkBitmap bitmap;
+    bool success = GetResourceAsBitmap("mandrill_128.png", &bitmap);
+    if (!success) {
+        return;
+    }
+
+    SkPixmap src;
+    success = bitmap.peekPixels(&src);
+    REPORTER_ASSERT(r, success);
+    if (!success) {
+        return;
+    }
+
+    SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
+    success = SkJpegEncoder::Encode(&dst0, src, SkJpegEncoder::Options());
+    REPORTER_ASSERT(r, success);
+
+    auto encoder1 = SkJpegEncoder::Make(&dst1, src, SkJpegEncoder::Options());
+    for (int i = 0; i < src.height(); i++) {
+        success = encoder1->encodeRows(1);
+        REPORTER_ASSERT(r, success);
+    }
+
+    auto encoder2 = SkJpegEncoder::Make(&dst2, src, SkJpegEncoder::Options());
+    for (int i = 0; i < src.height(); i+=3) {
+        success = encoder2->encodeRows(3);
+        REPORTER_ASSERT(r, success);
+    }
+
+    auto encoder3 = SkJpegEncoder::Make(&dst3, src, SkJpegEncoder::Options());
+    success = encoder3->encodeRows(200);
+    REPORTER_ASSERT(r, success);
+
+    sk_sp<SkData> data0 = dst0.detachAsData();
+    sk_sp<SkData> data1 = dst1.detachAsData();
+    sk_sp<SkData> data2 = dst2.detachAsData();
+    sk_sp<SkData> data3 = dst3.detachAsData();
+    REPORTER_ASSERT(r, data0->equals(data1.get()));
+    REPORTER_ASSERT(r, data0->equals(data2.get()));
+    REPORTER_ASSERT(r, data0->equals(data3.get()));
+}
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index 9cb9200f5a..9363e71a00 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -530,7 +530,7 @@ static const void* five_reference_pixels(SkColorType colorType) {
 
 static void test_conversion(skiatest::Reporter* r, const SkImageInfo& dstInfo,
                             const SkImageInfo& srcInfo) {
-    if (!SkImageInfoIsValid(srcInfo)) {
+    if (!SkImageInfoIsValidRenderingCS(srcInfo)) {
         return;
     }