Done all proper color conversions

awxkee · awxkee · commit d6e18cbf4ca4 · 2023-09-05T22:05:06.000+04:00
diff --git a/app/src/main/java/com/radzivon/bartoshyk/avif/MainActivity.kt b/app/src/main/java/com/radzivon/bartoshyk/avif/MainActivity.kt
@@ -39,16 +39,19 @@ class MainActivity : AppCompatActivity() {
         val buffer = this.assets.open("hato-wide-gamut.avif").source().buffer().readByteArray()
 //        assert(HeifCoder().isAvif(buffer))
         val size = HeifCoder().getSize(buffer)!!
-        val bitmap = HeifCoder().decodeSampled(buffer, size.width / 3, size.height / 3)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val bitmap = HeifCoder().decodeSampled(buffer, size.width / 3, size.height / 3)
+                .copy(Bitmap.Config.RGBA_1010102, true)
 //        val opts = BitmapFactory.Options()
 //        opts.inMutable = true
 //        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
 //            opts.inPreferredConfig = Bitmap.Config.RGBA_F16
 //        }
-        binding.imageView.setImageBitmap(bitmap)
-        val encoded = HeifCoder().encodeAvif(bitmap)
-        val decodedSample = HeifCoder().decode(encoded)
-        binding.imageView.setImageBitmap(decodedSample)
+            binding.imageView.setImageBitmap(bitmap)
+            val encoded = HeifCoder().encodeHeic(bitmap)
+            val decodedSample = HeifCoder().decode(encoded)
+            binding.imageView.setImageBitmap(decodedSample)
+        }
 
 //        binding.imageView.load("https://wh.aimuse.online/creatives/IMUSE_03617fe2db82a584166_27/TT_a9d21ff1061d785347935fef/68f06252.avif",
 //            imageLoader = ImageLoader.Builder(this)
diff --git a/avif-coder/src/main/cpp/CMakeLists.txt b/avif-coder/src/main/cpp/CMakeLists.txt
@@ -18,7 +18,7 @@ add_library( # Sets the name of the library.
         icc/cmsgmt.c icc/cmshalf.c icc/cmsintrp.c icc/cmsio0.c icc/cmsio1.c icc/cmslut.c icc/cmsmd5.c icc/cmsmtrx.c icc/cmsnamed.c
         icc/cmsopt.c icc/cmspack.c icc/cmspcs.c icc/cmsplugin.c icc/cmsps2.c icc/cmssamp.c icc/cmssm.c icc/cmstypes.c icc/cmsvirt.c
         icc/cmswtpnt.c icc/cmsxform.c rgba_to_bgra_neon.cpp rgba_to_bgra.cpp colorspace.cpp halfFloats.cpp
-        rgba16bitCopy.cpp rgbaF16bitToNBitU16.cpp rgbaF16bitNBitU8.cpp)
+        rgba16bitCopy.cpp rgbaF16bitToNBitU16.cpp rgbaF16bitNBitU8.cpp rgb1010102.cpp)
 
 add_library(libaom STATIC IMPORTED)
 add_library(libx265 STATIC IMPORTED)
diff --git a/avif-coder/src/main/cpp/coder.cpp b/avif-coder/src/main/cpp/coder.cpp
@@ -20,6 +20,7 @@
 #include "rgba16bitCopy.h"
 #include "rgbaF16bitToNBitU16.h"
 #include "rgbaF16bitNBitU8.h"
