Added Proper scaling

Author: awxkee

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

@@ -16,6 +16,7 @@ import coil.load
 import com.github.awxkee.avifcoil.HeifDecoder
 import com.radzivon.bartoshyk.avif.coder.HeifCoder
 import com.radzivon.bartoshyk.avif.coder.PreferredColorConfig
+import com.radzivon.bartoshyk.avif.coder.ScaleMode
 import com.radzivon.bartoshyk.avif.databinding.ActivityMainBinding
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -38,7 +39,7 @@ class MainActivity : AppCompatActivity() {
 
         // Example of a call to a native method
 //
-        val buffer = this.assets.open("hato_custom_icc.avif").source().buffer().readByteArray()
+        val buffer = this.assets.open("federico-beccari-hlg.avif").source().buffer().readByteArray()
 //        assert(HeifCoder().isAvif(buffer))
         val size = HeifCoder().getSize(buffer)!!
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
@@ -51,9 +52,10 @@ class MainActivity : AppCompatActivity() {
 //                )
                 val bitmap = HeifCoder().decodeSampled(
                     buffer,
-                    size.width / 2,
-                    size.height / 2,
-                    PreferredColorConfig.HARDWARE
+                    350,
+                    600,
+                    PreferredColorConfig.HARDWARE,
+                    ScaleMode.FIT
                 )
 //        val opts = BitmapFactory.Options()
 //        opts.inMutable = true
@@ -68,7 +70,10 @@ class MainActivity : AppCompatActivity() {
 //            binding.imageView.setImageBitmap(bitmap)
         }
 
-//        binding.imageView.load("https://wh.aimuse.online/creatives/IMUSE_03617fe2db82a584166_27/TT_a9d21ff1061d785347935fef/68f06252.avif",
+        //https://wh.aimuse.online/creatives/IMUSE_03617fe2db82a584166_27/TT_a9d21ff1061d785347935fef/68f06252.avif
+        //https://wh.aimuse.online/preset/federico-beccari.avif
+
+//        binding.imageView.load("https://wh.aimuse.online/preset/avif10bit.avif",
 //            imageLoader = ImageLoader.Builder(this)
 //                .components {
 //                    add(HeifDecoder.Factory())

app/src/main/res/layout/activity_main.xml

@@ -18,9 +18,9 @@
 
     <ImageView
         android:id="@+id/imageView"
-        android:layout_width="0dp"
-        android:layout_height="0dp"
-        android:scaleType="fitCenter"
+        android:layout_width="240dp"
+        android:layout_height="320dp"
+        android:scaleType="centerCrop"
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"

avif-coder-coil/src/main/java/com/github/awxkee/avifcoil/HeifDecoder.kt

@@ -5,6 +5,7 @@ import android.graphics.Canvas
 import android.graphics.Matrix
 import android.graphics.Paint
 import android.graphics.drawable.BitmapDrawable
+import android.os.Build
 import android.util.Size
 import coil.ImageLoader
 import coil.decode.DecodeResult
@@ -14,6 +15,8 @@ import coil.request.Options
 import coil.size.Scale
 import coil.size.pxOrElse
 import com.radzivon.bartoshyk.avif.coder.HeifCoder
+import com.radzivon.bartoshyk.avif.coder.PreferredColorConfig
+import com.radzivon.bartoshyk.avif.coder.ScaleMode
 import kotlinx.coroutines.runInterruptible
 import okio.ByteString.Companion.encodeUtf8
 
@@ -24,91 +27,60 @@ class HeifDecoder(
 ) : Decoder {
 
     override suspend fun decode(): DecodeResult? = runInterruptible {
+        // ColorSpace is preferred to be ignored due to lib is trying to handle all color profile by itself
         val sourceData = source.source.source().readByteArray()
-        val originalSize = HeifCoder().getSize(sourceData) ?: return@runInterruptible null
-        val dstWidth = options.size.width.pxOrElse { 0 }
-        val dstHeight = options.size.height.pxOrElse { 0 }
-        if (options.scale == Scale.FIT) {
-            val scaledSize = aspectScale(originalSize, Size(dstWidth, dstHeight))
+
+        var mPreferredColorConfig: PreferredColorConfig = when (options.config) {
+            Bitmap.Config.ALPHA_8 -> PreferredColorConfig.RGBA_8888
+            Bitmap.Config.RGB_565 -> if (options.allowRgb565) PreferredColorConfig.RGB_565 else PreferredColorConfig.DEFAULT
+            Bitmap.Config.ARGB_8888 -> PreferredColorConfig.RGBA_8888
+            else -> PreferredColorConfig.DEFAULT
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && options.config == Bitmap.Config.RGBA_F16) {
+            mPreferredColorConfig = PreferredColorConfig.RGBA_F16
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && options.config == Bitmap.Config.HARDWARE) {
+            mPreferredColorConfig = PreferredColorConfig.HARDWARE
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && options.config == Bitmap.Config.RGBA_1010102) {
+            mPreferredColorConfig = PreferredColorConfig.RGBA_1010102
+        }
+
+        if (options.size == coil.size.Size.ORIGINAL) {
             val originalImage =
-                HeifCoder().decodeSampled(sourceData, scaledSize.width, scaledSize.height)
+                HeifCoder().decode(
+                    sourceData,
+                    preferredColorConfig = mPreferredColorConfig
+                )
             return@runInterruptible DecodeResult(
                 BitmapDrawable(
                     options.context.resources,
                     originalImage
-                ), true
+                ), false
             )
         }
-        val isHorizontal = originalSize.width > originalSize.height
-        val square = originalSize.width * originalSize.height
-        val maxSquare = 2480 * 1440
-        val targetSizeNotAspect: Size =
-            if (square > maxSquare) (if (isHorizontal) Size(
-                2480,
-                1440
-            ) else Size(
-                1440,
-                2480
-            )) else originalSize
-        val aspectSize = aspectScale(originalSize, targetSizeNotAspect)
+
+        val dstWidth = options.size.width.pxOrElse { 0 }
+        val dstHeight = options.size.height.pxOrElse { 0 }
+        val scaleMode = when (options.scale) {
+            Scale.FILL -> ScaleMode.FILL
+            Scale.FIT -> ScaleMode.FIT
+        }
+
         val originalImage =
-            HeifCoder().decodeSampled(sourceData, aspectSize.width, aspectSize.height)
-        val resizedBitmap = resizeAspectFill(originalImage, Size(dstWidth, dstHeight))
-        originalImage.recycle()
+            HeifCoder().decodeSampled(
+                sourceData,
+                dstWidth,
+                dstHeight,
+                preferredColorConfig = mPreferredColorConfig,
+                scaleMode,
+            )
         return@runInterruptible DecodeResult(
             BitmapDrawable(
                 options.context.resources,
-                resizedBitmap
+                originalImage
             ), true
         )
     }
 
-    private fun resizeAspectFill(sourceBitmap: Bitmap, dstSize: Size): Bitmap {
-        val background = Bitmap.createBitmap(dstSize.width, dstSize.height, sourceBitmap.config)
-        val originalWidth: Float = background.width.toFloat()
-        val originalHeight: Float = background.height.toFloat()
-        val canvas = Canvas(background)
-
-        val scale: Float =
-            if (dstSize.height > dstSize.width) dstSize.height / originalHeight else dstSize.width / originalWidth
-
-        val xTranslation = (dstSize.width - originalWidth * scale) / 2.0f
-        val yTranslation: Float = (dstSize.height - originalHeight * scale) / 2.0f
-
-        val transformation = Matrix()
-        transformation.postTranslate(xTranslation, yTranslation)
-        transformation.preScale(scale, scale)
-
-        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
-        paint.isFilterBitmap = true
-
-        canvas.drawBitmap(sourceBitmap, transformation, paint)
-        return background
-    }
-
-    private fun aspectScale(
-        sourceSize: Size,
-        dstSize: Size
-    ): Size {
-        val isHorizontal = sourceSize.width > sourceSize.height
-        val targetSize =
-            if (isHorizontal) dstSize else Size(dstSize.height, dstSize.width)
-        if (targetSize.width > sourceSize.width && targetSize.height > sourceSize.height) {
-            return sourceSize
-        }
-        val imageAspectRatio = sourceSize.width.toFloat() / sourceSize.height.toFloat()
-        val canvasAspectRation = targetSize.width.toFloat() / targetSize.height.toFloat()
-        val resizeFactor: Float = if (imageAspectRatio > canvasAspectRation) {
-            targetSize.width.toFloat() / sourceSize.width.toFloat()
-        } else {
-            targetSize.height.toFloat() / sourceSize.height.toFloat()
-        }
-        return Size(
-            (sourceSize.width.toFloat() * resizeFactor).toInt(),
-            (sourceSize.height.toFloat() * resizeFactor).toInt()
-        )
-    }
-
     class Factory : Decoder.Factory {
         override fun create(
             result: SourceResult,

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

@@ -9,7 +9,7 @@ cmake_minimum_required(VERSION 3.22.1)
 
 project("coder")
 
-add_library(coder SHARED coder.cpp JniException.cpp scaler.cpp
+add_library(coder SHARED coder.cpp JniException.cpp SizeScaler.cpp
         icc/cmsalpha.c icc/cmscam02.c
         icc/cmscgats.c icc/cmscnvrt.c icc/cmserr.c icc/cmsgamma.c
         icc/cmsgmt.c icc/cmshalf.c icc/cmsintrp.c icc/cmsio0.c
@@ -61,7 +61,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 if (CMAKE_BUILD_TYPE STREQUAL "Release")
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -ffp-mode=fast")
 endif ()
-add_definitions(-DCMS_NO_REGISTER_KEYWORD)
+add_definitions(-DCMS_NO_REGISTER_KEYWORD -DSTB_IMAGE_RESIZE_IMPLEMENTATION)
 
 set(CMAKE_ANDROID_API_MIN 24)
 

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

@@ -9,7 +9,7 @@
 #include "libyuv/convert_argb.h"
 #include <vector>
 #include "JniException.h"
-#include "scaler.h"
+#include "SizeScaler.h"
 #include <android/log.h>
 #include <android/data_space.h>
 #include <sys/system_properties.h>
@@ -31,9 +31,13 @@
 
 jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
                                    std::vector<uint8_t> &srcBuffer, jint scaledWidth,
-                                   jint scaledHeight, jint javaColorspace) {
+                                   jint scaledHeight, jint javaColorSpace, jint javaScaleMode) {
     PreferredColorConfig preferredColorConfig;
-    checkDecodePreconditions(env, javaColorspace, &preferredColorConfig);
+    ScaleMode scaleMode;
+    if (!checkDecodePreconditions(env, javaColorSpace, &preferredColorConfig, javaScaleMode,
+                                  &scaleMode)) {
+        return static_cast<jobject>(nullptr);
+    }
 
     std::shared_ptr<heif_context> ctx(heif_context_alloc(),
                                       [](heif_context *c) { heif_context_free(c); });
@@ -131,87 +135,13 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
     int stride;
     std::vector<uint8_t> initialData;
 
-    if (scaledHeight > 0 && scaledWidth > 0) {
-        if (bitDepth == 8) {
-            auto data = heif_image_get_plane_readonly(img, heif_channel_interleaved, &stride);
-            if (!data) {
-                heif_image_release(img);
-                heif_image_handle_release(handle);
-                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);
-                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);
-            }
-
-            // For unknown reason some images doesn't scale properly by libheif in 8-bit
-            initialData.resize(scaledWidth * 4 * scaledHeight);
-            libyuv::ARGBScale(data, stride, imageWidth, imageHeight, initialData.data(),
-                              scaledWidth * 4, scaledWidth, scaledHeight, libyuv::kFilterBox);
-            stride = scaledWidth * 4;
-            imageHeight = scaledHeight;
-            imageWidth = scaledWidth;
-            heif_image_release(img);
-        } else {
-            heif_image *scaledImg;
-            result = heif_image_scale_image(img, &scaledImg, scaledWidth, scaledHeight, nullptr);
-            if (result.code != heif_error_Ok) {
-                heif_image_release(img);
-                heif_image_handle_release(handle);
-                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);
-            }
-
-            heif_image_release(img);
-
-            auto data = heif_image_get_plane_readonly(scaledImg, heif_channel_interleaved, &stride);
-            if (!data) {
-                heif_image_release(scaledImg);
-                heif_image_handle_release(handle);
-                std::string exception = "Interleaving planed has failed";
-                throwException(env, exception);
-                return nullptr;
-            }
-            imageWidth = heif_image_get_width(scaledImg, heif_channel_interleaved);
-            imageHeight = heif_image_get_height(scaledImg, heif_channel_interleaved);
-            initialData.resize(stride * imageHeight);
-            coder::CopyUnalignedRGBA(reinterpret_cast<const uint8_t *>(data), stride,
-                                     reinterpret_cast<uint8_t *>(initialData.data()), stride,
-                                     imageWidth,
-                                     imageHeight, useBitmapHalf16Floats ? 2 : 1);
-            heif_image_release(scaledImg);
-        }
-
-    } else {
-        auto data = heif_image_get_plane_readonly(img, heif_channel_interleaved, &stride);
-        if (!data) {
-            heif_image_release(img);
-            heif_image_handle_release(handle);
-            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);
-        initialData.resize(stride * imageHeight);
-
-        coder::CopyUnalignedRGBA(reinterpret_cast<const uint8_t *>(data), stride,
-                                 reinterpret_cast<uint8_t *>(initialData.data()), stride,
-                                 imageWidth,
-                                 imageHeight, useBitmapHalf16Floats ? 2 : 1);
-
-        heif_image_release(img);
+    imageWidth = heif_image_get_width(img, heif_channel_interleaved);
+    imageHeight = heif_image_get_height(img, heif_channel_interleaved);
+    auto scaleResult = RescaleImage(initialData, env, handle, img, &stride, useBitmapHalf16Floats,
+                                    &imageWidth, &imageHeight, scaledWidth, scaledHeight,
+                                    scaleMode);
+    if (!scaleResult) {
+        return static_cast<jobject >(nullptr);
     }
 
     std::shared_ptr<uint8_t> dstARGB(static_cast<uint8_t *>(malloc(stride * imageHeight)),
@@ -328,21 +258,22 @@ JNIEXPORT jobject JNICALL
 Java_com_radzivon_bartoshyk_avif_coder_HeifCoder_decodeImpl(JNIEnv *env, jobject thiz,
                                                             jbyteArray byte_array, jint scaledWidth,
                                                             jint scaledHeight,
-                                                            jint javaColorspace) {
+                                                            jint javaColorspace, jint scaleMode) {
     auto totalLength = env->GetArrayLength(byte_array);
     std::vector<uint8_t> srcBuffer(totalLength);
     env->GetByteArrayRegion(byte_array, 0, totalLength,
                             reinterpret_cast<jbyte *>(srcBuffer.data()));
     return decodeImplementationNative(env, thiz, srcBuffer, scaledWidth, scaledHeight,
-                                      javaColorspace);
+                                      javaColorspace, scaleMode);
 }
 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) {
+                                                                      jint clrConfig,
+                                                                      jint scaleMode) {
     auto bufferAddress = reinterpret_cast<uint8_t *>(env->GetDirectBufferAddress(byteBuffer));
     int length = (int) env->GetDirectBufferCapacity(byteBuffer);
     if (!bufferAddress || length <= 0) {
@@ -353,5 +284,5 @@ Java_com_radzivon_bartoshyk_avif_coder_HeifCoder_decodeByteBufferImpl(JNIEnv *en
     std::vector<uint8_t> srcBuffer(length);
     std::copy(bufferAddress, bufferAddress + length, srcBuffer.begin());
     return decodeImplementationNative(env, thiz, srcBuffer, scaledWidth, scaledHeight,
-                                      clrConfig);
+                                      clrConfig, scaleMode);
 }

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

@@ -16,12 +16,6 @@ jint throwHardwareBitmapException(JNIEnv *env) {
     return env->ThrowNew(exClass, "");
 }
 
-jint throwCantEncodeImageException(JNIEnv *env, const char * msg) {
-    jclass exClass;
-    exClass = env->FindClass("com/radzivon/bartoshyk/avif/coder/CantEncodeImageException");
-    return env->ThrowNew(exClass, msg);
-}
-
 jint throwInvalidPixelsFormat(JNIEnv *env) {
     jclass exClass;
     exClass = env->FindClass("com/radzivon/bartoshyk/avif/coder/UnsupportedImageFormatException");

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

@@ -10,8 +10,6 @@
 
 jint throwBitDepthException(JNIEnv *env);
 
-jint throwCantEncodeImageException(JNIEnv *env, const char *msg);
-
 jint throwInvalidPixelsFormat(JNIEnv *env);
 
 jint throwPixelsException(JNIEnv *env);