高效能圖片壓縮 —— libjpeg-turbo 的編譯與整合

前言

Android 提供的 JPEG 壓縮, 是由外部連結庫中的 libjpeg 實現的, 但 Google 考慮到 Android 裝置效能的瓶頸, 在 Skia 呼叫中的三方連結庫 libjpeg 時, 多處進行了閹割處理, 這樣帶來的好處就是壓縮的速度更快了, 但細節丟失嚴重, 壓縮後甚至有偏綠的情況, 下面的程式碼便是 Android 執行 JPEG 壓縮的關鍵

/**
 * SkImageDecoder_libjpeg.cpp
 */
class SkJPEGImageEncoder : public SkImageEncoder {
protected:
    virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) {
        ......
        // 1. 初始化 libjpeg
        jpeg_create_compress(&cinfo);
        // 設定一些引數
        cinfo.dest = &sk_wstream;
        cinfo.image_width = bm.width();
        cinfo.image_height = bm.height();
        cinfo.input_components = 3;
        // FIXME: Can we take advantage of other in_color_spaces in libjpeg-turbo?
        cinfo.in_color_space = JCS_RGB;
        // The gamma value is ignored by libjpeg-turbo.
        cinfo.input_gamma = 1;
        jpeg_set_defaults(&cinfo);
        // 這個標誌用於控制是否使用優化的哈夫曼表
        cinfo.optimize_coding = TRUE;
        jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
        
        // 2. 開始壓縮
        jpeg_start_compress(&cinfo, TRUE);

        const int       width = bm.width();
        uint8_t*        oneRowP = oneRow.reset(width * 3);

        const SkPMColor* colors = bm.getColorTable() ? bm.getColorTable()->readColors() : nullptr;
        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());
        }
        
        // 3. 結束壓縮
        jpeg_finish_compress(&cinfo);
        
        // 4. 釋放記憶體
        jpeg_destroy_compress(&cinfo);

        return true;
    }
};
複製程式碼

從上面的程式碼中, 我們定位到 cinfo.optimize_coding 這個引數

• Android7.0 之後, 這個引數為 true
  • 在圖片壓縮的時候, 會根據圖片去計算其對應的哈夫曼表, 圖片質量更高, 但是圖片佔用的磁碟空間也相應更高
• Android7.0 之前, 這個引數為 false
  • 使用預設的哈夫曼表, 不會去根據圖片進行特定的計算, 經 Google 測試, 圖片質量比使用哈夫曼低兩倍左右

初次之外早期的 Android 版本, 同樣考慮到效能問題, skia 引擎寫了一個函式替代了原來 libjpeg 的轉換函式, 好處是提高了編碼速度, 壞處就是犧牲了每一個畫素的精度

為了實現更快速更高質量的 JPEG 有失真壓縮, 因此筆者選擇編譯 libjpeg-turbo, 來處理專案中的圖片壓縮, 據官方介紹, 得益於它高度優化的哈夫曼演算法, 它比 libjpeg 要快上 2-6 倍, 接下來我們來一步一步的將它整合到專案中

一. 準備工作

一) 作業系統

Ubuntu-18.04.1

二) 依賴安裝

1. NDK

android-ndk-r16b-linux-x86_64.zip

2. CMake

CMake 3.12.1 的 Linux 版本

3. make

sudo apt-get install make
複製程式碼

4. libjpeg-turbo

從 Github 上下載最新的原始碼即可
github.com/libjpeg-tur…

註釋版本號

• 開啟 libjpeg-turbo/sharedLibs/CMakeList.txt, 將設定版本號的位置註釋, 否則在使用時, 可能會出現執行時缺少 so 庫的問題

二. 編譯

一) 指令碼編寫

Android 端指令碼編寫指南在 libjpeg-turbo 庫中的 BUILDING.md 中有說明

Building libjpeg-turbo for Android
----------------------------------

Building libjpeg-turbo for Android platforms requires v13b or later of the
[Android NDK](https://developer.android.com/tools/sdk/ndk).


### ARMv7 (32-bit)

The following is a general recipe script that can be modified for your specific
needs.

    # Set these variables to suit your needs
    NDK_PATH={full path to the NDK directory-- for example,
      /opt/android/android-ndk-r16b}
    TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r16b and earlier,
      and "clang" must be used with NDK r17c and later}
    ANDROID_VERSION={the minimum version of Android to support-- for example,
      "16", "19", etc.}

    cd {build_directory}
    cmake -G"Unix Makefiles" \
      -DANDROID_ABI=armeabi-v7a \
      -DANDROID_ARM_MODE=arm \
      -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
      -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
      -DCMAKE_ASM_FLAGS="--target=arm-linux-androideabi${ANDROID_VERSION}" \
      -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
      [additional CMake flags] {source_directory}
    make
......
複製程式碼

我們按照它的要求, 進行 shell 指令碼的編寫即可, 編寫後的shell 指令碼如下