+#include "rgb1010102.h"
 
 struct AvifMemEncoder {
     std::vector<char> buffer;
@@ -100,8 +101,10 @@ jbyteArray encodeBitmap(JNIEnv *env, jobject thiz,
 
     heif_image *image;
     heif_chroma chroma = heif_chroma_interleaved_RGBA;
-    if (info.format == ANDROID_BITMAP_FORMAT_RGBA_F16 &&
-        heifCompressionFormat == heif_compression_AV1) {
+    if ((info.format == ANDROID_BITMAP_FORMAT_RGBA_F16 &&
+         heifCompressionFormat == heif_compression_AV1) ||
+        (info.format == ANDROID_BITMAP_FORMAT_RGBA_1010102 &&
+         heifCompressionFormat == heif_compression_AV1)) {
         chroma = heif_chroma_interleaved_RRGGBBAA_LE;
     }
     result = heif_image_create((int) info.width, (int) info.height, heif_colorspace_RGB,
@@ -145,23 +148,13 @@ jbyteArray encodeBitmap(JNIEnv *env, jobject thiz,
         }
     } else if (info.format == ANDROID_BITMAP_FORMAT_RGBA_1010102) {
         if (heifCompressionFormat == heif_compression_HEVC) {
-            auto dstY = (char *) imgData;
-            auto srcY = (char *) sourceData.data();
-            for (int y = 0; y < info.height; ++y) {
-                memcpy(dstY, srcY, info.width * 4 * sizeof(uint32_t));
-                srcY += info.width * sizeof(uint64_t);
-                dstY += stride;
-            }
+            RGBA1010102ToU8(reinterpret_cast<uint8_t *>(sourceData.data()), (int) info.stride,
+                             reinterpret_cast<uint8_t *>(imgData), stride, (int) info.width,
+                             (int) info.height);
         } else {
-            libyuv::AR30ToARGB(sourceData.data(), (int) info.stride, imgData,
-                               stride, (int) info.width,
-                               (int) info.height);
-            for (int i = 0; i < stride / 4 * info.height; i += 4) {
-                imgData[i] = imgData[i + 1]; // R
-                imgData[i + 1] = imgData[i + 2]; // G
-                imgData[i + 2] = imgData[i + 3]; // B
-                imgData[i + 3] = imgData[i]; // A
-            }
+            RGBA1010102ToU16(reinterpret_cast<uint8_t *>(sourceData.data()), (int) info.stride,
+                             reinterpret_cast<uint16_t *>(imgData), stride, (int) info.width,
+                             (int) info.height);
         }
     } else if (info.format == ANDROID_BITMAP_FORMAT_RGBA_F16) {
         if (heifCompressionFormat == heif_compression_AV1) {
diff --git a/avif-coder/src/main/cpp/rgb1010102.cpp b/avif-coder/src/main/cpp/rgb1010102.cpp
@@ -0,0 +1,138 @@
+//
+// Created by Radzivon Bartoshyk on 05/09/2023.
+//
+
+#include "rgb1010102.h"
+#include <vector>
+
+void convertRGBA1010102ToU16_C(const uint8_t *src, int srcStride, uint16_t *dst, int dstStride,
+                               int width, int height) {
+    auto mDstPointer = reinterpret_cast<uint8_t *>(dst);
+    auto mSrcPointer = reinterpret_cast<const uint8_t *>(src);
+
+    uint32_t testValue = 0x01020304;
+    auto testBytes = reinterpret_cast<uint8_t *>(&testValue);
+
+    bool littleEndian = false;
+    if (testBytes[0] == 0x04) {
+        littleEndian = true;
+    } else if (testBytes[0] == 0x01) {
+        littleEndian = false;
+    }
+
+    for (int y = 0; y < height; ++y) {
+
+        auto dstPointer = reinterpret_cast<uint8_t *>(mDstPointer);
+        auto srcPointer = reinterpret_cast<const uint8_t *>(mSrcPointer);
+
+        for (int x = 0; x < width; ++x) {
+            uint32_t rgba1010102 = reinterpret_cast<const uint32_t *>(srcPointer)[0];
+
+            const uint32_t mask = (1u << 10u) - 1u;
+            uint32_t b = (rgba1010102) & mask;
+            uint32_t g = (rgba1010102 >> 10) & mask;
+            uint32_t r = (rgba1010102 >> 20) & mask;
+
+            uint32_t a1 = (rgba1010102 >> 30);
+            uint32_t a = (a1 << 8) | (a1 << 6) | (a1 << 4) | (a1 << 2) | a1;
+
+            // Convert each channel to floating-point values
+            auto rFloat = static_cast<uint16_t>(r);
+            auto gFloat = static_cast<uint16_t>(g);
+            auto bFloat = static_cast<uint16_t>(b);
+            auto aFloat = static_cast<uint16_t>(a);
+
+            auto dstCast = reinterpret_cast<uint16_t *>(dstPointer);
+            if (littleEndian) {
+                dstCast[0] = bFloat;
+                dstCast[1] = gFloat;
+                dstCast[2] = rFloat;
+                dstCast[3] = aFloat;
+            } else {
+                dstCast[0] = rFloat;
+                dstCast[1] = gFloat;
+                dstCast[2] = bFloat;
+                dstCast[3] = aFloat;
+            }
+
+            srcPointer += 4;
+            dstPointer += 8;
+        }
+
+        mSrcPointer += srcStride;
+        mDstPointer += dstStride;
+    }
+}
+
+void convertRGBA1010102ToU8_C(const uint8_t *src, int srcStride, uint8_t *dst, int dstStride,
+                              int width, int height) {
+    auto mDstPointer = reinterpret_cast<uint8_t *>(dst);
+    auto mSrcPointer = reinterpret_cast<const uint8_t *>(src);
+
+    uint32_t testValue = 0x01020304;
+    auto testBytes = reinterpret_cast<uint8_t *>(&testValue);
+
+    bool littleEndian = false;
+    if (testBytes[0] == 0x04) {
+        littleEndian = true;
+    } else if (testBytes[0] == 0x01) {
+        littleEndian = false;
+    }
+
+    for (int y = 0; y < height; ++y) {
+
+        auto dstPointer = reinterpret_cast<uint8_t *>(mDstPointer);
+        auto srcPointer = reinterpret_cast<const uint8_t *>(mSrcPointer);
+
+        for (int x = 0; x < width; ++x) {
+            uint32_t rgba1010102 = reinterpret_cast<const uint32_t *>(srcPointer)[0];
+
+            const uint32_t mask = (1u << 10u) - 1u;
+            uint32_t b = (rgba1010102) & mask;
+            uint32_t g = (rgba1010102 >> 10) & mask;
+            uint32_t r = (rgba1010102 >> 20) & mask;
+
+            uint32_t a1 = (rgba1010102 >> 30);
+            uint32_t a = (a1 << 8) | (a1 << 6) | (a1 << 4) | (a1 << 2) | a1;
+
+            // Convert each channel to floating-point values
+            auto rFloat = std::max(std::min(static_cast<uint8_t>((r * 255) / 1023), (uint8_t) 255),
+                                   (uint8_t) 0);
+            auto gFloat = std::max(std::min(static_cast<uint8_t>((g * 255) / 1023), (uint8_t) 255),
+                                   (uint8_t) 0);
+            auto bFloat = std::max(std::min(static_cast<uint8_t>((b * 255) / 1023), (uint8_t) 255),
+                                   (uint8_t) 0);
+            auto aFloat = std::max(std::min(static_cast<uint8_t>((a * 255) / 1023), (uint8_t) 255),
+                                   (uint8_t) 0);
+
+            auto dstCast = reinterpret_cast<uint8_t *>(dstPointer);
+            if (littleEndian) {
+                dstCast[0] = bFloat;
+                dstCast[1] = gFloat;
+                dstCast[2] = rFloat;
+                dstCast[3] = aFloat;
+            } else {
+                dstCast[0] = rFloat;
+                dstCast[1] = gFloat;
+                dstCast[2] = bFloat;
+                dstCast[3] = aFloat;
+            }
+
+            srcPointer += 4;
+            dstPointer += 4;
+        }
+
+        mSrcPointer += srcStride;
+        mDstPointer += dstStride;
+    }
+}
+
+void RGBA1010102ToU8(const uint8_t *src, int srcStride, uint8_t *dst, int dstStride,
+                     int width, int height) {
+    convertRGBA1010102ToU8_C(src, srcStride, dst, dstStride, width, height);
+}
+
+void RGBA1010102ToU16(const uint8_t *src, int srcStride, uint16_t *dst, int dstStride,
+                      int width, int height) {
+    convertRGBA1010102ToU16_C(src, srcStride, dst, dstStride, width, height);
+}
diff --git a/avif-coder/src/main/cpp/rgb1010102.h b/avif-coder/src/main/cpp/rgb1010102.h
@@ -0,0 +1,15 @@
+//
+// Created by Radzivon Bartoshyk on 05/09/2023.
+//
+
+#ifndef AVIF_RGB1010102_H
+#define AVIF_RGB1010102_H
+
+#include <vector>
+
+void RGBA1010102ToU16(const uint8_t *src, int srcStride, uint16_t *dst, int dstStride,
+                      int width, int height);
+void RGBA1010102ToU8(const uint8_t *src, int srcStride, uint8_t *dst, int dstStride,
+                     int width, int height);
+
+#endif //AVIF_RGB1010102_H
diff --git a/avif-coder/src/main/cpp/rgba16bitCopy.cpp b/avif-coder/src/main/cpp/rgba16bitCopy.cpp
@@ -29,7 +29,7 @@ void copyRGBA16_NEON(uint16_t* source, int srcStride,
             dstPtr += 8;
         }
 
-        for (x = 0; x < width; ++x) {
+        for (; x < width; ++x) {
             auto srcPtr64 = reinterpret_cast<uint64_t *>(srcPtr);
             auto dstPtr64 = reinterpret_cast<uint64_t *>(dstPtr);
             dstPtr64[0] = srcPtr64[0];
diff --git a/avif-coder/src/main/cpp/rgbaF16bitNBitU8.cpp b/avif-coder/src/main/cpp/rgbaF16bitNBitU8.cpp
@@ -48,7 +48,7 @@ void RGBAF16BitToNU8_NEON(const uint16_t *sourceData, int srcStride,
             srcPtr += 8;
         }
 
-        for (x = 0; x < width; ++x) {
+        for (; x < width; ++x) {
             auto alpha = half_to_float(srcPtr[3]);
             auto tmpR = (uint16_t) std::min(std::max((half_to_float(srcPtr[0]) / scale), 0.0f), maxColors);
             auto tmpG = (uint16_t) fmin(std::max((half_to_float(srcPtr[1]) / scale), 0.0f), maxColors);
diff --git a/avif-coder/src/main/cpp/rgbaF16bitToNBitU16.cpp b/avif-coder/src/main/cpp/rgbaF16bitToNBitU16.cpp
@@ -46,7 +46,7 @@ void RGBAF16BitToNU16_NEON(const uint16_t *sourceData, int srcStride, uint16_t *
             dstPtr += 8;
         }
 
-        for (x = 0; x < width; ++x) {
+        for (; x < width; ++x) {
             auto alpha = half_to_float(srcPtr[3]);
             auto tmpR = (uint16_t) std::min(std::max((half_to_float(srcPtr[0]) / scale), 0.0f),
                                             maxColors);

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ void copyRGBA16_NEON(uint16_t* source, int srcStride,`
`29`	`29`	`dstPtr += 8;`
`30`	`30`	`}`
`31`	`31`
`32`		`- for (x = 0; x < width; ++x) {`
	`32`	`+ for (; x < width; ++x) {`
`33`	`33`	`auto srcPtr64 = reinterpret_cast<uint64_t *>(srcPtr);`
`34`	`34`	`auto dstPtr64 = reinterpret_cast<uint64_t *>(dstPtr);`
`35`	`35`	`dstPtr64[0] = srcPtr64[0];`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ void RGBAF16BitToNU8_NEON(const uint16_t *sourceData, int srcStride,`
`48`	`48`	`srcPtr += 8;`
`49`	`49`	`}`
`50`	`50`
`51`		`- for (x = 0; x < width; ++x) {`
	`51`	`+ for (; x < width; ++x) {`
`52`	`52`	`auto alpha = half_to_float(srcPtr[3]);`
`53`	`53`	`auto tmpR = (uint16_t) std::min(std::max((half_to_float(srcPtr[0]) / scale), 0.0f), maxColors);`
`54`	`54`	`auto tmpG = (uint16_t) fmin(std::max((half_to_float(srcPtr[1]) / scale), 0.0f), maxColors);`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ void RGBAF16BitToNU16_NEON(const uint16_t sourceData, int srcStride, uint16_t `
`46`	`46`	`dstPtr += 8;`
`47`	`47`	`}`
`48`	`48`
`49`		`- for (x = 0; x < width; ++x) {`
	`49`	`+ for (; x < width; ++x) {`
`50`	`50`	`auto alpha = half_to_float(srcPtr[3]);`
`51`	`51`	`auto tmpR = (uint16_t) std::min(std::max((half_to_float(srcPtr[0]) / scale), 0.0f),`
`52`	`52`	`maxColors);`