include: update VendorVideoAPI for HDR10+

3351e728e include: define USE_FULL_ST2094_40_INFO only at specific device
e7f44aafe videoapi: featuring supporting range of HDR10+
32fba1860 include: rearrange location of struct member
618fe6a36 add hdr type info and reserved field at struct ExynosVideoMeta
4a92ac4df added ExynosHdrDynamicBlob for HDR10+ full spec support
5a9254872 videoapi: supports full spec of HDR10+(ST2094-40)
88555c82f videoapi: modified ExynosHdrDynamicInfo struct
ad676b77e include: reorganize struct ExynosVideoMeta
dfd94ea49 update VendorVideoAPI.h

Bug: 233398860
Test: run cts -m CtsMediaV2TestCases -t android.mediav2.cts.EncoderHDRInfoTest
Test: run cts -m CtsMediaV2TestCases -t android.mediav2.cts.DecoderHDRInfoTest
Test: run cts -m CtsMediaDecoderTestCases -t android.media.decoder.cts.HDRDecoderTest
Signed-off-by: Taehwan Kim <t_h.kim@samsung.com>
Change-Id: I8bb4992c427757716316e92bd7035b485299056b
Signed-off-by: wenchangliu <wenchangliu@google.com>

3 files changed, 1417 insertions, 109 deletions

diff --git a/include/VendorVideoAPI.h b/include/VendorVideoAPI.h
index 290cfae..15ba530 100644
--- a/include/VendorVideoAPI.h
+++ b/include/VendorVideoAPI.h
@@ -81,37 +81,93 @@ typedef struct _ExynosHdrStaticInfo {
     };
 } ExynosHdrStaticInfo;
 