#!/bin/sh

# lib-name
MY_LIBS_NAME=libjpeg-turbo
# 原始碼檔案目錄
MY_SOURCE_DIR=/home/sharry/Desktop/libjpeg-turbo-master
# 編譯的過程中產生的中介軟體的存放目錄，為了區分編譯目錄，原始碼目錄，install目錄
MY_BUILD_DIR=binary

##  CMake 環境變數
export PATH=/home/sharry/Desktop/cmake-3.12.1-Linux-x86_64/bin:$PATH

NDK_PATH=/home/sharry/Desktop/android-ndk-r16b
BUILD_PLATFORM=linux-x86_64
TOOLCHAIN_VERSION=4.9
ANDROID_VERSION=19

ANDROID_ARMV5_CFLAGS="-march=armv5te"
ANDROID_ARMV7_CFLAGS="-march=armv7-a -mfloat-abi=softfp -mfpu=neon"  # -mfpu=vfpv3-d16  -fexceptions -frtti
ANDROID_ARMV8_CFLAGS="-march=armv8-a"   # -mfloat-abi=softfp -mfpu=neon -fexceptions -frtti
ANDROID_X86_CFLAGS="-march=i386 -mtune=intel -mssse3 -mfpmath=sse -m32"
ANDROID_X86_64_CFLAGS="-march=x86-64 -msse4.2 -mpopcnt -m64 -mtune=intel"

# params($1:arch,$2:arch_abi,$3:host,$4:compiler,$5:cflags,$6:processor)
build_bin() {

    echo "-------------------star build $2-------------------------"

    ARCH=$1                # arm arm64 x86 x86_64
    ANDROID_ARCH_ABI=$2    # armeabi armeabi-v7a x86 mips
    # 最終編譯的安裝目錄
    PREFIX=$(pwd)/dist/${MY_LIBS_NAME}/${ANDROID_ARCH_ABI}/
    HOST=$3
    COMPILER=$4
    PROCESSOR=$6
    SYSROOT=${NDK_PATH}/platforms/android-${ANDROID_VERSION}/arch-${ARCH}
    CFALGS="$5"
    TOOLCHAIN=${NDK_PATH}/toolchains/${HOST}-${TOOLCHAIN_VERSION}/prebuilt/${BUILD_PLATFORM}
    
    # build 中介軟體
    BUILD_DIR=./${MY_BUILD_DIR}/${ANDROID_ARCH_ABI}

    export CFLAGS="$5 -Os -D__ANDROID_API__=${ANDROID_VERSION} --sysroot=${SYSROOT} \
                   -isystem ${NDK_PATH}/sysroot/usr/include \
                   -isystem ${NDK_PATH}/sysroot/usr/include/${HOST} "
    export LDFLAGS=-pie

    echo "path==>$PATH"
    echo "build_dir==>$BUILD_DIR"
    echo "ARCH==>$ARCH"
    echo "ANDROID_ARCH_ABI==>$ANDROID_ARCH_ABI"
    echo "HOST==>$HOST"
    echo "CFALGS==>$CFALGS"
    echo "COMPILER==>$COMPILER-gcc"
    echo "PROCESSOR==>$PROCESSOR"

    mkdir -p ${BUILD_DIR}   #建立當前arch_abi的編譯目錄,比如:binary/armeabi-v7a
    cd ${BUILD_DIR}         #此處 進了當前arch_abi的2級編譯目錄

# 執行時建立臨時編譯鏈檔案toolchain.cmake
cat >toolchain.cmake << EOF 
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR $6)
set(CMAKE_C_COMPILER ${TOOLCHAIN}/bin/${COMPILER}-gcc)
set(CMAKE_FIND_ROOT_PATH ${TOOLCHAIN}/${COMPILER})
EOF

    cmake -G"Unix Makefiles" \
          -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
          -DCMAKE_POSITION_INDEPENDENT_CODE=1 \
          -DCMAKE_INSTALL_PREFIX=${PREFIX} \
          -DWITH_JPEG8=1 \
          ${MY_SOURCE_DIR}

    make clean
    make
    make install

    #從當前arch_abi編譯目錄跳出，對應上面的cd ${BUILD_DIR},以便function多次執行
    cd ../../

    echo "-------------------$2 build end-------------------------"
}

# build armeabi
build_bin arm armeabi arm-linux-androideabi arm-linux-androideabi "$ANDROID_ARMV5_CFLAGS" arm
複製程式碼

二) 執行編譯指令碼

sh build.sh
複製程式碼

編譯執行之後, 便會輸出標頭檔案 和 armeabi 架構的 so 庫

三. 整合

一) 新增

將我們上面編譯好的 so 和標頭檔案拷貝到我們的專案中

二) CMake 連結

在 CMake 中將我們的動態了新增進去

# 連結標頭檔案
include_directories(${source_dir}/jniLibs/include)

