Lots of improvements, allow to choose preferred config format

Author: awxkee

README.md

@@ -4,18 +4,19 @@ Library provides simple interface to decode or encode ( create ) AVIF and HEIF i
 Very fast and convinient to use AVIF in android apps with api version 24+
 26+. Based on libheif, libde265, libx265, libyuv, libaom and libdav1d
 
-Correctly handles ICC, and color profiles.
+Correctly handles ICC, and color profiles and HDR images.
 Fully supports HDR images, 10, 12 bit. Preprocess image in tile to increase speed.
-Extremly fast in decoding large HDR images or just large images
-The most features AVIF, HEIF library in android
+Extremly fast in decoding large HDR images or just large images.
+The most features AVIF, HEIF library in android.
+Supported decoding in all necessary pixel formats in Android and avoids android decoding bugs.
 
 # Usage example
 
 ```kotlin
 // May decode AVIF(AV1) and HEIC (HEVC) images, all HDR images currently will be converted in 8bit
 val bitmap: Bitmap = HeifCoder().decode(buffer) // Decode avif from ByteArray
 val bytes: ByteArray = HeifCoder().encodeAvif(decodedBitmap) // Encode Bitmap to AVIF
-val bytes = HeifCoder().encodeHeic(bitmap) // Encode Bitmap to HEIC / Supports HDR in RGBA_F16
+val bytes = HeifCoder().encodeHeic(bitmap) // Encode Bitmap to HEIC / Supports HDR in RGBA_F16, RGBA_1010102, HARDWARE
 // Check if image is valid AVIF(AV1) image
 val isAvif = HeifCoder().isAvif(byteArray)
 // Check if image is valid HEIF(HEVC) image

app/src/main/java/com/radzivon/bartoshyk/avif/MainActivity.kt

@@ -38,16 +38,22 @@ class MainActivity : AppCompatActivity() {
 
         // Example of a call to a native method
 //
-        val buffer = this.assets.open("federico-beccari-hlg.avif").source().buffer().readByteArray()
+        val buffer = this.assets.open("hato_custom_icc.avif").source().buffer().readByteArray()
 //        assert(HeifCoder().isAvif(buffer))
         val size = HeifCoder().getSize(buffer)!!
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             val time = measureTimeMillis {
+//                val bitmap = HeifCoder().decodeSampled(
+//                    buffer,
+//                    size.width / 2,
+//                    size.height / 2,
+//                    PreferredColorConfig.HARDWARE
+//                )
                 val bitmap = HeifCoder().decodeSampled(
                     buffer,
                     size.width / 2,
                     size.height / 2,
-                    PreferredColorConfig.RGBA_1010102
+                    PreferredColorConfig.HARDWARE
                 )
 //        val opts = BitmapFactory.Options()
 //        opts.inMutable = true

avif-coder/src/main/cpp/CMakeLists.txt

@@ -20,7 +20,8 @@ add_library(coder SHARED coder.cpp JniException.cpp scaler.cpp
         imagebits/RgbaF16bitToNBitU16.cpp imagebits/RgbaF16bitNBitU8.cpp imagebits/Rgb1010102.cpp
         colorspace/PerceptualQuantinizer.cpp ThreadPool.hpp
         imagebits/CopyUnalignedRGBA.cpp colorspace/HLG.cpp JniDecoder.cpp imagebits/Rgba8ToF16.cpp
-        imagebits/Rgb565.cpp JniBitmap.cpp ReformatBitmap.cpp Support.cpp IccRecognizer.cpp)
+        imagebits/Rgb565.cpp JniBitmap.cpp ReformatBitmap.cpp Support.cpp IccRecognizer.cpp
+        HardwareBuffersCompat.cpp)
 
 add_library(libaom STATIC IMPORTED)
 add_library(libx265 STATIC IMPORTED)

avif-coder/src/main/cpp/HardwareBuffersCompat.cpp

@@ -0,0 +1,88 @@
+//
+// Created by Radzivon Bartoshyk on 16/09/2023.
+//
+
+#include "HardwareBuffersCompat.h"
+
+#include <mutex>
+#include <dlfcn.h>
+#include "JniException.h"
+#include "jni.h"
+
+std::mutex dlMutex;
+
+bool alreadyHdBuffersLoaded = false;
+
+AHardwareBufferAllocateFunc AHardwareBuffer_allocate_compat = nullptr;
+AHardwareBufferIsSupportedFunc AHardwareBuffer_isSupported_compat = nullptr;
+AHardwareBufferUnlockFunc AHardwareBuffer_unlock_compat = nullptr;
+AHardwareBufferReleaseFunc AHardwareBuffer_release_compat = nullptr;
+AHardwareBufferLockFunc AHardwareBuffer_lock_compat = nullptr;
+AHardwareBufferToHardwareBufferFunc AHardwareBuffer_toHardwareBuffer_compat = nullptr;
+AHardwareBufferDescribeFunc AHardwareBuffer_describe_compat = nullptr;
+
+bool loadAHardwareBuffersAPI() {
+    // Bitmap doesn't support wrapping before 29 API
+    if (androidOSVersion() < 29) {
+        return false;
+    }
+    std::lock_guard guard(dlMutex);
+    if (alreadyHdBuffersLoaded) {
+        return AHardwareBuffer_allocate_compat != nullptr
+               && AHardwareBuffer_isSupported_compat != nullptr
+               && AHardwareBuffer_unlock_compat != nullptr
+               && AHardwareBuffer_release_compat != nullptr
+               && AHardwareBuffer_lock_compat != nullptr
+               && AHardwareBuffer_toHardwareBuffer_compat != nullptr
+               && AHardwareBuffer_describe_compat != nullptr;
+    }
+    alreadyHdBuffersLoaded = true;
+    void *hhl = dlopen("libandroid.so", RTLD_NOW);
+    if (!hhl) {
+        return false;
+    }
+
+    AHardwareBuffer_allocate_compat = (AHardwareBufferAllocateFunc) dlsym(hhl,
+                                                                          "AHardwareBuffer_allocate");
+    if (AHardwareBuffer_allocate_compat == nullptr) {
+        return false;
+    }
+
+    AHardwareBuffer_isSupported_compat = (AHardwareBufferIsSupportedFunc) dlsym(hhl,
+                                                                                "AHardwareBuffer_isSupported");
+    if (AHardwareBuffer_isSupported_compat == nullptr) {
+        return false;
+    }
+
+    AHardwareBuffer_unlock_compat = (AHardwareBufferUnlockFunc) dlsym(hhl,
+                                                                      "AHardwareBuffer_unlock");
+    if (AHardwareBuffer_unlock_compat == nullptr) {
+        return false;
+    }
+
+    AHardwareBuffer_release_compat = (AHardwareBufferReleaseFunc) dlsym(hhl,
+                                                                        "AHardwareBuffer_release");
+    if (AHardwareBuffer_release_compat == nullptr) {
+        return false;
+    }
+
+    AHardwareBuffer_lock_compat = (AHardwareBufferLockFunc) dlsym(hhl,
+                                                                  "AHardwareBuffer_lock");
+    if (AHardwareBuffer_lock_compat == nullptr) {
+        return false;
+    }
+
+    AHardwareBuffer_toHardwareBuffer_compat = (AHardwareBufferToHardwareBufferFunc) dlsym(hhl,
+                                                                                          "AHardwareBuffer_toHardwareBuffer");
+    if (AHardwareBuffer_toHardwareBuffer_compat == nullptr) {
+        return false;
+    }
+
+    AHardwareBuffer_describe_compat = (AHardwareBufferDescribeFunc) dlsym(hhl,
+                                                                          "AHardwareBuffer_describe");
+    if (AHardwareBuffer_describe_compat == nullptr) {
+        return false;
+    }
+
+    return true;
+}

avif-coder/src/main/cpp/HardwareBuffersCompat.h

@@ -0,0 +1,51 @@
+//
+// Created by Radzivon Bartoshyk on 16/09/2023.
+//
+
+#ifndef AVIF_HARDWAREBUFFERSCOMPAT_H
+#define AVIF_HARDWAREBUFFERSCOMPAT_H
+
+#include <android/bitmap.h>
+#include <android/hardware_buffer.h>
+#include <android/hardware_buffer_jni.h>
+
+bool loadAHardwareBuffersAPI();
+
+typedef int (*AHardwareBufferAllocateFunc)(
+        const AHardwareBuffer_Desc *_Nonnull desc, AHardwareBuffer *_Nullable *_Nonnull outBuffer
+);
+
+typedef int (*AHardwareBufferIsSupportedFunc)(
+        const AHardwareBuffer_Desc *_Nonnull desc
+);
+
+typedef int (*AHardwareBufferReleaseFunc)(
+        AHardwareBuffer *_Nonnull buffer
+);
+
+typedef int (*AHardwareBufferUnlockFunc)(
+        AHardwareBuffer *_Nonnull buffer, int32_t *_Nullable fence
+);
+
+typedef int (*AHardwareBufferLockFunc)(
+        AHardwareBuffer *_Nonnull buffer, uint64_t usage, int32_t fence,
+        const ARect *_Nullable rect, void *_Nullable *_Nonnull outVirtualAddress
+);
+
+typedef void (*AHardwareBufferDescribeFunc)(
+        const AHardwareBuffer *_Nonnull buffer, AHardwareBuffer_Desc *_Nonnull outDesc
+);
+
+typedef jobject (*AHardwareBufferToHardwareBufferFunc)(
+        JNIEnv *env, AHardwareBuffer *hardwareBuffer
+);
+
+extern AHardwareBufferAllocateFunc AHardwareBuffer_allocate_compat;
+extern AHardwareBufferIsSupportedFunc AHardwareBuffer_isSupported_compat;
+extern AHardwareBufferUnlockFunc AHardwareBuffer_unlock_compat;
+extern AHardwareBufferReleaseFunc AHardwareBuffer_release_compat;
+extern AHardwareBufferLockFunc AHardwareBuffer_lock_compat;
+extern AHardwareBufferToHardwareBufferFunc AHardwareBuffer_toHardwareBuffer_compat;
+extern AHardwareBufferDescribeFunc AHardwareBuffer_describe_compat;
+
+#endif //AVIF_HARDWAREBUFFERSCOMPAT_H

avif-coder/src/main/cpp/JniBitmap.cpp

@@ -11,7 +11,16 @@
 
 jobject
 createBitmap(JNIEnv *env, std::shared_ptr<uint8_t> &data, std::string &colorConfig, int stride,
-             int imageWidth, int imageHeight, bool use16Floats) {
+             int imageWidth, int imageHeight, bool use16Floats, jobject hwBuffer) {
+    if (colorConfig == "HARDWARE") {
+        jclass bitmapClass = env->FindClass("android/graphics/Bitmap");
+        jmethodID createBitmapMethodID = env->GetStaticMethodID(bitmapClass, "wrapHardwareBuffer",
+                                                                "(Landroid/hardware/HardwareBuffer;Landroid/graphics/ColorSpace;)Landroid/graphics/Bitmap;");
+        jobject emptyObject = nullptr;
+        jobject bitmapObj = env->CallStaticObjectMethod(bitmapClass, createBitmapMethodID,
+                                                        hwBuffer, emptyObject);
+        return bitmapObj;
+    }
     jclass bitmapConfig = env->FindClass("android/graphics/Bitmap$Config");
     jfieldID rgba8888FieldID = env->GetStaticFieldID(bitmapConfig, colorConfig.c_str(),
                                                      "Landroid/graphics/Bitmap$Config;");

avif-coder/src/main/cpp/JniBitmap.h

@@ -10,6 +10,6 @@
 
 jobject
 createBitmap(JNIEnv *env, std::shared_ptr<uint8_t> &data, std::string &colorConfig, int stride,
-             int imageWidth, int imageHeight, bool use16Floats);
+             int imageWidth, int imageHeight, bool use16Floats, jobject hwBuffer);
 
 #endif //AVIF_JNIBITMAP_H

avif-coder/src/main/cpp/JniDecoder.cpp

@@ -38,22 +38,25 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
     std::shared_ptr<heif_context> ctx(heif_context_alloc(),
                                       [](heif_context *c) { heif_context_free(c); });
     if (!ctx) {
-        throwCoderCreationException(env);
+        std::string exception = "Can't create HEIF/AVIF decoder due to unknown reason";
+        throwException(env, exception);
         return static_cast<jobject>(nullptr);
     }
 
     auto result = heif_context_read_from_memory_without_copy(ctx.get(), srcBuffer.data(),
                                                              srcBuffer.size(),
                                                              nullptr);
     if (result.code != heif_error_Ok) {
-        throwCannotReadFileException(env);
+        std::string exception = "Can't read heif file exception";
+        throwException(env, exception);
         return static_cast<jobject>(nullptr);
     }
 
     heif_image_handle *handle;
     result = heif_context_get_primary_image_handle(ctx.get(), &handle);
     if (result.code != heif_error_Ok) {
-        throwCannotReadFileException(env);
+        std::string exception = "Acquiring an image from file has failed";
+        throwException(env, exception);
         return static_cast<jobject>(nullptr);
     }
 
@@ -85,7 +88,8 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
 
     if (result.code != heif_error_Ok) {
         heif_image_handle_release(handle);
-        throwCantDecodeImageException(env);
+        std::string exception = "Decoding an image has failed";
+        throwException(env, exception);
         return static_cast<jobject>(nullptr);
     }
 
@@ -133,15 +137,18 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
             if (!data) {
                 heif_image_release(img);
                 heif_image_handle_release(handle);
-                throwCannotReadFileException(env);
+                std::string exception = "Interleaving planed has failed";
+                throwException(env, exception);
                 return nullptr;
             }
             imageWidth = heif_image_get_width(img, heif_channel_interleaved);
             imageHeight = heif_image_get_height(img, heif_channel_interleaved);
             if (result.code != heif_error_Ok) {
                 heif_image_release(img);
                 heif_image_handle_release(handle);
-                throwInvalidScale(env, result.message);
+                std::string cp(result.message);
+                std::string exception = "HEIF wasn't able to scale image due to " + cp;
+                throwException(env, exception);
                 return static_cast<jobject>(nullptr);
             }
 
@@ -159,7 +166,9 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
             if (result.code != heif_error_Ok) {
                 heif_image_release(img);
                 heif_image_handle_release(handle);
-                throwInvalidScale(env, result.message);
+                std::string cp(result.message);
+                std::string exception = "HEIF wasn't able to scale image due to " + cp;
+                throwException(env, exception);
                 return static_cast<jobject>(nullptr);
             }
 
@@ -169,7 +178,8 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
             if (!data) {
                 heif_image_release(scaledImg);
                 heif_image_handle_release(handle);
-                throwCannotReadFileException(env);
+                std::string exception = "Interleaving planed has failed";
+                throwException(env, exception);
                 return nullptr;
             }
             imageWidth = heif_image_get_width(scaledImg, heif_channel_interleaved);
@@ -187,7 +197,8 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
         if (!data) {
             heif_image_release(img);
             heif_image_handle_release(handle);
-            throwCannotReadFileException(env);
+            std::string exception = "Interleaving planed has failed";
+            throwException(env, exception);
             return nullptr;
         }
 
@@ -303,11 +314,13 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
 
     std::string imageConfig = useBitmapHalf16Floats ? "RGBA_F16" : "ARGB_8888";
 
-    ReformatColorConfig(dstARGB, imageConfig, preferredColorConfig, bitDepth, imageWidth,
-                        imageHeight, &stride, &useBitmapHalf16Floats);
+    jobject hwBuffer = nullptr;
+
+    ReformatColorConfig(env, dstARGB, imageConfig, preferredColorConfig, bitDepth, imageWidth,
+                        imageHeight, &stride, &useBitmapHalf16Floats, &hwBuffer);
 
     return createBitmap(env, dstARGB, imageConfig, stride, imageWidth, imageHeight,
-                        useBitmapHalf16Floats);
+                        useBitmapHalf16Floats, hwBuffer);
 }
 
 extern "C"
@@ -322,4 +335,23 @@ Java_com_radzivon_bartoshyk_avif_coder_HeifCoder_decodeImpl(JNIEnv *env, jobject
                             reinterpret_cast<jbyte *>(srcBuffer.data()));
     return decodeImplementationNative(env, thiz, srcBuffer, scaledWidth, scaledHeight,
                                       javaColorspace);
+}
+extern "C"
+JNIEXPORT jobject JNICALL
+Java_com_radzivon_bartoshyk_avif_coder_HeifCoder_decodeByteBufferImpl(JNIEnv *env, jobject thiz,
+                                                                      jobject byteBuffer,
+                                                                      jint scaledWidth,
+                                                                      jint scaledHeight,
+                                                                      jint clrConfig) {
+    auto bufferAddress = reinterpret_cast<uint8_t *>(env->GetDirectBufferAddress(byteBuffer));
+    int length = (int) env->GetDirectBufferCapacity(byteBuffer);
+    if (!bufferAddress || length <= 0) {
+        std::string errorString = "Only direct byte buffers are supported";
+        throwException(env, errorString);
+        return nullptr;
+    }
+    std::vector<uint8_t> srcBuffer(length);
+    std::copy(bufferAddress, bufferAddress + length, srcBuffer.begin());
+    return decodeImplementationNative(env, thiz, srcBuffer, scaledWidth, scaledHeight,
+                                      clrConfig);
 }