【Android 内存优化】Android 原生 API 图片压缩原理 ( Bitmap_compress 方法解析 | Skia 二维图形库 | libjpeg 函数库 | libpng 函数库 )

long nativeBitmap 参数 : Native 层的 Bitmap 指针 ;
int format 参数 : 压缩格式格式 ;
int quality 参数 : 压缩质量 ;
OutputStream stream 参数 : 输出流 ;
byte[] tempStorage 参数 : 暂时的存储区 ;
private static native boolean nativeCompress(long nativeBitmap, int format,
                                        int quality, OutputStream stream,
                                        byte[] tempStorage);

jlong bitmapHandle 参数 : Native 层的 Bitmap 指针 ;
jint format 参数 : 压缩格式格式 ;
jint quality 参数 : 压缩质量 ;
jobject jstream 参数 : 输出流 ;
jbyteArray jstorage 参数 : 暂时的存储区 ;
static jboolean Bitmap_compress(JNIEnv* env, jobject clazz, jlong bitmapHandle,
                                jint format, jint quality,
                                jobject jstream, jbyteArray jstorage) {
  // 获取 Bitmap 指针
    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
    SkImageEncoder::Type fm;
  // 判断图片压缩格式 , 给 SkImageEncoder::Type fm 局部变量赋值
    switch (format) {
    // JPEG 格式
    case kJPEG_JavaEncodeFormat:
        fm = SkImageEncoder::kJPEG_Type;
        break;
  // PNG 格式
    case kPNG_JavaEncodeFormat:
        fm = SkImageEncoder::kPNG_Type;
        break;
  // WEBP 格式
    case kWEBP_JavaEncodeFormat:
        fm = SkImageEncoder::kWEBP_Type;
        break;
  // 如果传入未知格式 , 直接返回 错误信息 
    default:
        return JNI_FALSE;
    }
    bool success = false;
    if (NULL != bitmap) {
        SkAutoLockPixels alp(*bitmap);
        if (NULL == bitmap->getPixels()) {
            return JNI_FALSE;
        }
        SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
        if (NULL == strm) {
            return JNI_FALSE;
        }
  // 创建图片编码器 , 需要根据传入的 fm 编码类型创建
        SkImageEncoder* encoder = SkImageEncoder::Create(fm);
        if (NULL != encoder) {
          // ★ 这是图片压缩的核心方法
            success = encoder->encodeStream(strm, *bitmap, quality);
            delete encoder;
        }
        delete strm;
    }
    return success ? JNI_TRUE : JNI_FALSE;
}

#ifndef SkImageEncoder_DEFINED
#define SkImageEncoder_DEFINED
#include "SkTypes.h"
#include "SkTRegistry.h"
class SkBitmap;
class SkData;
class SkWStream;
class SkImageEncoder {
public:
    enum Type {
        kUnknown_Type,
        kBMP_Type,
        kGIF_Type,
        kICO_Type,
        kJPEG_Type,
        kPNG_Type,
        kWBMP_Type,
        kWEBP_Type,
        kKTX_Type,
    };
    static SkImageEncoder* Create(Type);
    virtual ~SkImageEncoder();
    /*  Quality ranges from 0..100 */
    enum {
        kDefaultQuality = 80
    };
    SkData* encodeData(const SkBitmap&, int quality);
    bool encodeFile(const char file[], const SkBitmap& bm, int quality);
    bool encodeStream(SkWStream* stream, const SkBitmap& bm, int quality);
    static SkData* EncodeData(const SkBitmap&, Type, int quality);
    static bool EncodeFile(const char file[], const SkBitmap&, Type,
                           int quality);
    static bool EncodeStream(SkWStream*, const SkBitmap&, Type,
                           int quality);
protected:
  // 特别注意 : 该函数是个虚函数 , 需要在子类实现中实现该方法
    virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) = 0;
};

#include "SkImageEncoder.h"
#include "SkBitmap.h"
#include "SkStream.h"
#include "SkTemplates.h"
SkImageEncoder::~SkImageEncoder() {}
// 在该方法中调用了 onEncode 虚函数方法 , 该方法需要在子类中实现 
bool SkImageEncoder::encodeStream(SkWStream* stream, const SkBitmap& bm,
                                  int quality) {
    quality = SkMin32(100, SkMax32(0, quality));
    return this->onEncode(stream, bm, quality);
}
// ... 省略部分代码

// SkJPEGImageEncoder 是 SkImageEncoder 子类 , 共有继承 
class SkJPEGImageEncoder : public SkImageEncoder {
protected:
  // 该方法中调用了大量 libjpeg 库的函数
    virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) {
#ifdef TIME_ENCODE
        SkAutoTime atm("JPEG Encode");
#endif
        SkAutoLockPixels alp(bm);
        if (NULL == bm.getPixels()) {
            return false;
        }
        jpeg_compress_struct    cinfo;
        skjpeg_error_mgr        sk_err;
        skjpeg_destination_mgr  sk_wstream(stream);
        // allocate these before set call setjmp
        SkAutoMalloc    oneRow;
        SkAutoLockColors ctLocker;
        cinfo.err = jpeg_std_error(&sk_err);
        sk_err.error_exit = skjpeg_error_exit;
        if (setjmp(sk_err.fJmpBuf)) {
            return false;
        }
        // Keep after setjmp or mark volatile.
        const WriteScanline writer = ChooseWriter(bm);
        if (NULL == writer) {
            return false;
        }
        jpeg_create_compress(&cinfo);
        cinfo.dest = &sk_wstream;
        cinfo.image_width = bm.width();
        cinfo.image_height = bm.height();
        cinfo.input_components = 3;
#ifdef WE_CONVERT_TO_YUV
        cinfo.in_color_space = JCS_YCbCr;
#else
        cinfo.in_color_space = JCS_RGB;
#endif
        cinfo.input_gamma = 1;
        jpeg_set_defaults(&cinfo);
        jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
#ifdef DCT_IFAST_SUPPORTED
        cinfo.dct_method = JDCT_IFAST;
#endif
        jpeg_start_compress(&cinfo, TRUE);
        const int       width = bm.width();
        uint8_t*        oneRowP = (uint8_t*)oneRow.reset(width * 3);
        const SkPMColor* colors = ctLocker.lockColors(bm);
        const void*      srcRow = bm.getPixels();
        while (cinfo.next_scanline < cinfo.image_height) {
            JSAMPROW row_pointer[1];    /* pointer to JSAMPLE row[s] */
            writer(oneRowP, srcRow, width, colors);
            row_pointer[0] = oneRowP;
            (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
            srcRow = (const void*)((const char*)srcRow + bm.rowBytes());
        }
        jpeg_finish_compress(&cinfo);
        jpeg_destroy_compress(&cinfo);
        return true;
    }
};