# libjpeg-turbo
add_library(libjpeg SHARED IMPORTED)
set_target_properties(
        libjpeg
        PROPERTIES
        IMPORTED_LOCATION
        ${source_dir}/jniLibs/armeabi/libjpeg.so
)

# 將打包的 so 連結到專案中
target_link_libraries(
        ......
        libjpeg
        ......
)
複製程式碼

三) build.gradle

因為我們只編譯了 armeabi 架構的 so, 因此我們需要再 gradle 中新增 filters

android {
    compileSdkVersion 28
    defaultConfig {
        minSdkVersion 16
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        externalNativeBuild {
            ndk {
                abiFilters "armeabi" // 只生成 armeabi 的 CPU 架構的 .so
            }
        }
    }
}
複製程式碼

好的, 至此我們的整合就完成了, 接下來提供一些簡單的用法

四. 程式碼的編寫與測試

我們編譯 libjpeg-turbo 的主要目的就是為了進行 JPEG 的高質量壓縮, 關於 libjpeg-turbo 的使用, 這裡就不贅述了, 其官方提供好的 sample 如下
raw.githubusercontent.com/libjpeg-tur…

簡單的來說, 就是將 Bitmap 的顏色通道轉為 BGR, 然後傳給 libjpeg-turbo API 即可, 程式碼還是非常簡單的

extern "C"
JNIEXPORT jint JNICALL
Java_com_sharry_libscompressor_Core_nativeCompress(JNIEnv *env, jclass type, jobject bitmap,
                                                   jint quality, jstring destPath_) {
    // 1. 獲取 bitmap 資訊
    AndroidBitmapInfo info;
    AndroidBitmap_getInfo(env, bitmap, &info);
    int cols = info.width;
    int rows = info.height;
    int format = info.format;
    LOGE("->> Bitmap width is %d, height is %d", cols, rows);
    // 若不為 ARGB8888, 則不給予壓縮
    if (format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
        return false;
    }
    // 2. 解析資料
    LOGE("->> Parse bitmap pixels");
    // 鎖定畫布
    uchar *pixels = NULL;
    AndroidBitmap_lockPixels(env, bitmap, (void **) &pixels);
    // 建立儲存陣列
    uchar *data = (uchar *) malloc(static_cast<size_t>(cols * rows * 3));
    uchar *data_header_pointer = data;// 臨時儲存 data 的首地址, 用於後續釋放記憶體
    uchar r, g, b;
    int row = 0, col = 0, pixel;
    for (row = 0; row < rows; ++row) {
        for (col = 0; col < cols; ++col) {
            // 獲取二維陣列的每一個畫素資訊首地址
            pixel = *((int *) pixels);
            // ...                                              // 忽略 A 通道值
            r = static_cast<uchar>((pixel & 0x00FF0000) >> 16); // 獲取 R 通道值
            g = static_cast<uchar>((pixel & 0x0000FF00) >> 8);  // 獲取 G 通道值
            b = static_cast<uchar>((pixel & 0x000000FF));       // 獲取 B 通道值
            *data = b;
            *(data + 1) = g;
            *(data + 2) = r;
            data += 3;
            pixels += 4;
        }
    }
    // 解鎖畫布
    AndroidBitmap_unlockPixels(env, bitmap);
    // 3. 使用 libjpeg 進行圖片質量壓縮
    LOGE("->> Lib jpeg turbo do compress");
    char *output_filename = (char *) (env)->GetStringUTFChars(destPath_, 0);
    int result = LibJpegTurboUtils::write_JPEG_file(data_header_pointer, rows, cols, output_filename,
                                               quality);
    // 4. 釋放資源
    LOGE("->> Release memory");
    free((void *) data_header_pointer);
    env->ReleaseStringUTFChars(destPath_, output_filename);
    return result;
}
複製程式碼

效果展示

I/Core: Request{inputSourceType = String, outputSourceType = Bitmap, quality = 70, destWidth = -1, destHeight = -1}
// 取樣壓縮之後
E/Core_native: ->> Bitmap width is 1512, height is 2016
E/Core_native: ->> Parse bitmap pixels
E/Core_native: ->> Lib jpeg turbo do compress
E/Core_native: ->> Release memory
I/Core: ->> output file is: /data/user/0/com.sharry.scompressor/cache/1555157510264.jpg
// 質量壓縮之後
I/Core: ->> Output file length is 196kb
複製程式碼

可以看到 1512 x 2016 的圖片, 在 quality 為 70 的情況下壓縮之後, 為 196kb, 當然他的依舊是非常清晰的

總結

到這裡我們的編譯與整合就完成了, 整體的過程還是比較簡單的, 其效果也非常的 nice, 而且不會受到 Android SDK 版本的困擾, 感興趣的同學可以按照上述的方式試試看。

參考文獻

blog.csdn.net/yuxiatongzh…