-typedef struct _ExynosHdrDynamicInfo {
-    unsigned int valid;
-
-    struct {
-        unsigned char  country_code;
-        unsigned short provider_code;
-        unsigned short provider_oriented_code;
-
-        unsigned char  application_identifier;
-        unsigned short application_version;
-
-        unsigned int  display_maximum_luminance;
+#ifdef USE_FULL_ST2094_40
+#define USE_FULL_ST2094_40_INFO
+#endif
 
-        unsigned int maxscl[3];
+typedef struct _ExynosHdrData_ST2094_40 {
+    unsigned char  country_code;
+    unsigned short provider_code;
+    unsigned short provider_oriented_code;
+
+    unsigned char  application_identifier;
+    unsigned char  application_version;
+
+#ifdef USE_FULL_ST2094_40
+    unsigned char num_windows;
+
+    unsigned short window_upper_left_corner_x[2];
+    unsigned short window_upper_left_corner_y[2];
+    unsigned short window_lower_right_corner_x[2];
+    unsigned short window_lower_right_corner_y[2];
+    unsigned short center_of_ellipse_x[2];
+    unsigned short center_of_ellipse_y[2];
+    unsigned char  rotation_angle[2];
+    unsigned short semimajor_axis_internal_ellipse[2];
+    unsigned short semimajor_axis_external_ellipse[2];
+    unsigned short semiminor_axis_external_ellipse[2];
+    unsigned char  overlap_process_option[2];
+
+    unsigned int  targeted_system_display_maximum_luminance;
+    unsigned char targeted_system_display_actual_peak_luminance_flag;
+    unsigned char num_rows_targeted_system_display_actual_peak_luminance;
+    unsigned char num_cols_targeted_system_display_actual_peak_luminance;
+    unsigned char targeted_system_display_actual_peak_luminance[25][25];
+
+    unsigned int maxscl[3][3];
+    unsigned int average_maxrgb[3];
+
+    unsigned char num_maxrgb_percentiles[3];
+    unsigned char maxrgb_percentages[3][15];
+    unsigned int  maxrgb_percentiles[3][15];
+
+    unsigned short fraction_bright_pixels[3];
+
+    unsigned char mastering_display_actual_peak_luminance_flag;
+    unsigned char num_rows_mastering_display_actual_peak_luminance;
+    unsigned char num_cols_mastering_display_actual_peak_luminance;
+    unsigned char mastering_display_actual_peak_luminance[25][25];
 
-        unsigned char num_maxrgb_percentiles;
-        unsigned char maxrgb_percentages[15];
-        unsigned int  maxrgb_percentiles[15];
+    struct {
+        unsigned char   tone_mapping_flag[3];
+        unsigned short  knee_point_x[3];
+        unsigned short  knee_point_y[3];
+        unsigned char   num_bezier_curve_anchors[3];
+        unsigned short  bezier_curve_anchors[3][15];
+    } tone_mapping;
+
+    unsigned char color_saturation_mapping_flag[3];
+    unsigned char color_saturation_weight[3];
+#else
+    unsigned int  display_maximum_luminance;
+    unsigned int maxscl[3];
+
+    unsigned char num_maxrgb_percentiles;
+    unsigned char maxrgb_percentages[15];
+    unsigned int  maxrgb_percentiles[15];
 
-        struct {
-            unsigned short  tone_mapping_flag;
-            unsigned short  knee_point_x;
-            unsigned short  knee_point_y;
-            unsigned short  num_bezier_curve_anchors;
-            unsigned short  bezier_curve_anchors[15];
-        } tone_mapping;
-    } data;
+    struct {
+        unsigned short  tone_mapping_flag;
+        unsigned short  knee_point_x;
+        unsigned short  knee_point_y;
+        unsigned short  num_bezier_curve_anchors;
+        unsigned short  bezier_curve_anchors[15];
+    } tone_mapping;
+#endif
+} ExynosHdrData_ST2094_40;
 
+typedef struct _ExynosHdrDynamicInfo {
+    unsigned int valid;
     unsigned int reserved[42];
+
+    ExynosHdrData_ST2094_40 data;
 } ExynosHdrDynamicInfo;
 
+typedef struct _ExynosHdrDynamicBlob {
+    int  nSize;
+    char pData[1020];
+} ExynosHdrDynamicBlob;
+
 typedef struct _ExynosVideoCrop {
     int left;
     int top;
@@ -138,20 +194,28 @@ typedef struct _ExynosVideoEncData {
 } ExynosVideoEncData;
 
 typedef struct _ExynosVideoMeta {
-    ExynosVideoInfoType eType;
+    /***********************************************/
+    /****** WARNING: DO NOT MODIFY THIS AREA *******/
+    /**/                                         /**/
+    /**/  ExynosVideoInfoType eType;             /**/
+    /**/  int                 nHDRType;          /**/
+    /**/                                         /**/
+    /**/  ExynosColorAspects   sColorAspects;    /**/
+    /**/  ExynosHdrStaticInfo  sHdrStaticInfo;   /**/
+    /**/  ExynosHdrDynamicInfo sHdrDynamicInfo;  /**/
+    /**/                                         /**/
+    /****** WARNING: DO NOT MODIFY THIS AREA *******/
+    /***********************************************/
 
-    ExynosHdrStaticInfo  sHdrStaticInfo;
-    ExynosColorAspects   sColorAspects;
+    int nPixelFormat;
+    ExynosVideoCrop crop;
 
     union {
         ExynosVideoDecData dec;
         ExynosVideoEncData enc;
     } data;
 
-    ExynosHdrDynamicInfo sHdrDynamicInfo;
-
-    int nPixelFormat;
-    ExynosVideoCrop crop;
+    int reserved[20];   /* reserved filed for additional info */
 } ExynosVideoMeta;
 
 int Exynos_parsing_user_data_registered_itu_t_t35(ExynosHdrDynamicInfo *dest, void *src, int size);
diff --git a/videoapi/Android.mk b/videoapi/Android.mk
index c877d03..d99d029 100644
--- a/videoapi/Android.mk
+++ b/videoapi/Android.mk
@@ -19,6 +19,12 @@ include $(CLEAR_VARS)
 LOCAL_MODULE_TAGS := optional
 LOCAL_PROPRIETARY_MODULE := true
 
+LOCAL_CFLAGS :=
+
+ifeq ($(BOARD_USE_FULL_ST2094_40), true)
+LOCAL_CFLAGS += -DUSE_FULL_ST2094_40
+endif
+
 LOCAL_SRC_FILES := \
 	VendorVideoAPI.cpp
 
diff --git a/videoapi/VendorVideoAPI.cpp b/videoapi/VendorVideoAPI.cpp
index d186a04..873d77e 100644
--- a/videoapi/VendorVideoAPI.cpp
+++ b/videoapi/VendorVideoAPI.cpp
@@ -132,6 +132,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
     data = 0;
 
     CHECK_BOUNDARY(bit_offset + 2, size);
+#ifdef USE_FULL_ST2094_40
     /* num_windows : 2bit*/
     for (i = 0; i < 1; i++) {
         for (j = 0; j < 2; j++) {
@@ -141,12 +142,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
     bit_offset += 2;
     extraBit   = (bit_offset % 8);
     data       = data >> (8 - extraBit);
-    //pHdr10PlusInfo->data.num_windows = data;
-    windows = data;
+    pHdr10PlusInfo->data.num_windows = data;
     data = 0;
 
-
-    for (i = 1; i < windows; i++) {
+    for (i = 1; i < pHdr10PlusInfo->data.num_windows; i++) {
         CHECK_BOUNDARY(bit_offset + 16, size);
         /* window_upper_left_corner_x : 16bit */
         if (extraBit > 0)
@@ -167,7 +166,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.window_upper_left_corner_x[i] = data;
+        pHdr10PlusInfo->data.window_upper_left_corner_x[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
@@ -190,11 +189,11 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.window_upper_left_corner_y[i] = data;
+        pHdr10PlusInfo->data.window_upper_left_corner_y[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
-        /* window_upper_right_corner_x : 16bit */
+        /* window_lower_right_corner_x : 16bit */
         if (extraBit > 0)
             extraByte = 1;
 
@@ -213,11 +212,11 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.window_upper_right_corner_x[i] = data;
+        pHdr10PlusInfo->data.window_lower_right_corner_x[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
-        /* window_upper_right_corner_y : 16bit */
+        /* window_lower_right_corner_y : 16bit */
         if (extraBit > 0)
             extraByte = 1;
 
@@ -236,7 +235,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.window_upper_right_corner_y[i] = data;
+        pHdr10PlusInfo->data.window_lower_right_corner_y[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
@@ -259,7 +258,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.window_upper_right_corner_y[i] = data;
+        pHdr10PlusInfo->data.center_of_ellipse_x[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
@@ -282,7 +281,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.window_upper_right_corner_y[i] = data;
+        pHdr10PlusInfo->data.center_of_ellipse_y[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 8, size);
@@ -305,7 +304,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.rotation_angle[i] = data;
+        pHdr10PlusInfo->data.rotation_angle[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
@@ -328,7 +327,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.semimajor_axis_internal_ellipse[i] = data;
+        pHdr10PlusInfo->data.semimajor_axis_internal_ellipse[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
@@ -351,7 +350,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.semimajor_axis_external_ellipse[i] = data;
+        pHdr10PlusInfo->data.semimajor_axis_external_ellipse[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 16, size);
@@ -374,7 +373,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.semiminor_axis_external_ellipse[i] = data;
+        pHdr10PlusInfo->data.semiminor_axis_external_ellipse[i - 1] = data;
         data = 0;
 
         CHECK_BOUNDARY(bit_offset + 1, size);
@@ -385,7 +384,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte    = 0;
         extraBit     = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.overlap_process_option[i] = data;
+        pHdr10PlusInfo->data.overlap_process_option[i - 1] = data;
         data = 0;
     }
 
@@ -404,14 +403,14 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         if (i < 3 + extraByte - 1)
             data = data << 8;
 
-        extraBit += (k - extraBit);
+        extraBit += (j - extraBit);
         extraBit %= 8;
     }
     bit_offset += 27;
     extraByte   = 0;
     extraBit    = bit_offset % 8;
     data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-    pHdr10PlusInfo->data.display_maximum_luminance = data;
+    pHdr10PlusInfo->data.targeted_system_display_maximum_luminance = data;
     data = 0;
 
     CHECK_BOUNDARY(bit_offset + 1, size);
@@ -421,11 +420,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
     bit_offset  += 1;
     extraBit     = bit_offset % 8;
     data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-    //pHdr10PlusInfo->data.targeted_system_display_actual_peak_luminance_flag = data;
+    pHdr10PlusInfo->data.targeted_system_display_actual_peak_luminance_flag = data;
     targeted_system_display_actual_peak_luminance_flag = data;
     data = 0;
 
-
     if (targeted_system_display_actual_peak_luminance_flag) {
         CHECK_BOUNDARY(bit_offset + 5, size);
         /* num_rows_targeted_system_display_actual_peak_luminance : 5bit */
@@ -447,7 +445,7 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.num_rows_targeted_system_display_actual_peak_luminance = data;
+        pHdr10PlusInfo->data.num_rows_targeted_system_display_actual_peak_luminance = data;
         num_rows_targeted_system_display_actual_peak_luminance = data;
         data = 0;
 
@@ -471,11 +469,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.num_cols_targeted_system_display_actual_peak_luminance = data;
+        pHdr10PlusInfo->data.num_cols_targeted_system_display_actual_peak_luminance = data;
         num_cols_targeted_system_display_actual_peak_luminance = data;
         data = 0;
 
-
         for (i = 0; i < num_rows_targeted_system_display_actual_peak_luminance; i++) {
             for (j = 0; j < num_cols_targeted_system_display_actual_peak_luminance; j++) {
                 CHECK_BOUNDARY(bit_offset + 4, size);
@@ -498,15 +495,14 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
                 extraByte   = 0;
                 extraBit    = bit_offset % 8;
                 data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-                //pHdr10PlusInfo->data.mastering_display_actual_peak_luminance = data;
+                pHdr10PlusInfo->data.mastering_display_actual_peak_luminance[i][j] = data;
                 data = 0;
             }
         }
     }
 
-    for (i = 0; i < windows; i++) {
+    for (i = 0; i < pHdr10PlusInfo->data.num_windows; i++) {
         for (j = 0; j < 3; j++) {
-            CHECK_BOUNDARY(bit_offset + 17, size);
             /* maxscl : 17bit */
             for (k = 0; k < 3; k++) {
                 for (l = extraBit; l < 8; l++) {
@@ -525,10 +521,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
             if (extraBit != 0)
                 data = data >> (8 - extraBit);
 
-            pHdr10PlusInfo->data.maxscl[j] = data;
+            pHdr10PlusInfo->data.maxscl[i][j] = data;
             data = 0;
         }
-        CHECK_BOUNDARY(bit_offset + 17, size);
+
         /* average_maxrgb : 17bit */
         for (j = 0; j < 3; j++) {
             for (k = extraBit; k < 8; k++) {
@@ -544,10 +540,9 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         bit_offset += 17;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.average_maxrgb = data;
+        pHdr10PlusInfo->data.average_maxrgb[i] = data;
         data = 0;
 
-        CHECK_BOUNDARY(bit_offset + 4, size);
         /* num_distribution_maxrgb_percentiles : 4bit */
         if (extraBit > 4)
             extraByte = 1;
@@ -569,12 +564,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        pHdr10PlusInfo->data.num_maxrgb_percentiles = data;
+        pHdr10PlusInfo->data.num_maxrgb_percentiles[i] = data;
         data = 0;
 
-
-        for (j = 0; j < pHdr10PlusInfo->data.num_maxrgb_percentiles; j++) {
-            CHECK_BOUNDARY(bit_offset + 7, size);
+        for (j = 0; j < pHdr10PlusInfo->data.num_maxrgb_percentiles[i]; j++) {
             /* distribution_maxrgb_percentages : 7bit */
             if (extraBit > 1)
                 extraByte = 1;
@@ -594,10 +587,9 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
             extraByte   = 0;
             extraBit    = bit_offset % 8;
             data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-            pHdr10PlusInfo->data.maxrgb_percentages[j] = data;
+            pHdr10PlusInfo->data.maxrgb_percentages[i][j] = data;
             data = 0;
 
-            CHECK_BOUNDARY(bit_offset + 17, size);
             /* distribution_maxrgb_percentiles : 17bit */
             if (extraBit >= 0)
                 extraByte = 1;
@@ -617,11 +609,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
             extraByte   = 0;
             extraBit    = bit_offset % 8;
             data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-            pHdr10PlusInfo->data.maxrgb_percentiles[j] = data;
+            pHdr10PlusInfo->data.maxrgb_percentiles[i][j] = data;
             data = 0;
         }
 
-        CHECK_BOUNDARY(bit_offset + 10, size);
         /* fraction_bright_pixels : 10bit*/
         if (extraBit > 6)
             extraByte = 2;
@@ -643,24 +634,21 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.fraction_bright_pixels = data;
+        pHdr10PlusInfo->data.fraction_bright_pixels[i] = data;
         data = 0;
     }
 
-    CHECK_BOUNDARY(bit_offset + 1, size);
     /* mastering_display_actual_peak_luminance_flag : 1bit */
     data |= (*((char *)src + (bit_offset / 8)) & (1 << (7 - extraBit)));
 
     bit_offset  += 1;
     extraBit     = bit_offset % 8;
     data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-    //pHdr10PlusInfo->data.mastering_display_actual_peak_luminance_flag = data;
+    pHdr10PlusInfo->data.mastering_display_actual_peak_luminance_flag = data;
     mastering_display_actual_peak_luminance_flag = data;
     data = 0;
 
-
     if (mastering_display_actual_peak_luminance_flag) {
-        CHECK_BOUNDARY(bit_offset + 5, size);
         /* num_rows_mastering_display_actual_peak_luminance : 5bit */
         if (extraBit > 3)
             extraByte = 1;
@@ -680,11 +668,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.num_rows_mastering_display_actual_peak_luminance = data;
+        pHdr10PlusInfo->data.num_rows_mastering_display_actual_peak_luminance = data;
         num_rows_mastering_display_actual_peak_luminance = data;
         data = 0;
 
-        CHECK_BOUNDARY(bit_offset + 5, size);
         /* num_cols_mastering_display_actual_peak_luminance : 5bit */
         if (extraBit > 3)
             extraByte = 1;
@@ -704,14 +691,12 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte   = 0;
         extraBit    = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.num_cols_mastering_display_actual_peak_luminance = data;
+        pHdr10PlusInfo->data.num_cols_mastering_display_actual_peak_luminance = data;
         num_cols_mastering_display_actual_peak_luminance = data;
         data = 0;
 
-
         for (i = 0; i < num_rows_mastering_display_actual_peak_luminance; i++) {
             for (j = 0; j < num_cols_mastering_display_actual_peak_luminance; j++) {
-                CHECK_BOUNDARY(bit_offset + 4, size);
                 /* mastering_display_actual_peak_luminance : 4bit */
                 if (extraBit > 4)
                     extraByte = 1;
@@ -731,26 +716,23 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
                 extraByte   = 0;
                 extraBit    = bit_offset % 8;
                 data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-                //pHdr10PlusInfo->data.mastering_display_actual_peak_luminance = data;
+                pHdr10PlusInfo->data.mastering_display_actual_peak_luminance[i][j] = data;
                 data = 0;
             }
         }
     }
 
-    for (i = 0; i < windows; i++) {
-        CHECK_BOUNDARY(bit_offset + 1, size);
+    for (i = 0; i < pHdr10PlusInfo->data.num_windows; i++) {
         /* tone_mapping_flag : 1bit */
         data |= (*((char *)src + (bit_offset / 8)) & (1 << (7 - extraBit)));
 
         bit_offset  += 1;
         extraBit     = bit_offset % 8;
         data         = data >> (8 - extraBit);
-        pHdr10PlusInfo->data.tone_mapping.tone_mapping_flag = data;
+        pHdr10PlusInfo->data.tone_mapping.tone_mapping_flag[i] = data;
         data = 0;
 
-
-        if (pHdr10PlusInfo->data.tone_mapping.tone_mapping_flag) {
-            CHECK_BOUNDARY(bit_offset + 12, size);
+        if (pHdr10PlusInfo->data.tone_mapping.tone_mapping_flag[i]) {
             /* knee_point_x : 12bit */
             if (extraBit > 5)
                 extraByte = 2;
@@ -772,10 +754,9 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
             extraByte   = 0;
             extraBit    = bit_offset % 8;
             data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-            pHdr10PlusInfo->data.tone_mapping.knee_point_x = data;
+            pHdr10PlusInfo->data.tone_mapping.knee_point_x[i] = data;
             data = 0;
 
-            CHECK_BOUNDARY(bit_offset + 12, size);
             /* knee_point_y : 12bit */
             if (extraBit > 5)
                 extraByte = 2;
@@ -797,10 +778,9 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
             extraByte   = 0;
             extraBit    = bit_offset % 8;
             data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-            pHdr10PlusInfo->data.tone_mapping.knee_point_y = data;
+            pHdr10PlusInfo->data.tone_mapping.knee_point_y[i] = data;
             data = 0;
 
-            CHECK_BOUNDARY(bit_offset + 4, size);
             /* num_bezier_curve_anchors : 4bit */
             if (extraBit > 4)
                 extraByte = 1;
@@ -820,12 +800,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
             extraByte   = 0;
             extraBit    = bit_offset % 8;
             data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-            pHdr10PlusInfo->data.tone_mapping.num_bezier_curve_anchors = data;
+            pHdr10PlusInfo->data.tone_mapping.num_bezier_curve_anchors[i] = data;
             data = 0;
 
-
-            for (j = 0; j < pHdr10PlusInfo->data.tone_mapping.num_bezier_curve_anchors; j++) {
-                CHECK_BOUNDARY(bit_offset + 10, size);
+            for (j = 0; j < pHdr10PlusInfo->data.tone_mapping.num_bezier_curve_anchors[i]; j++) {
                 /* bezier_curve_anchors : 10bit */
                 if (extraBit > 6)
                     extraByte = 2;
@@ -847,12 +825,11 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
                 extraByte   = 0;
                 extraBit    = bit_offset % 8;
                 data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-                pHdr10PlusInfo->data.tone_mapping.bezier_curve_anchors[j] = data;
+                pHdr10PlusInfo->data.tone_mapping.bezier_curve_anchors[i][j] = data;
                 data = 0;
             }
         }
 
-        CHECK_BOUNDARY(bit_offset + 1, size);
         /* color_saturation_mapping_flag : 1bit */
         data |= (*((char *)src + (bit_offset / 8)) & (1 << (7 - extraBit)));
 
@@ -860,13 +837,10 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
         extraByte    = 0;
         extraBit     = bit_offset % 8;
         data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-        //pHdr10PlusInfo->data.color_saturation_mapping_flag = data;
-        color_saturation_mapping_flag = data;
+        pHdr10PlusInfo->data.color_saturation_mapping_flag[i] = data;
         data = 0;
 
-
-        if (color_saturation_mapping_flag) {
-            CHECK_BOUNDARY(bit_offset + 6, size);
+        if (pHdr10PlusInfo->data.color_saturation_mapping_flag[i]) {
             /* color_saturation_weight : 6bit */
             if (extraBit > 3)
                 extraByte = 1;
@@ -886,11 +860,470 @@ int Exynos_parsing_user_data_registered_itu_t_t35 (
             extraByte   = 0;
             extraBit    = bit_offset % 8;
             data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
-            //pHdr10PlusInfo->color_saturation_weight = data;
+            pHdr10PlusInfo->data.color_saturation_weight[i] = data;
             data = 0;
         }
     }
 
+#else // USE_FULL_ST2094_40
+    /* Device does not support full ST2094_40 info for HDR10 plus
+     * So some infos will be omitted from data parsing or muxing.
+     * (Not parsed but just offset moved)
+     */
+
+    /* num_windows : 2bit*/
+    for (i = 0; i < 1; i++) {
+        for (j = 0; j < 2; j++) {
+            data |= (*((char *)src + (bit_offset / 8) + i) & (1 << (7 - j)));
+        }
+    }
+    bit_offset += 2;
+    extraBit   = (bit_offset % 8);
+    data       = data >> (8 - extraBit);
+    windows    = data;
+    data       = 0;
+
+    for (i = 1; i < windows; i++) {
+        /* window_upper_left_corner_x : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* window_upper_left_corner_y : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* window_lower_right_corner_x : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* window_lower_right_corner_y : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* center_of_ellipse_x : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* center_of_ellipse_y : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* rotation_angle : 8bit */
+        bit_offset += 8;
+        extraBit    = bit_offset % 8;
+
+        /* semimajor_axis_internal_ellipse : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* semimajor_axis_external_ellipse : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* semiminor_axis_external_ellipse : 16bit */
+        bit_offset += 16;
+        extraBit    = bit_offset % 8;
+
+        /* overlap_process_option : 1bit */
+        bit_offset  += 1;
+        extraBit     = bit_offset % 8;
+    }
+
+    /* targeted_system_display_maximum_luminance : 27bit */
+    if (extraBit > 5)
+        extraByte = 2;
+    else if (extraBit <= 5)
+        extraByte = 1;
+
+    for (i = 0; i < 3 + extraByte; i++) {
+        for (j = extraBit; j < 8; j++) {
+            data |= (*((char *)src + (bit_offset / 8) + i) & (1 << (7 - j)));
+        }
+
+        if (i < 3 + extraByte - 1)
+            data = data << 8;
+
+        extraBit += (j - extraBit);
+        extraBit %= 8;
+    }
+    bit_offset += 27;
+    extraByte   = 0;
+    extraBit    = bit_offset % 8;
+    data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+    pHdr10PlusInfo->data.display_maximum_luminance = data;
+    data = 0;
+
+    /* targeted_system_display_actual_peak_luminance_flag : 1bit */
+    data |= (*((char *)src + (bit_offset / 8)) & (1 << (7 - extraBit)));
+
+    bit_offset  += 1;
+    extraBit     = bit_offset % 8;
+    data         = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+    targeted_system_display_actual_peak_luminance_flag = data;
+    data = 0;
+
+    if (targeted_system_display_actual_peak_luminance_flag) {
+        /* num_rows_targeted_system_display_actual_peak_luminance : 5bit */
+        if (extraBit > 3)
+            extraByte = 1;
+
+        for (i = 0; i < 1 + extraByte; i++) {
+            for (j = extraBit; j < 8; j++) {
+                data |= (*((char *)src + (bit_offset / 8) + i) & (1 << (7 - j)));
+            }
+
+            if (i < 1)
+                data = data << 8;
+
+            extraBit += (j - extraBit);
+            extraBit %= 8;
+        }
+        bit_offset += 5;
+        extraByte   = 0;
+        extraBit    = bit_offset % 8;
+        data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+        num_rows_targeted_system_display_actual_peak_luminance = data;
+        data = 0;
+
+        /* num_cols_targeted_system_display_actual_peak_luminance : 5bit */
+        if (extraBit > 3)
+            extraByte = 1;
+
+        for (i = 0; i < 1 + extraByte; i++) {
+            for (j = extraBit; j < 8; j++) {
+                data |= (*((char *)src + (bit_offset / 8) + i) & (1 << (7 - j)));
+            }
+
+            if (i < 1)
+                data = data << 8;
+
+            extraBit += (j - extraBit);
+            extraBit %= 8;
+        }
+        bit_offset += 5;
+        extraByte   = 0;
+        extraBit    = bit_offset % 8;
+        data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+        num_cols_targeted_system_display_actual_peak_luminance = data;
+        data = 0;
+
+        for (i = 0; i < num_rows_targeted_system_display_actual_peak_luminance; i++) {
+            for (j = 0; j < num_cols_targeted_system_display_actual_peak_luminance; j++) {
+                /* mastering_display_actual_peak_luminance : 4bit */
+                bit_offset += 4;
+                extraBit    = bit_offset % 8;
+            }
+        }
+    }
+
+    for (i = 0; i < windows; i++) {
+        for (j = 0; j < 3; j++) {
+            CHECK_BOUNDARY(bit_offset + 17, size);
+            /* maxscl : 17bit */
+            for (k = 0; k < 3; k++) {
+                for (l = extraBit; l < 8; l++) {
+                    data |= (*((char *)src + (bit_offset / 8) + k) & (1 << (7 - l)));
+                }
+
+                if (k < 2)
+                    data = data << 8;
+
+                extraBit += (l - extraBit);
+                extraBit %= 8;
+            }
+            bit_offset += 17;
+            extraBit    = bit_offset % 8;
+
+            if (extraBit != 0)
+                data = data >> (8 - extraBit);
+
+            pHdr10PlusInfo->data.maxscl[j] = data;
+            data = 0;
+        }
+        CHECK_BOUNDARY(bit_offset + 17, size);
+        /* average_maxrgb : 17bit */
+        bit_offset += 17;
+        extraBit    = bit_offset % 8;
+
+        CHECK_BOUNDARY(bit_offset + 4, size);
+        /* num_distribution_maxrgb_percentiles : 4bit */
+        if (extraBit > 4)
+            extraByte = 1;
+
+        for (j = 0; j < 1 + extraByte; j++) {
+            for (k = extraBit; k < 8; k++) {
+                data |= (*((char *)src + (bit_offset / 8) + j) & (1 << (7 - k)));
+            }
+
+            if (extraByte > 0) {
+                if (j < 1)
+                    data = data << 8;
+            }
+
+            extraBit += (k - extraBit);
+            extraBit %= 8;
+        }
+        bit_offset += 4;
+        extraByte   = 0;
+        extraBit    = bit_offset % 8;
+        data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+        pHdr10PlusInfo->data.num_maxrgb_percentiles = data;
+        data = 0;
+
+        for (j = 0; j < pHdr10PlusInfo->data.num_maxrgb_percentiles; j++) {
+            CHECK_BOUNDARY(bit_offset + 7, size);
+            /* distribution_maxrgb_percentages : 7bit */
+            if (extraBit > 1)
+                extraByte = 1;
+
+            for (k = 0; k < 1 + extraByte; k++) {
+                for (l = extraBit; l < 8; l++) {
+                    data |= (*((char *)src + (bit_offset / 8) + k) & (1 << (7 - l)));
+                }
+
+                if (k < 1)
+                    data = data << 8;
+
+                extraBit += (l - extraBit);
+                extraBit %= 8;
+            }
+            bit_offset += 7;
+            extraByte   = 0;
+            extraBit    = bit_offset % 8;
+            data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+            pHdr10PlusInfo->data.maxrgb_percentages[j] = data;
+            data = 0;
+
+            CHECK_BOUNDARY(bit_offset + 17, size);
+            /* distribution_maxrgb_percentiles : 17bit */
+            if (extraBit >= 0)
+                extraByte = 1;
+
+            for (k = 0; k < 2 + extraByte; k++) {
+                for (l = extraBit; l < 8; l++) {
+                    data |= (*((char *)src + (bit_offset / 8) + k) & (1 << (7 - l)));
+                }
+
+                if (k < 2)
+                    data = data << 8;
+
+                extraBit += (l - extraBit);
+                extraBit %= 8;
+            }
+            bit_offset += 17;
+            extraByte   = 0;
+            extraBit    = bit_offset % 8;
+            data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+            pHdr10PlusInfo->data.maxrgb_percentiles[j] = data;
+            data = 0;
+        }
+
+        CHECK_BOUNDARY(bit_offset + 10, size);
+        /* fraction_bright_pixels : 10bit*/
+        bit_offset += 10;
+        extraBit    = bit_offset % 8;
+    }
+
+    CHECK_BOUNDARY(bit_offset + 1, size);
+    /* mastering_display_actual_peak_luminance_flag : 1bit */
+    data |= (*((char *)src + (bit_offset / 8)) & (1 << (7 - extraBit)));
+
+    bit_offset  += 1;
+    extraBit     = bit_offset % 8;
+    data         = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+    mastering_display_actual_peak_luminance_flag = data;
+    data = 0;
+
+    if (mastering_display_actual_peak_luminance_flag) {
+        CHECK_BOUNDARY(bit_offset + 5, size);
+        /* num_rows_mastering_display_actual_peak_luminance : 5bit */
+        if (extraBit > 3)
+            extraByte = 1;
+
+        for (i = 0; i < 1 + extraByte; i++) {
+            for (j = extraBit; j < 8; j++) {
+                data |= (*((char *)src + (bit_offset / 8) + i) & (1 << (7 - j)));
+            }
+
+            if (i < 1)
+                data = data << 8;
+
+            extraBit += (j - extraBit);
+            extraBit %= 8;
+        }
+        bit_offset += 5;
+        extraByte   = 0;
+        extraBit    = bit_offset % 8;
+        data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+        num_rows_mastering_display_actual_peak_luminance = data;
+        data = 0;
+
+        CHECK_BOUNDARY(bit_offset + 5, size);
+        /* num_cols_mastering_display_actual_peak_luminance : 5bit */
+        if (extraBit > 3)
+            extraByte = 1;
+
+        for (i = 0; i < 1 + extraByte; i++) {
+            for (j = extraBit; j < 8; j++) {
+                data |= (*((char *)src + (bit_offset / 8) + i) & (1 << (7 - j)));
+    }
+
+            if (i < 1)
+                data = data << 8;
+
+            extraBit += (j - extraBit);
+            extraBit %= 8;
+        }
+        bit_offset += 5;
+        extraByte   = 0;
+        extraBit    = bit_offset % 8;
+        data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+        num_cols_mastering_display_actual_peak_luminance = data;
+        data = 0;
+
+        for (i = 0; i < num_rows_mastering_display_actual_peak_luminance; i++) {
+            for (j = 0; j < num_cols_mastering_display_actual_peak_luminance; j++) {
+                CHECK_BOUNDARY(bit_offset + 4, size);
+                /* mastering_display_actual_peak_luminance : 4bit */
+                bit_offset += 4;
+                extraBit    = bit_offset % 8;
+            }
+        }
+    }
+
+    for (i = 0; i < windows; i++) {
+        CHECK_BOUNDARY(bit_offset + 1, size);
+        /* tone_mapping_flag : 1bit */
+        data |= (*((char *)src + (bit_offset / 8)) & (1 << (7 - extraBit)));
+
+        bit_offset  += 1;
+        extraBit     = bit_offset % 8;
+        data         = data >> (8 - extraBit);
+        pHdr10PlusInfo->data.tone_mapping.tone_mapping_flag = data;
+        data = 0;
+
+        if (pHdr10PlusInfo->data.tone_mapping.tone_mapping_flag) {
+            CHECK_BOUNDARY(bit_offset + 12, size);
+            /* knee_point_x : 12bit */
+            if (extraBit > 5)
+                extraByte = 2;
+            else if (extraBit <= 5)
+                extraByte = 1;
+
+            for (j = 0; j < 1 + extraByte; j++) {
+                for (k = extraBit; k < 8; k++) {
+                    data |= (*((char *)src + (bit_offset / 8) + j) & (1 << (7 - k)));
+                }
+
+                if (j < 1 + extraByte - 1)
+                    data = data << 8;
+
+                extraBit += (k - extraBit);
+                extraBit %= 8;
+            }
+            bit_offset += 12;
+            extraByte   = 0;
+            extraBit    = bit_offset % 8;
+            data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+            pHdr10PlusInfo->data.tone_mapping.knee_point_x = data;
+            data = 0;
+
+            CHECK_BOUNDARY(bit_offset + 12, size);
+            /* knee_point_y : 12bit */
+            if (extraBit > 5)
+                extraByte = 2;
+            else if (extraBit <= 5)
+                extraByte = 1;
+
+            for (j = 0; j < 1 + extraByte; j++) {
+                for (k = extraBit; k < 8; k++) {
+                    data |= (*((char *)src + (bit_offset / 8) + j) & (1 << (7 - k)));
+                }
+
+                if (j < 1 + extraByte - 1)
+                    data = data << 8;
+
+                extraBit += (k - extraBit);
+                extraBit %= 8;
+            }
+            bit_offset += 12;
+            extraByte   = 0;
+            extraBit    = bit_offset % 8;
+            data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+            pHdr10PlusInfo->data.tone_mapping.knee_point_y = data;
+            data = 0;
+
+            CHECK_BOUNDARY(bit_offset + 4, size);
+            /* num_bezier_curve_anchors : 4bit */
+            if (extraBit > 4)
+                extraByte = 1;
+
+            for (j = 0; j < 1 + extraByte; j++) {
+                for (k = extraBit; k < 8; k++) {
+                    data |= (*((char *)src + (bit_offset / 8) + j) & (1 << (7 - k)));
+                }
+
+                if (j < 1 + extraByte - 1)
+                    data = data << 8;
+
+                extraBit += (k - extraBit);
+                extraBit %= 8;
+            }
+            bit_offset += 4;
+            extraByte   = 0;
+            extraBit    = bit_offset % 8;
+            data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+            pHdr10PlusInfo->data.tone_mapping.num_bezier_curve_anchors = data;
+            data = 0;
+
+            for (j = 0; j < pHdr10PlusInfo->data.tone_mapping.num_bezier_curve_anchors; j++) {
+                CHECK_BOUNDARY(bit_offset + 10, size);
+                /* bezier_curve_anchors : 10bit */
+                if (extraBit > 6)
+                    extraByte = 2;
+                else if (extraBit <= 6)
+                    extraByte = 1;
+
+                for (k = 0; k < 1 + extraByte; k++) {
+                    for (l = extraBit; l < 8; l++) {
+                        data |= (*((char *)src + (bit_offset / 8) + k) & (1 << (7 - l)));
+                    }
+
+                    if (k < 1 + extraByte - 1)
+                        data = data << 8;
+
+                    extraBit += (l - extraBit);
+                    extraBit %= 8;
+                }
+                bit_offset += 10;
+                extraByte   = 0;
+                extraBit    = bit_offset % 8;
+                data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+                pHdr10PlusInfo->data.tone_mapping.bezier_curve_anchors[j] = data;
+                data = 0;
+            }
+        }
+
+        CHECK_BOUNDARY(bit_offset + 1, size);
+        /* color_saturation_mapping_flag : 1bit */
+        data |= (*((char *)src + (bit_offset / 8)) & (1 << (7 - extraBit)));
+
+        bit_offset  += 1;
+        extraByte    = 0;
+        extraBit     = bit_offset % 8;
+        data        = (extraBit != 0) ? (data >> (8 - extraBit)) : data;
+        color_saturation_mapping_flag = data;
+        data = 0;
+
+        if (color_saturation_mapping_flag) {
+            CHECK_BOUNDARY(bit_offset + 6, size);
+            /* color_saturation_weight : 6bit */
+            bit_offset += 6;
+            extraBit    = bit_offset % 8;
+        }
+    }
+#endif // USE_FULL_ST2094_40
+
     return 0;
 }
 
@@ -910,7 +1343,7 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
     int buffer     = 0;
     int tempBuffer = 0;
 
-    int i, j, k;
+    int i, j, k, l;
 
     if ((src == NULL) || (dst == NULL)) {
         ALOGE("[%s] invalid parameters", __FUNCTION__);
@@ -931,6 +1364,7 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
         if (bit_offset == offset_limit)
             break;
     }
+    extraBit = (bit_offset % 8);
 
     /* terminal_provider_code: 16bit */
     offset_limit = bit_offset + 16;
@@ -945,6 +1379,7 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
                 break;
         }
     }
+    extraBit = (bit_offset % 8);
 
     /* terminal_provider_oriented_code: 16bit */
     offset_limit = bit_offset + 16;
@@ -959,6 +1394,7 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
                 break;
         }
     }
+    extraBit = (bit_offset % 8);
 
     /* application_identifier: 8bit */
     offset_limit = bit_offset + 8;
@@ -971,6 +1407,7 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
         if (bit_offset == offset_limit)
             break;
     }
+    extraBit = (bit_offset % 8);
 
     /* application_version: 8bit */
     offset_limit = bit_offset + 8;
@@ -983,7 +1420,804 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
         if (bit_offset == offset_limit)
             break;
     }
+    extraBit = (bit_offset % 8);
+
+#ifdef USE_FULL_ST2094_40
+    /* num_windows: 2bit */
+    offset_limit = bit_offset + 2;
+
+    tempBuffer = pHDRDynamicInfo->data.num_windows << (6 - extraBit);
+    for (i = 0; i < 2; i++) {
+        /* num_windows is always 1 now */
+        *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&tempBuffer) & (1 << (7 - i)));
+        bit_offset++;
+
+        if (bit_offset == offset_limit)
+            break;
+    }
+    extraBit = (bit_offset % 8);
+    tempBuffer = 0;
+
+    for (i = 1; i < pHDRDynamicInfo->data.num_windows; i++) {
+        /* window_upper_left_corner_x: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.window_upper_left_corner_x[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* window_upper_left_corner_y: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.window_upper_left_corner_y[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* window_lower_right_corner_x: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.window_lower_right_corner_x[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* window_lower_right_corner_y: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.window_lower_right_corner_y[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* center_of_ellipse_x: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.center_of_ellipse_x[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* center_of_ellipse_y: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.center_of_ellipse_y[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* rotation_angle: 8bit */
+        offset_limit = bit_offset + 8;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.rotation_angle[i - 1];
+        tempBuffer = tempBuffer << (24 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (1 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* semimajor_axis_internal_ellipse: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.semimajor_axis_internal_ellipse[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* semimajor_axis_external_ellipse: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.semimajor_axis_external_ellipse[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* semiminor_axis_external_ellipse: 16bit */
+        offset_limit = bit_offset + 16;
+
+        if (extraBit > 0)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.semiminor_axis_external_ellipse[i - 1];
+        tempBuffer = tempBuffer << (16 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* overlap_process_option: 1bit */
+
+    }
+
+    /* targeted_system_display_maximum_luminance: 27bit */
+    offset_limit = bit_offset + 27;
+
+    tempBuffer = pHDRDynamicInfo->data.targeted_system_display_maximum_luminance;
+    tempBuffer = tempBuffer << (5 - extraBit);
+    for (i = 0; i < 4; i++) {
+        memcpy((char *)&buffer + i, (char *)&tempBuffer + (3 - i), sizeof(char));
+    }
+
+    for (i = 0; i < 4; i++) {
+        for (j = extraBit; j < 8; j++) {
+            *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + i) & (1 << (7 - j)));
+            bit_offset++;
+
+            if (bit_offset == offset_limit)
+                break;
+        }
+        extraBit = (bit_offset % 8);
+    }
+    buffer     = 0;
+    tempBuffer = 0;
+
+    /* targeted_system_display_actual_peak_luminance_flag: 1bit */
+    if (pHDRDynamicInfo->data.targeted_system_display_actual_peak_luminance_flag) {
+        *((char *)pBlob + (bit_offset / 8)) |= (1 << (7 - extraBit));
+    }
+    bit_offset += 1;
+    extraBit = (bit_offset % 8);
+
+    if (pHDRDynamicInfo->data.targeted_system_display_actual_peak_luminance_flag) {
+        /* num_rows_targeted_system_display_actual_peak_luminance: 5bit */
+        offset_limit = bit_offset + 5;
+
+        if (extraBit > 3)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.num_rows_targeted_system_display_actual_peak_luminance;
+        tempBuffer = tempBuffer << (27 - extraBit);
+        for (i = 0; i < 4; i++) {
+            memcpy((char *)&buffer + i, (char *)&tempBuffer + (3 - i), sizeof(char));
+        }
+
+        for (i = 0; i < (1 + extraByte); i++) {
+            for (j = extraBit; j < 8; j++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + i) & (1 << (7 - j)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* num_cols_targeted_system_display_actual_peak_luminance: 5bit */
+        offset_limit = bit_offset + 5;
+
+        if (extraBit > 3)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.num_cols_targeted_system_display_actual_peak_luminance;
+        tempBuffer = tempBuffer << (27 - extraBit);
+        for (i = 0; i < 4; i++) {
+            memcpy((char *)&buffer + i, (char *)&tempBuffer + (3 - i), sizeof(char));
+        }
+
+        for (i = 0; i < (1 + extraByte); i++) {
+            for (j = extraBit; j < 8; j++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + i) & (1 << (7 - j)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* targeted_system_display_actual_peak_luminance[row][col]: 4bit */
+        for (i = 0; i < pHDRDynamicInfo->data.num_rows_targeted_system_display_actual_peak_luminance; i++) {
+            for (j = 0; j < pHDRDynamicInfo->data.num_cols_targeted_system_display_actual_peak_luminance; j++) {
+                offset_limit = bit_offset + 4;
+
+                if (extraBit > 4)
+                    extraByte = 1;
+
+                tempBuffer = pHDRDynamicInfo->data.targeted_system_display_actual_peak_luminance[i][j];
+                tempBuffer = tempBuffer << (28 - extraBit);
+                for (k = 0; k < 4; k++) {
+                    memcpy((char *)&buffer + k, (char *)&tempBuffer + (3 - k), sizeof(char));
+                }
+
+                for (k = 0; k < (1 + extraByte); k++) {
+                    for (l = extraBit; l < 8; l++) {
+                        *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + k) & (1 << (7 - l)));
+                        bit_offset++;
+
+                        if (bit_offset == offset_limit) {
+                            break;
+                        }
+                    }
+                    extraBit = (bit_offset % 8);
+                }
+                buffer     = 0;
+                tempBuffer = 0;
+                extraByte  = 0;
+            }
+        }
+    }
 
+    for (i = 0; i < pHDRDynamicInfo->data.num_windows; i++) {
+        /* maxscl: 17bit */
+        for (j = 0; j < 3; j++) {
+            offset_limit = bit_offset + 17;
+
+            tempBuffer = pHDRDynamicInfo->data.maxscl[i][j] << (15 - extraBit);
+            for (k = 0; k < 4; k++) {
+                memcpy((char *)&buffer + k, (char *)&tempBuffer + (3 - k), sizeof(char));
+            }
+
+            for (k = 0; k < 3; k++) {
+                for (l = extraBit; l < 8; l++) {
+                    *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + k) & (1 << (7 - l)));
+                    bit_offset++;
+
+                    if (bit_offset == offset_limit)
+                        break;
+                }
+                extraBit = (bit_offset % 8);
+            }
+            buffer     = 0;
+            tempBuffer = 0;
+        }
+
+        /* average_maxrgb: 17bit */
+        offset_limit = bit_offset + 17;
+
+        tempBuffer = pHDRDynamicInfo->data.average_maxrgb[i] << (15 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < 3; j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit)
+                    break;
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+
+        /* num_distribution_maxrgb_percentiles: 4bit */
+        offset_limit = bit_offset + 4;
+
+        tempBuffer = pHDRDynamicInfo->data.num_maxrgb_percentiles[i] << (4 - extraBit);
+        for (j = extraBit; j < 8; j++) {
+            *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&tempBuffer) & (1 << (7 - j)));
+            bit_offset++;
+
+            if (bit_offset == offset_limit)
+                break;
+        }
+        extraBit = (bit_offset % 8);
+        tempBuffer = 0;
+
+        for (j = 0; j < pHDRDynamicInfo->data.num_maxrgb_percentiles[i]; j++) {
+            /* distribution_maxrgb_percentaged: 7bit */
+            offset_limit = bit_offset + 7;
+
+            if (extraBit > 1)
+                extraByte = 1;
+
+            tempBuffer = pHDRDynamicInfo->data.maxrgb_percentages[i][j];
+            tempBuffer = tempBuffer << (25 - extraBit);
+            for (k = 0; k < 4; k++) {
+                memcpy((char *)&buffer + k, (char *)&tempBuffer + (3 - k), sizeof(char));
+            }
+
+            for (k = 0; k < (1 + extraByte); k++) {
+                for (l = extraBit; l < 8; l++) {
+                    *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + k) & (1 << (7 - l)));
+                    bit_offset++;
+
+                    if (bit_offset == offset_limit) {
+                        break;
+                    }
+                }
+                extraBit = (bit_offset % 8);
+            }
+            buffer     = 0;
+            tempBuffer = 0;
+            extraByte  = 0;
+
+            /* distribution_maxrgb_percentiles: 17bit */
+            offset_limit = bit_offset + 17;
+
+            tempBuffer = pHDRDynamicInfo->data.maxrgb_percentiles[i][j] << (15 - extraBit);
+            for (k = 0; k < 4; k++) {
+                memcpy((char *)&buffer + k, (char *)&tempBuffer + (3 - k), sizeof(char));
+            }
+
+            for (k = 0; k < 3; k++) {
+                for (l = extraBit; l < 8; l++) {
+                    *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + k) & (1 << (7 - l)));
+                    bit_offset++;
+
+                    if (bit_offset == offset_limit) {
+                        break;
+                    }
+                }
+                extraBit = (bit_offset % 8);
+            }
+            buffer     = 0;
+            tempBuffer = 0;
+        }
+
+        /* fraction_bright_pixels: 10bit */
+        if (extraBit > 6)
+            extraByte = 1;
+
+        offset_limit = bit_offset + 10;
+
+        tempBuffer = pHDRDynamicInfo->data.fraction_bright_pixels[i];
+        tempBuffer = tempBuffer << (22 - extraBit);
+        for (j = 0; j < 4; j++) {
+            memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+        }
+
+        for (j = 0; j < (2 + extraByte); j++) {
+            for (k = extraBit; k < 8; k++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+    }
+
+    /* mastering_display_actual_peak_luminance_flag: 1bit */
+    if (pHDRDynamicInfo->data.mastering_display_actual_peak_luminance_flag) {
+        *((char *)pBlob + (bit_offset / 8)) |= (1 << (7 - extraBit));
+    }
+    bit_offset += 1;
+    extraBit = (bit_offset % 8);
+
+    if (pHDRDynamicInfo->data.mastering_display_actual_peak_luminance_flag) {
+        /* num_rows_mastering_display_actual_peak_luminance: 5bit */
+        offset_limit = bit_offset + 5;
+
+        if (extraBit > 3)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.num_rows_mastering_display_actual_peak_luminance;
+        tempBuffer = tempBuffer << (27 - extraBit);
+        for (i = 0; i < 4; i++) {
+            memcpy((char *)&buffer + i, (char *)&tempBuffer + (3 - i), sizeof(char));
+        }
+
+        for (i = 0; i < (1 + extraByte); i++) {
+            for (j = extraBit; j < 8; j++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + i) & (1 << (7 - j)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* num_cols_mastering_display_actual_peak_luminance: 5bit */
+        offset_limit = bit_offset + 5;
+
+        if (extraBit > 3)
+            extraByte = 1;
+
+        tempBuffer = pHDRDynamicInfo->data.num_cols_mastering_display_actual_peak_luminance;
+        tempBuffer = tempBuffer << (27 - extraBit);
+        for (i = 0; i < 4; i++) {
+            memcpy((char *)&buffer + i, (char *)&tempBuffer + (3 - i), sizeof(char));
+        }
+
+        for (i = 0; i < (1 + extraByte); i++) {
+            for (j = extraBit; j < 8; j++) {
+                *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + i) & (1 << (7 - j)));
+                bit_offset++;
+
+                if (bit_offset == offset_limit) {
+                    break;
+                }
+            }
+            extraBit = (bit_offset % 8);
+        }
+        buffer     = 0;
+        tempBuffer = 0;
+        extraByte  = 0;
+
+        /* mastering_display_actual_peak_luminance[row][col]: 4bit */
+        for (i = 0; i < pHDRDynamicInfo->data.num_rows_mastering_display_actual_peak_luminance; i++) {
+            for (j = 0; j < pHDRDynamicInfo->data.num_cols_mastering_display_actual_peak_luminance; j++) {
+                offset_limit = bit_offset + 4;
+
+                if (extraBit > 4)
+                    extraByte = 1;
+
+                tempBuffer = pHDRDynamicInfo->data.mastering_display_actual_peak_luminance[i][j];
+                tempBuffer = tempBuffer << (28 - extraBit);
+                for (k = 0; k < 4; k++) {
+                    memcpy((char *)&buffer + k, (char *)&tempBuffer + (3 - k), sizeof(char));
+                }
+
+                for (k = 0; k < (1 + extraByte); k++) {
+                    for (l = extraBit; l < 8; l++) {
+                        *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + k) & (1 << (7 - l)));
+                        bit_offset++;
+
+                        if (bit_offset == offset_limit) {
+                            break;
+                        }
+                    }
+                    extraBit = (bit_offset % 8);
+                }
+                buffer     = 0;
+                tempBuffer = 0;
+                extraByte  = 0;
+            }
+        }
+    }
+
+    for (i = 0; i < pHDRDynamicInfo->data.num_windows; i++) {
+        /* tone_mapping_flag: 1bit */
+        if (pHDRDynamicInfo->data.tone_mapping.tone_mapping_flag[i]) {
+            *((char *)pBlob + (bit_offset / 8)) |= (1 << (7 - extraBit));
+        }
+        bit_offset += 1;
+        extraBit = (bit_offset % 8);
+
+        if (pHDRDynamicInfo->data.tone_mapping.tone_mapping_flag[i]) {
+            /* knee_point_x: 12bit */
+            if (extraBit > 4)
+                extraByte = 1;
+
+            offset_limit = bit_offset + 12;
+
+            tempBuffer = pHDRDynamicInfo->data.tone_mapping.knee_point_x[i];
+            tempBuffer = tempBuffer << (20 - extraBit);
+            for (j = 0; j < 4; j++) {
+                memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+            }
+
+            for (j = 0; j < (2 + extraByte); j++) {
+                for (k = extraBit; k < 8; k++) {
+                    *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                    bit_offset++;
+
+                    if (bit_offset == offset_limit) {
+                        break;
+                    }
+                }
+                extraBit = (bit_offset % 8);
+            }
+            buffer     = 0;
+            tempBuffer = 0;
+            extraByte  = 0;
+
+            /* knee_point_y: 12bit */
+            if (extraBit > 4)
+                extraByte = 1;
+
+            offset_limit = bit_offset + 12;
+
+            tempBuffer = pHDRDynamicInfo->data.tone_mapping.knee_point_y[i];
+            tempBuffer = tempBuffer << (20 - extraBit);
+            for (j = 0; j < 4; j++) {
+                memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+            }
+
+            for (j = 0; j < (2 + extraByte); j++) {
+                for (k = extraBit; k < 8; k++) {
+                    *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                    bit_offset++;
+
+                    if (bit_offset == offset_limit) {
+                        break;
+                    }
+                }
+                extraBit = (bit_offset % 8);
+            }
+            buffer     = 0;
+            tempBuffer = 0;
+            extraByte  = 0;
+
+            /* num_bezier_curve_anchors: 4bit */
+            if (extraBit > 4)
+                extraByte = 1;
+
+            offset_limit = bit_offset + 4;
+
+            tempBuffer = pHDRDynamicInfo->data.tone_mapping.num_bezier_curve_anchors[i];
+            tempBuffer = tempBuffer << (28 - extraBit);
+            for (j = 0; j < 4; j++) {
+                memcpy((char *)&buffer + j, (char *)&tempBuffer + (3 - j), sizeof(char));
+            }
+
+            for (j = 0; j < (1 + extraByte); j++) {
+                for (k = extraBit; k < 8; k++) {
+                    *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + j) & (1 << (7 - k)));
+                    bit_offset++;
+
+                    if (bit_offset == offset_limit) {
+                        break;
+                    }
+                }
+                extraBit = (bit_offset % 8);
+            }
+            buffer     = 0;
+            tempBuffer = 0;
+            extraByte  = 0;
+
+            for (j = 0; j < pHDRDynamicInfo->data.tone_mapping.num_bezier_curve_anchors[i]; j++) {
+                /* bezier_curve_anchors: 10bit */
+                if (extraBit > 6)
+                    extraByte = 1;
+
+                offset_limit = bit_offset + 10;
+
+                tempBuffer = pHDRDynamicInfo->data.tone_mapping.bezier_curve_anchors[i][j];
+                tempBuffer = tempBuffer << (22 - extraBit);
+                for (k = 0; k < 4; k++) {
+                    memcpy((char *)&buffer + k, (char *)&tempBuffer + (3 - k), sizeof(char));
+                }
+
+                for (k = 0; k < (2 + extraByte); k++) {
+                    for (l = extraBit; l < 8; l++) {
+                        *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + k) & (1 << (7 - l)));
+                        bit_offset++;
+
+                        if (bit_offset == offset_limit) {
+                            break;
+                        }
+                    }
+                    extraBit = (bit_offset % 8);
+                }
+                buffer     = 0;
+                tempBuffer = 0;
+                extraByte  = 0;
+            }
+        }
+
+        /* color_saturation_mapping_flag: 1bit */
+        if (pHDRDynamicInfo->data.color_saturation_mapping_flag[i]) {
+            *((char *)pBlob + (bit_offset / 8)) |= (1 << (7 - extraBit));
+        }
+        bit_offset += 1;
+        extraBit = (bit_offset % 8);
+
+        if (pHDRDynamicInfo->data.color_saturation_mapping_flag[i]) {
+            /* color_saturation_weight: 6bit */
+            offset_limit = bit_offset + 5;
+
+            if (extraBit > 3)
+                extraByte = 1;
+
+            tempBuffer = pHDRDynamicInfo->data.num_rows_targeted_system_display_actual_peak_luminance;
+            tempBuffer = tempBuffer << (27 - extraBit);
+            for (i = 0; i < 4; i++) {
+                memcpy((char *)&buffer + i, (char *)&tempBuffer + (3 - i), sizeof(char));
+            }
+
+            for (i = 0; i < (1 + extraByte); i++) {
+                for (j = extraBit; j < 8; j++) {
+                    *((char *)pBlob + (bit_offset / 8)) |= (*((char *)&buffer + i) & (1 << (7 - j)));
+                    bit_offset++;
+
+                    if (bit_offset == offset_limit) {
+                        break;
+                    }
+                }
+                extraBit = (bit_offset % 8);
+            }
+            buffer     = 0;
+            tempBuffer = 0;
+            extraByte  = 0;
+        }
+    }
+#else // USE_FULL_ST2094_40
     /* num_windows: 2bit */
     offset_limit = bit_offset + 2;
 
@@ -1006,11 +2240,11 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
         bit_offset += 16;
         extraBit = (bit_offset % 8);
 
-        /* window_upper_right_corner_x: 16bit */
+        /* window_lower_right_corner_x: 16bit */
         bit_offset += 16;
         extraBit = (bit_offset % 8);
 
-        /* window_upper_right_corner_y: 16bit */
+        /* window_lower_right_corner_y: 16bit */
         bit_offset += 16;
         extraBit = (bit_offset % 8);
 
@@ -1071,7 +2305,8 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
     /* NOTE: These info would not set because targeted_system_display_actual_peak_luminance_flag is always 0
      * - num_rows_targeted_system_display_actual_peak_luminance: 5bit
      * - num_cols_targeted_system_display_actual_peak_luminance: 5bit
-     * - targeted_system_display_actual_peak_luminance: 4bit */
+     * - targeted_system_display_actual_peak_luminance: 4bit
+     */
 
     /* maxscl: 17bit */
     for (i = 0; i < 3; i++) {
@@ -1179,7 +2414,8 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
     /* NOTE: These infos would not be set because mastering_display_actual_peak_luminance_flag is always 0.
      * - num_rows_mastering_display_actual_peak_luminance: 5bit
      * - num_cols_mastering_display_actual_peak_luminance: 5bit
-     * - mastering_display_actual_peak_luminance: 4bit */
+     * - mastering_display_actual_peak_luminance: 4bit
+     */
 
     /* tone_mapping_flag: 1bit */
     if (pHDRDynamicInfo->data.tone_mapping.tone_mapping_flag) {
@@ -1309,7 +2545,9 @@ int Exynos_dynamic_meta_to_itu_t_t35 (
     extraBit = (bit_offset % 8);
 
     /* NOTE: This info would not be set because color_saturation_mapping_flag is always 0.
-     * - color_saturation_weight: 6bit */
+     * - color_saturation_weight: 6bit
+     */
+#endif // USE_FULL_ST2094_40
 
     if(extraBit > 0) {
         size = (bit_offset / 8) + 1;