Updates, color encoding

Author: awxkee

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

@@ -93,11 +93,11 @@ class MainActivity : AppCompatActivity() {
 
         // HDR EXAMPLES - https://us.zonerama.com/williamskeaguidingphotography/Photo/1000120226/1004888131
         lifecycleScope.launch(Dispatchers.IO) {
-            val buffer = this@MainActivity.assets.open("test_1.jpg").source().buffer().readByteArray()
+            val buffer = this@MainActivity.assets.open("test_2.jpg").source().buffer().readByteArray()
             var bitmap = BitmapFactory.decodeByteArray(buffer, 0, buffer.size)
 
             bitmap = bitmap.scale(bitmap.width / 2, bitmap.height / 2)
-                .copy(Bitmap.Config.RGBA_F16, true)
+                .copy(Bitmap.Config.RGBA_1010102, true)
             lifecycleScope.launch(Dispatchers.Main) {
                 val imageView = BindingImageViewBinding.inflate(layoutInflater, binding.scrollViewContainer, false)
                 imageView.root.setImageBitmap(bitmap)

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

@@ -206,6 +206,12 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
 
         float gamma = 1.0f;
 
+        if (nclx->transfer_characteristics !=
+            heif_transfer_characteristic_ITU_R_BT_2100_0_HLG &&
+            nclx->transfer_characteristics != heif_transfer_characteristic_ITU_R_BT_2100_0_PQ) {
+            toneMapper = TONE_SKIP;
+        }
+
         if (nclx->transfer_characteristics ==
             heif_transfer_characteristic_ITU_R_BT_2100_0_HLG) {
             function = HLG;
@@ -228,9 +234,9 @@ jobject decodeImplementationNative(JNIEnv *env, jobject thiz,
         } else if (nclx->transfer_characteristics ==
                    heif_transfer_characteristic_ITU_R_BT_601_6) {
             function = EOTF_BT601;
-        } else if (
-                nclx->transfer_characteristics == heif_transfer_characteristic_ITU_R_BT_709_5 ||
-                nclx->transfer_characteristics ==
+        } else if (nclx->transfer_characteristics == heif_transfer_characteristic_ITU_R_BT_709_5) {
+            function = EOTF_SRGB;
+        } else if (nclx->transfer_characteristics ==
                 heif_transfer_characteristic_ITU_R_BT_2020_2_10bit ||
                 nclx->transfer_characteristics ==
                 heif_transfer_characteristic_ITU_R_BT_2020_2_12bit) {

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

@@ -4,7 +4,7 @@
  * Copyright (c) 2023 Radzivon Bartoshyk
  * avif-coder [https://github.com/awxkee/avif-coder]
  *
- * Created by Radzivon Bartoshyk on 01/1/2023
+ * Created by Radzivon Bartoshyk on 01/01/2023
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

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

@@ -70,16 +70,14 @@ bool checkDecodePreconditions(JNIEnv *env, jint javaColorspace, PreferredColorCo
 
     auto mScaleMode = static_cast<ScaleMode>(javaScaleMode);
     if (!mScaleMode) {
-        std::string errorString =
-                "Invalid Scale Mode was passed";
+        std::string errorString = "Invalid Scale Mode was passed";
         throwException(env, errorString);
         return false;
     }
 
     auto mToneMapper = static_cast<CurveToneMapper>(javaToneMapper);
     if (!mScaleMode) {
-        std::string errorString =
-                "Invalid Tone mapper was requestedd";
+        std::string errorString = "Invalid Tone mapper was requestedd";
         throwException(env, errorString);
         return false;
     }

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

@@ -48,6 +48,7 @@
 #include "colorspace/HDRTransferAdapter.h"
 #include "imagebits/RGBAlpha.h"
 #include "imagebits/Rgb565.h"
+#include "DataSpaceToNCLX.hpp"
 
 using namespace std;
 
@@ -72,7 +73,7 @@ struct heif_error writeHeifData(struct heif_context *ctx,
 
 jbyteArray encodeBitmap(JNIEnv *env, jobject thiz,
                         jobject bitmap, heif_compression_format heifCompressionFormat,
-                        int quality) {
+                        int quality, int dataSpace) {
     std::shared_ptr<heif_context> ctx(heif_context_alloc(),
                                       [](heif_context *c) { heif_context_free(c); });
     if (!ctx) {
@@ -135,15 +136,31 @@ jbyteArray encodeBitmap(JNIEnv *env, jobject thiz,
          heifCompressionFormat == heif_compression_AV1)) {
         chroma = heif_chroma_interleaved_RRGGBBAA_LE;
     }
-    result = heif_image_create((int) info.width, (int) info.height, heif_colorspace_RGB,
-                               chroma, &image);
+
+    result = heif_image_create((int) info.width, (int) info.height,
+                               heif_colorspace_RGB, chroma, &image);
     if (result.code != heif_error_Ok) {
         std::string choke(result.message);
         std::string str = "Can't create encoded image with exception: " + choke;
         throwException(env, str);
         return static_cast<jbyteArray>(nullptr);
     }
 
+    std::shared_ptr<heif_color_profile_nclx> profile(heif_nclx_color_profile_alloc(), [](auto x) {
+        heif_nclx_color_profile_free(x);
+    });
+
+    bool nclxResult = coder::nclxFromDataSpace(dataSpace, profile.get());
+    if (nclxResult) {
+        result = heif_image_set_nclx_color_profile(image, profile.get());
+        if (result.code != heif_error_Ok) {
+            std::string choke(result.message);
+            std::string str = "Can't set required color profiel: " + choke;
+            throwException(env, str);
+            return static_cast<jbyteArray>(nullptr);
+        }
+    }
+
     int bitDepth = 8;
     if (info.format == ANDROID_BITMAP_FORMAT_RGB_565) {
         bitDepth = 8;
@@ -174,21 +191,24 @@ jbyteArray encodeBitmap(JNIEnv *env, jobject thiz,
                                  imgData, stride, (int) info.width, (int) info.height, 8, 255);
     } else if (info.format == ANDROID_BITMAP_FORMAT_RGBA_1010102) {
         if (heifCompressionFormat == heif_compression_HEVC) {
-            RGBA1010102ToU8(reinterpret_cast<uint8_t *>(sourceData.data()), (int) info.stride,
-                            reinterpret_cast<uint8_t *>(imgData), stride, (int) info.width,
-                            (int) info.height);
+            coder::RGBA1010102ToUnsigned(reinterpret_cast<const uint8_t *>(sourceData.data()),
+                                         (int) info.stride,
+                                         reinterpret_cast<uint8_t *>(imgData), stride,
+                                         (int) info.width, (int) info.height, 8);
+            heif_image_set_premultiplied_alpha(image, true);
         } else {
-            RGBA1010102ToU16(reinterpret_cast<uint8_t *>(sourceData.data()), (int) info.stride,
-                             reinterpret_cast<uint16_t *>(imgData), stride, (int) info.width,
-                             (int) info.height);
+            coder::RGBA1010102ToUnsigned(reinterpret_cast<uint8_t *>(sourceData.data()),
+                                         (int) info.stride,
+                                         reinterpret_cast<uint16_t *>(imgData), stride,
+                                         (int) info.width, (int) info.height, 10);
         }
     } else if (info.format == ANDROID_BITMAP_FORMAT_RGBA_F16) {
         if (heifCompressionFormat == heif_compression_AV1) {
             coder::RGBAF16BitToNBitU16(reinterpret_cast<const uint16_t *>(sourceData.data()),
-                                (int) info.stride,
-                                reinterpret_cast<uint16_t *>(imgData), stride,
-                                (int) info.width,
-                                (int) info.height, 10);
+                                       (int) info.stride,
+                                       reinterpret_cast<uint16_t *>(imgData), stride,
+                                       (int) info.width,
+                                       (int) info.height, 10);
         } else {
             coder::RGBAF16BitToNBitU8(reinterpret_cast<const uint16_t *>(sourceData.data()),
                                       (int) info.stride,
@@ -205,59 +225,11 @@ jbyteArray encodeBitmap(JNIEnv *env, jobject thiz,
                                                    });
     options->version = 5;
     options->image_orientation = heif_orientation_normal;
-//    options->output_nclx_profile = nullptr;
-//    options->save_two_colr_boxes_when_ICC_and_nclx_available = false;
 
     result = heif_context_encode_image(ctx.get(), image, encoder.get(), options.get(), &handle);
     options.reset();
     if (handle && result.code == heif_error_Ok) {
         heif_context_set_primary_image(ctx.get(), handle);
-//
-//        std::time_t currentTime = std::time(nullptr);
-//        std::tm *timeInfo = std::localtime(&currentTime);
-//
-//        // Format the date and time
-//        char formattedTime[20]; // Buffer for the formatted time
-//        std::strftime(formattedTime, sizeof(formattedTime), "%Y:%m:%d %H:%M:%S", timeInfo);
-//        std::string dateTime(formattedTime);
-//
-//        std::string format(heifCompressionFormat == heif_compression_AV1 ? "AVIF" : "HEIC");
-//
-//        std::string xmpMetadata = "<?xpacket begin='' id='W5M0MpCehiHzreSzNTczkc9d'?>"
-//                                  "<x:xmpmeta xmlns:x='adobe:ns:meta/' x:xmptk='XMP Core 5.5.0'>"
-//                                  "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>"
-//                                  "<rdf:Description rdf:about='' xmlns:dc='http://purl.org/dc/elements/1.1/'>"
-//                                  "<dc:title>Generated image by avif-coder</dc:title>"
-//                                  "<dc:creator>avif-coder</dc:creator>"
-//                                  "<dc:description>A image was created by avif-coder (https://github.com/awxkee/avif-coder)</dc:description>"
-//                                  "<dc:date>" + dateTime + "</dc:date>\n"
-//                                                           "<dc:publisher>https://github.com/awxkee/avif-coder>"
-//                                                           "<dc:format>" + format + "</dc:format>"
-//                                                                                    "</rdf:Description>"
-//                                                                                    "<rdf:Description rdf:about='' xmlns:exif='http://ns.adobe.com/exif/1.0/'>\n"
-//                                                                                    "<exif:ColorSpace>sRGB</exif:ColorSpace>\n"
-//                                                                                    "<exif:ColorProfile>sRGB IEC61966-2.1</exif:ColorProfile>\n"
-//                                                                                    "</rdf:Description>\n"
-//                                                                                    "<rdf:Description rdf:about='' xmlns:xmp='http://ns.adobe.com/xap/1.0/'>\n"
-//                                                                                    "<xmp:CreatorTool>avif-coder (https://github.com/awxkee/avif-coder)</xmp:CreatorTool>\n"
-//                                                                                    "<xmp:ModifyDate>" +
-//                                  dateTime +
-//                                  "</xmp:ModifyDate>\n"
-//                                  "</rdf:Description>\n"
-//                                  "</rdf:RDF>"
-//                                  "</x:xmpmeta>"
-//                                  "<?xpacket end='w'?>";
-//
-//        result = heif_context_add_XMP_metadata(ctx.get(), handle,
-//                                               reinterpret_cast<const void *>(xmpMetadata.data()),
-//                                               static_cast<int>(xmpMetadata.size()));
-//        if (result.code != heif_error_Ok) {
-//            heif_image_handle_release(handle);
-//            heif_image_release(image);
-//            throwCantEncodeImageException(env, result.message);
-//            return static_cast<jbyteArray>(nullptr);
-//        }
-
         heif_image_handle_release(handle);
     }
     heif_image_release(image);
@@ -293,9 +265,10 @@ jbyteArray encodeBitmap(JNIEnv *env, jobject thiz,
 extern "C"
 JNIEXPORT jbyteArray JNICALL
 Java_com_radzivon_bartoshyk_avif_coder_HeifCoder_encodeAvifImpl(JNIEnv *env, jobject thiz,
-                                                                jobject bitmap, jint quality) {
+                                                                jobject bitmap, jint quality,
+                                                                jint dataSpace) {
     try {
-        return encodeBitmap(env, thiz, bitmap, heif_compression_AV1, quality);
+        return encodeBitmap(env, thiz, bitmap, heif_compression_AV1, quality, dataSpace);
     } catch (std::bad_alloc &err) {
         std::string exception = "Not enough memory to encode this image";
         throwException(env, exception);
@@ -306,9 +279,10 @@ Java_com_radzivon_bartoshyk_avif_coder_HeifCoder_encodeAvifImpl(JNIEnv *env, job
 extern "C"
 JNIEXPORT jbyteArray JNICALL
 Java_com_radzivon_bartoshyk_avif_coder_HeifCoder_encodeHeicImpl(JNIEnv *env, jobject thiz,
-                                                                jobject bitmap, jint quality) {
+                                                                jobject bitmap, jint quality,
+                                                                jint dataSpace) {
     try {
-        return encodeBitmap(env, thiz, bitmap, heif_compression_HEVC, quality);
+        return encodeBitmap(env, thiz, bitmap, heif_compression_HEVC, quality, dataSpace);
     } catch (std::bad_alloc &err) {
         std::string exception = "Not enough memory to encode this image";
         throwException(env, exception);

avif-coder/src/main/cpp/colorspace/DataSpaceToNCLX.hpp

@@ -0,0 +1,115 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Radzivon Bartoshyk
+ * avif-coder [https://github.com/awxkee/avif-coder]
+ *
+ * Created by Radzivon Bartoshyk on 07/03/2024
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#pragma once
+
+#include <android/data_space.h>
+#include "libheif/heif.h"
+#include "Eigen/Eigen"
+#include "ColorSpaceProfile.h"
+
+namespace coder {
+    bool nclxFromDataSpace(int dataSpace, heif_color_profile_nclx *profile) {
+        if (dataSpace == -1) {
+            return false;
+        }
+
+        bool isResolved = false;
+
+        if (dataSpace == ADataSpace::ADATASPACE_UNKNOWN) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_709_5;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_709_5;
+            isResolved = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_BT709) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_709_5;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_709_5;
+            isResolved = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_SRGB) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_709_5;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_709_5;
+            isResolved = true;
+            profile->full_range_flag = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_BT2020) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_2020_2_10bit;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_2020_2_and_2100_0;
+            isResolved = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_DISPLAY_P3) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_709_5;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance;
+            profile->color_primaries = heif_color_primaries_SMPTE_EG_432_1;
+            profile->full_range_flag = true;
+            isResolved = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_DCI_P3) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance;
+            profile->color_primaries = heif_color_primaries_SMPTE_EG_432_1;
+            profile->full_range_flag = true;
+            isResolved = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_SCRGB_LINEAR) {
+            profile->transfer_characteristics = heif_transfer_characteristic_linear;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_709_5;
+            isResolved = true;
+        } else if ((dataSpace == ADataSpace::ADATASPACE_BT2020_ITU_PQ ||
+                    dataSpace == ADataSpace::ADATASPACE_BT2020_HLG ||
+                    dataSpace == ADataSpace::ADATASPACE_BT2020_ITU_HLG)) {
+            heif_transfer_characteristics transfer = heif_transfer_characteristic_ITU_R_BT_2100_0_PQ;
+            if (dataSpace == ADataSpace::ADATASPACE_BT2020_HLG ||
+                dataSpace == ADataSpace::ADATASPACE_BT2020_ITU_HLG) {
+                transfer = heif_transfer_characteristic_ITU_R_BT_2100_0_HLG;
+            }
+            profile->transfer_characteristics = transfer;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_2020_2_and_2100_0;
+            isResolved = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_ADOBE_RGB) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_709_5;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5;
+            profile->color_primaries = heif_color_primaries_unspecified;
+            isResolved = true;
+        } else if (dataSpace == ADataSpace::ADATASPACE_BT601_525 ||
+                   dataSpace == ADataSpace::ADATASPACE_BT601_625 ||
+                   dataSpace == ADataSpace::ADATASPACE_JFIF) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_601_6;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_601_6;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_601_6;
+            isResolved = true;
+        } else if (dataSpace & ADataSpace::STANDARD_BT470M) {
+            profile->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G;
+            profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G;
+            profile->color_primaries = heif_color_primaries_ITU_R_BT_470_6_System_M;
+            isResolved = true;
+        }
+
+        return isResolved;
+    }
+}