summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
author Dichen Zhang <dichenzhang@google.com> 2023-04-10 16:28:16 -0700
committer Dichen Zhang <dichenzhang@google.com> 2023-04-12 21:48:17 +0000
commit10959a4eff0e149dd12d844cf4372a517b7c7606 (patch)
tree7da5d795fc23068bb698c43ba8495d9213926ba8
parent901994d3f2f0756cf237f689be35a629305af80b (diff)
JPEG/R refactor: rename "recovery map" to "gain map"
Bug: b/264715926 Test: build, jpegr_test, gainmapmath_test Change-Id: I9ff07ed4201f0d7ee664209fc0450808f2ec143d
Diffstat
-rw-r--r--libs/jpegrecoverymap/Android.bp2
-rw-r--r--libs/jpegrecoverymap/gainmapmath.cpp (renamed from libs/jpegrecoverymap/recoverymapmath.cpp)40
-rw-r--r--libs/jpegrecoverymap/icc.cpp2
-rw-r--r--libs/jpegrecoverymap/include/jpegrecoverymap/gainmapmath.h (renamed from libs/jpegrecoverymap/include/jpegrecoverymap/recoverymapmath.h)60
-rw-r--r--libs/jpegrecoverymap/include/jpegrecoverymap/jpegr.h102
-rw-r--r--libs/jpegrecoverymap/jpegr.cpp168
-rw-r--r--libs/jpegrecoverymap/tests/Android.bp2
-rw-r--r--libs/jpegrecoverymap/tests/gainmapmath_test.cpp (renamed from libs/jpegrecoverymap/tests/recoverymapmath_test.cpp)412
-rw-r--r--libs/jpegrecoverymap/tests/jpegr_test.cpp44
9 files changed, 416 insertions, 416 deletions
diff --git a/libs/jpegrecoverymap/Android.bp b/libs/jpegrecoverymap/Android.bp
index a1b0e19509..a376ced7f1 100644
--- a/libs/jpegrecoverymap/Android.bp
+++ b/libs/jpegrecoverymap/Android.bp
@@ -31,7 +31,7 @@ cc_library {
srcs: [
"icc.cpp",
"jpegr.cpp",
- "recoverymapmath.cpp",
+ "gainmapmath.cpp",
"jpegrutils.cpp",
"multipictureformat.cpp",
],
diff --git a/libs/jpegrecoverymap/recoverymapmath.cpp b/libs/jpegrecoverymap/gainmapmath.cpp
index ce6fc8fa47..f15a0784e8 100644
--- a/libs/jpegrecoverymap/recoverymapmath.cpp
+++ b/libs/jpegrecoverymap/gainmapmath.cpp
@@ -16,7 +16,7 @@
#include <cmath>
#include <vector>
-#include <jpegrecoverymap/recoverymapmath.h>
+#include <jpegrecoverymap/gainmapmath.h>
namespace android::jpegrecoverymap {
@@ -441,14 +441,14 @@ ColorTransformFn getHdrConversionFn(jpegr_color_gamut sdr_gamut, jpegr_color_gam
////////////////////////////////////////////////////////////////////////////////
-// Recovery map calculations
-uint8_t encodeRecovery(float y_sdr, float y_hdr, jr_metadata_ptr metadata) {
- return encodeRecovery(y_sdr, y_hdr, metadata,
- log2(metadata->minContentBoost), log2(metadata->maxContentBoost));
+// Gain map calculations
+uint8_t encodeGain(float y_sdr, float y_hdr, jr_metadata_ptr metadata) {
+ return encodeGain(y_sdr, y_hdr, metadata,
+ log2(metadata->minContentBoost), log2(metadata->maxContentBoost));
}
-uint8_t encodeRecovery(float y_sdr, float y_hdr, jr_metadata_ptr metadata,
- float log2MinContentBoost, float log2MaxContentBoost) {
+uint8_t encodeGain(float y_sdr, float y_hdr, jr_metadata_ptr metadata,
+ float log2MinContentBoost, float log2MaxContentBoost) {
float gain = 1.0f;
if (y_sdr > 0.0f) {
gain = y_hdr / y_sdr;
@@ -462,23 +462,23 @@ uint8_t encodeRecovery(float y_sdr, float y_hdr, jr_metadata_ptr metadata,
* 255.0f);
}
-Color applyRecovery(Color e, float recovery, jr_metadata_ptr metadata) {
- float logBoost = log2(metadata->minContentBoost) * (1.0f - recovery)
- + log2(metadata->maxContentBoost) * recovery;
- float recoveryFactor = exp2(logBoost);
- return e * recoveryFactor;
+Color applyGain(Color e, float gain, jr_metadata_ptr metadata) {
+ float logBoost = log2(metadata->minContentBoost) * (1.0f - gain)
+ + log2(metadata->maxContentBoost) * gain;
+ float gainFactor = exp2(logBoost);
+ return e * gainFactor;
}
-Color applyRecovery(Color e, float recovery, jr_metadata_ptr metadata, float displayBoost) {
- float logBoost = log2(metadata->minContentBoost) * (1.0f - recovery)
- + log2(metadata->maxContentBoost) * recovery;
- float recoveryFactor = exp2(logBoost * displayBoost / metadata->maxContentBoost);
- return e * recoveryFactor;
+Color applyGain(Color e, float gain, jr_metadata_ptr metadata, float displayBoost) {
+ float logBoost = log2(metadata->minContentBoost) * (1.0f - gain)
+ + log2(metadata->maxContentBoost) * gain;
+ float gainFactor = exp2(logBoost * displayBoost / metadata->maxContentBoost);
+ return e * gainFactor;
}
-Color applyRecoveryLUT(Color e, float recovery, RecoveryLUT& recoveryLUT) {
- float recoveryFactor = recoveryLUT.getRecoveryFactor(recovery);
- return e * recoveryFactor;
+Color applyGainLUT(Color e, float gain, GainLUT& gainLUT) {
+ float gainFactor = gainLUT.getGainFactor(gain);
+ return e * gainFactor;
}
Color getYuv420Pixel(jr_uncompressed_ptr image, size_t x, size_t y) {
diff --git a/libs/jpegrecoverymap/icc.cpp b/libs/jpegrecoverymap/icc.cpp
index 5412cb1102..6e78f671e5 100644
--- a/libs/jpegrecoverymap/icc.cpp
+++ b/libs/jpegrecoverymap/icc.cpp
@@ -15,7 +15,7 @@
*/
#include <jpegrecoverymap/icc.h>
-#include <jpegrecoverymap/recoverymapmath.h>
+#include <jpegrecoverymap/gainmapmath.h>
#include <vector>
#include <utils/Log.h>
diff --git a/libs/jpegrecoverymap/include/jpegrecoverymap/recoverymapmath.h b/libs/jpegrecoverymap/include/jpegrecoverymap/gainmapmath.h
index a32b29119e..57fddd0a42 100644
--- a/libs/jpegrecoverymap/include/jpegrecoverymap/recoverymapmath.h
+++ b/libs/jpegrecoverymap/include/jpegrecoverymap/gainmapmath.h
@@ -129,40 +129,40 @@ inline uint16_t floatToHalf(float f) {
| (e > 143) * 0x7FFF;
}
-constexpr size_t kRecoveryFactorPrecision = 10;
-constexpr size_t kRecoveryFactorNumEntries = 1 << kRecoveryFactorPrecision;
-struct RecoveryLUT {
- RecoveryLUT(jr_metadata_ptr metadata) {
- for (int idx = 0; idx < kRecoveryFactorNumEntries; idx++) {
- float value = static_cast<float>(idx) / static_cast<float>(kRecoveryFactorNumEntries - 1);
+constexpr size_t kGainFactorPrecision = 10;
+constexpr size_t kGainFactorNumEntries = 1 << kGainFactorPrecision;
+struct GainLUT {
+ GainLUT(jr_metadata_ptr metadata) {
+ for (int idx = 0; idx < kGainFactorNumEntries; idx++) {
+ float value = static_cast<float>(idx) / static_cast<float>(kGainFactorNumEntries - 1);
float logBoost = log2(metadata->minContentBoost) * (1.0f - value)
+ log2(metadata->maxContentBoost) * value;
- mRecoveryTable[idx] = exp2(logBoost);
+ mGainTable[idx] = exp2(logBoost);
}
}
- RecoveryLUT(jr_metadata_ptr metadata, float displayBoost) {
+ GainLUT(jr_metadata_ptr metadata, float displayBoost) {
float boostFactor = displayBoost > 0 ? displayBoost / metadata->maxContentBoost : 1.0f;
- for (int idx = 0; idx < kRecoveryFactorNumEntries; idx++) {
- float value = static_cast<float>(idx) / static_cast<float>(kRecoveryFactorNumEntries - 1);
+ for (int idx = 0; idx < kGainFactorNumEntries; idx++) {
+ float value = static_cast<float>(idx) / static_cast<float>(kGainFactorNumEntries - 1);
float logBoost = log2(metadata->minContentBoost) * (1.0f - value)
+ log2(metadata->maxContentBoost) * value;
- mRecoveryTable[idx] = exp2(logBoost * boostFactor);
+ mGainTable[idx] = exp2(logBoost * boostFactor);
}
}
- ~RecoveryLUT() {
+ ~GainLUT() {
}
- float getRecoveryFactor(float recovery) {
- uint32_t idx = static_cast<uint32_t>(recovery * (kRecoveryFactorNumEntries - 1));
+ float getGainFactor(float gain) {
+ uint32_t idx = static_cast<uint32_t>(gain * (kGainFactorNumEntries - 1));
//TODO() : Remove once conversion modules have appropriate clamping in place
- idx = CLIP3(idx, 0, kRecoveryFactorNumEntries - 1);
- return mRecoveryTable[idx];
+ idx = CLIP3(idx, 0, kGainFactorNumEntries - 1);
+ return mGainTable[idx];
}
private:
- float mRecoveryTable[kRecoveryFactorNumEntries];
+ float mGainTable[kGainFactorNumEntries];
};
struct ShepardsIDW {
@@ -195,11 +195,11 @@ struct ShepardsIDW {
// p60 p61 p62 p63 p64 p65 p66 p67
// p70 p71 p72 p73 p74 p75 p76 p77
- // Recovery Map (for 4 scale factor) :-
+ // Gain Map (for 4 scale factor) :-
// m00 p01
// m10 m11
- // Recovery sample of curr 4x4, right 4x4, bottom 4x4, bottom right 4x4 are used during
+ // Gain sample of curr 4x4, right 4x4, bottom 4x4, bottom right 4x4 are used during
// reconstruction. hence table weight size is 4.
float* mWeights;
// TODO: check if its ok to mWeights at places
@@ -354,29 +354,29 @@ Color bt2100ToP3(Color e);
inline Color identityConversion(Color e) { return e; }
/*
- * Get the conversion to apply to the HDR image for recovery map generation
+ * Get the conversion to apply to the HDR image for gain map generation
*/
ColorTransformFn getHdrConversionFn(jpegr_color_gamut sdr_gamut, jpegr_color_gamut hdr_gamut);
////////////////////////////////////////////////////////////////////////////////
-// Recovery map calculations
+// Gain map calculations
/*
- * Calculate the 8-bit unsigned integer recovery value for the given SDR and HDR
+ * Calculate the 8-bit unsigned integer gain value for the given SDR and HDR
* luminances in linear space, and the hdr ratio to encode against.
*/
-uint8_t encodeRecovery(float y_sdr, float y_hdr, jr_metadata_ptr metadata);
-uint8_t encodeRecovery(float y_sdr, float y_hdr, jr_metadata_ptr metadata,
- float log2MinContentBoost, float log2MaxContentBoost);
+uint8_t encodeGain(float y_sdr, float y_hdr, jr_metadata_ptr metadata);
+uint8_t encodeGain(float y_sdr, float y_hdr, jr_metadata_ptr metadata,
+ float log2MinContentBoost, float log2MaxContentBoost);
/*
- * Calculates the linear luminance in nits after applying the given recovery
+ * Calculates the linear luminance in nits after applying the given gain
* value, with the given hdr ratio, to the given sdr input in the range [0, 1].
*/
-Color applyRecovery(Color e, float recovery, jr_metadata_ptr metadata);
-Color applyRecovery(Color e, float recovery, jr_metadata_ptr metadata, float displayBoost);
-Color applyRecoveryLUT(Color e, float recovery, RecoveryLUT& recoveryLUT);
+Color applyGain(Color e, float gain, jr_metadata_ptr metadata);
+Color applyGain(Color e, float gain, jr_metadata_ptr metadata, float displayBoost);
+Color applyGainLUT(Color e, float gain, GainLUT& gainLUT);
/*
* Helper for sampling from YUV 420 images.
@@ -405,7 +405,7 @@ Color sampleYuv420(jr_uncompressed_ptr map, size_t map_scale_factor, size_t x, s
Color sampleP010(jr_uncompressed_ptr map, size_t map_scale_factor, size_t x, size_t y);
/*
- * Sample the recovery value for the map from a given x,y coordinate on a scale
+ * Sample the gain value for the map from a given x,y coordinate on a scale
* that is map scale factor larger than the map size.
*/
float sampleMap(jr_uncompressed_ptr map, float map_scale_factor, size_t x, size_t y);
diff --git a/libs/jpegrecoverymap/include/jpegrecoverymap/jpegr.h b/libs/jpegrecoverymap/include/jpegrecoverymap/jpegr.h
index afec0655b3..ce7b33b495 100644
--- a/libs/jpegrecoverymap/include/jpegrecoverymap/jpegr.h
+++ b/libs/jpegrecoverymap/include/jpegrecoverymap/jpegr.h
@@ -58,14 +58,14 @@ struct jpegr_info_struct {
};
/*
- * Holds information for uncompressed image or recovery map.
+ * Holds information for uncompressed image or gain map.
*/
struct jpegr_uncompressed_struct {
// Pointer to the data location.
void* data;
- // Width of the recovery map or the luma plane of the image in pixels.
+ // Width of the gain map or the luma plane of the image in pixels.
int width;
- // Height of the recovery map or the luma plane of the image in pixels.
+ // Height of the gain map or the luma plane of the image in pixels.
int height;
// Color gamut.
jpegr_color_gamut colorGamut;
@@ -86,7 +86,7 @@ struct jpegr_uncompressed_struct {
};
/*
- * Holds information for compressed image or recovery map.
+ * Holds information for compressed image or gain map.
*/
struct jpegr_compressed_struct {
// Pointer to the data location.
@@ -110,7 +110,7 @@ struct jpegr_exif_struct {
};
/*
- * Holds information for recovery map related metadata.
+ * Holds information for gain map related metadata.
*/
struct jpegr_metadata_struct {
// JPEG/R version
@@ -135,8 +135,8 @@ public:
* Encode API-0
* Compress JPEGR image from 10-bit HDR YUV.
*
- * Tonemap the HDR input to a SDR image, generate recovery map from the HDR and SDR images,
- * compress SDR YUV to 8-bit JPEG and append the recovery map to the end of the compressed
+ * Tonemap the HDR input to a SDR image, generate gain map from the HDR and SDR images,
+ * compress SDR YUV to 8-bit JPEG and append the gain map to the end of the compressed
* JPEG.
* @param uncompressed_p010_image uncompressed HDR image in P010 color format
* @param hdr_tf transfer function of the HDR image
@@ -156,8 +156,8 @@ public:
* Encode API-1
* Compress JPEGR image from 10-bit HDR YUV and 8-bit SDR YUV.
*
- * Generate recovery map from the HDR and SDR inputs, compress SDR YUV to 8-bit JPEG and append
- * the recovery map to the end of the compressed JPEG. HDR and SDR inputs must be the same
+ * Generate gain map from the HDR and SDR inputs, compress SDR YUV to 8-bit JPEG and append
+ * the gain map to the end of the compressed JPEG. HDR and SDR inputs must be the same
* resolution.
* @param uncompressed_p010_image uncompressed HDR image in P010 color format
* @param uncompressed_yuv_420_image uncompressed SDR image in YUV_420 color format
@@ -181,7 +181,7 @@ public:
*
* This method requires HAL Hardware JPEG encoder.
*
- * Generate recovery map from the HDR and SDR inputs, append the recovery map to the end of the
+ * Generate gain map from the HDR and SDR inputs, append the gain map to the end of the
* compressed JPEG. HDR and SDR inputs must be the same resolution and color space.
* @param uncompressed_p010_image uncompressed HDR image in P010 color format
* @param uncompressed_yuv_420_image uncompressed SDR image in YUV_420 color format
@@ -204,8 +204,8 @@ public:
*
* This method requires HAL Hardware JPEG encoder.
*
- * Decode the compressed 8-bit JPEG image to YUV SDR, generate recovery map from the HDR input
- * and the decoded SDR result, append the recovery map to the end of the compressed JPEG. HDR
+ * Decode the compressed 8-bit JPEG image to YUV SDR, generate gain map from the HDR input
+ * and the decoded SDR result, append the gain map to the end of the compressed JPEG. HDR
* and SDR inputs must be the same resolution.
* @param uncompressed_p010_image uncompressed HDR image in P010 color format
* @param compressed_jpeg_image compressed 8-bit JPEG image
@@ -242,9 +242,9 @@ public:
----------------------------------------------------------------------
| JPEGR_OUTPUT_HDR_HLG | RGBA_1010102 HLG |
----------------------------------------------------------------------
- * @param recovery_map destination of the decoded recovery map. The default value is NULL where
+ * @param gain_map destination of the decoded gain map. The default value is NULL where
the decoder will do nothing about it. If configured not NULL the decoder
- will write the decoded recovery_map data into this structure. The format
+ will write the decoded gain_map data into this structure. The format
is defined in {@code jpegr_uncompressed_struct}.
* @param metadata destination of the decoded metadata. The default value is NULL where the
decoder will do nothing about it. If configured not NULL the decoder will
@@ -257,7 +257,7 @@ public:
float max_display_boost = FLT_MAX,
jr_exif_ptr exif = nullptr,
jpegr_output_format output_format = JPEGR_OUTPUT_HDR_LINEAR,
- jr_uncompressed_ptr recovery_map = nullptr,
+ jr_uncompressed_ptr gain_map = nullptr,
jr_metadata_ptr metadata = nullptr);
/*
@@ -274,30 +274,30 @@ public:
protected:
/*
* This method is called in the encoding pipeline. It will take the uncompressed 8-bit and
- * 10-bit yuv images as input, and calculate the uncompressed recovery map. The input images
+ * 10-bit yuv images as input, and calculate the uncompressed gain map. The input images
* must be the same resolution.
*
* @param uncompressed_yuv_420_image uncompressed SDR image in YUV_420 color format
* @param uncompressed_p010_image uncompressed HDR image in P010 color format
* @param hdr_tf transfer function of the HDR image
- * @param dest recovery map; caller responsible for memory of data
+ * @param dest gain map; caller responsible for memory of data
* @param metadata max_content_boost is filled in
* @return NO_ERROR if calculation succeeds, error code if error occurs.
*/
- status_t generateRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
- jr_uncompressed_ptr uncompressed_p010_image,
- jpegr_transfer_function hdr_tf,
- jr_metadata_ptr metadata,
- jr_uncompressed_ptr dest);
+ status_t generateGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
+ jr_uncompressed_ptr uncompressed_p010_image,
+ jpegr_transfer_function hdr_tf,
+ jr_metadata_ptr metadata,
+ jr_uncompressed_ptr dest);
/*
* This method is called in the decoding pipeline. It will take the uncompressed (decoded)
- * 8-bit yuv image, the uncompressed (decoded) recovery map, and extracted JPEG/R metadata as
+ * 8-bit yuv image, the uncompressed (decoded) gain map, and extracted JPEG/R metadata as
* input, and calculate the 10-bit recovered image. The recovered output image is the same
* color gamut as the SDR image, with HLG transfer function, and is in RGBA1010102 data format.
*
* @param uncompressed_yuv_420_image uncompressed SDR image in YUV_420 color format
- * @param uncompressed_recovery_map uncompressed recovery map
+ * @param uncompressed_gain_map uncompressed gain map
* @param metadata JPEG/R metadata extracted from XMP.
* @param output_format flag for setting output color format. if set to
* {@code JPEGR_OUTPUT_SDR}, decoder will only decode the primary image
@@ -306,67 +306,67 @@ protected:
* @param dest reconstructed HDR image
* @return NO_ERROR if calculation succeeds, error code if error occurs.
*/
- status_t applyRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
- jr_uncompressed_ptr uncompressed_recovery_map,
- jr_metadata_ptr metadata,
- jpegr_output_format output_format,
- float max_display_boost,
- jr_uncompressed_ptr dest);
+ status_t applyGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
+ jr_uncompressed_ptr uncompressed_gain_map,
+ jr_metadata_ptr metadata,
+ jpegr_output_format output_format,
+ float max_display_boost,
+ jr_uncompressed_ptr dest);
private:
/*
- * This method is called in the encoding pipeline. It will encode the recovery map.
+ * This method is called in the encoding pipeline. It will encode the gain map.
*
- * @param uncompressed_recovery_map uncompressed recovery map
+ * @param uncompressed_gain_map uncompressed gain map
* @param dest encoded recover map
* @return NO_ERROR if encoding succeeds, error code if error occurs.
*/
- status_t compressRecoveryMap(jr_uncompressed_ptr uncompressed_recovery_map,
- jr_compressed_ptr dest);
+ status_t compressGainMap(jr_uncompressed_ptr uncompressed_gain_map,
+ jr_compressed_ptr dest);
/*
- * This methoud is called to separate primary image and recovery map image from JPEGR
+ * This methoud is called to separate primary image and gain map image from JPEGR
*
* @param compressed_jpegr_image compressed JPEGR image
* @param primary_image destination of primary image
- * @param recovery_map destination of compressed recovery map
+ * @param gain_map destination of compressed gain map
* @return NO_ERROR if calculation succeeds, error code if error occurs.
*/
- status_t extractPrimaryImageAndRecoveryMap(jr_compressed_ptr compressed_jpegr_image,
- jr_compressed_ptr primary_image,
- jr_compressed_ptr recovery_map);
+ status_t extractPrimaryImageAndGainMap(jr_compressed_ptr compressed_jpegr_image,
+ jr_compressed_ptr primary_image,
+ jr_compressed_ptr gain_map);
/*
* This method is called in the decoding pipeline. It will read XMP metadata to find the start
- * position of the compressed recovery map, and will extract the compressed recovery map.
+ * position of the compressed gain map, and will extract the compressed gain map.
*
* @param compressed_jpegr_image compressed JPEGR image
- * @param dest destination of compressed recovery map
+ * @param dest destination of compressed gain map
* @return NO_ERROR if calculation succeeds, error code if error occurs.
*/
- status_t extractRecoveryMap(jr_compressed_ptr compressed_jpegr_image,
- jr_compressed_ptr dest);
+ status_t extractGainMap(jr_compressed_ptr compressed_jpegr_image,
+ jr_compressed_ptr dest);
/*
* This method is called in the encoding pipeline. It will take the standard 8-bit JPEG image,
- * the compressed recovery map and optionally the exif package as inputs, and generate the XMP
+ * the compressed gain map and optionally the exif package as inputs, and generate the XMP
* metadata, and finally append everything in the order of:
- * SOI, APP2(EXIF) (if EXIF is from outside), APP2(XMP), primary image, recovery map
+ * SOI, APP2(EXIF) (if EXIF is from outside), APP2(XMP), primary image, gain map
* Note that EXIF package is only available for encoding API-0 and API-1. For encoding API-2 and
* API-3 this parameter is null, but the primary image in JPEG/R may still have EXIF as long as
* the input JPEG has EXIF.
*
* @param compressed_jpeg_image compressed 8-bit JPEG image
- * @param compress_recovery_map compressed recover map
+ * @param compress_gain_map compressed recover map
* @param (nullable) exif EXIF package
* @param metadata JPEG/R metadata to encode in XMP of the jpeg
* @param dest compressed JPEGR image
* @return NO_ERROR if calculation succeeds, error code if error occurs.
*/
- status_t appendRecoveryMap(jr_compressed_ptr compressed_jpeg_image,
- jr_compressed_ptr compressed_recovery_map,
- jr_exif_ptr exif,
- jr_metadata_ptr metadata,
- jr_compressed_ptr dest);
+ status_t appendGainMap(jr_compressed_ptr compressed_jpeg_image,
+ jr_compressed_ptr compressed_gain_map,
+ jr_exif_ptr exif,
+ jr_metadata_ptr metadata,
+ jr_compressed_ptr dest);
/*
* This method will tone map a HDR image to an SDR image.
diff --git a/libs/jpegrecoverymap/jpegr.cpp b/libs/jpegrecoverymap/jpegr.cpp
index cdf685e005..2590f63623 100644
--- a/libs/jpegrecoverymap/jpegr.cpp
+++ b/libs/jpegrecoverymap/jpegr.cpp
@@ -17,7 +17,7 @@
#include <jpegrecoverymap/jpegr.h>
#include <jpegrecoverymap/jpegencoderhelper.h>
#include <jpegrecoverymap/jpegdecoderhelper.h>
-#include <jpegrecoverymap/recoverymapmath.h>
+#include <jpegrecoverymap/gainmapmath.h>
#include <jpegrecoverymap/jpegrutils.h>
#include <jpegrecoverymap/multipictureformat.h>
#include <jpegrecoverymap/icc.h>
@@ -50,7 +50,7 @@ namespace android::jpegrecoverymap {
#define USE_PQ_OETF_LUT 1
#define USE_HLG_INVOETF_LUT 1
#define USE_PQ_INVOETF_LUT 1
-#define USE_APPLY_RECOVERY_LUT 1
+#define USE_APPLY_GAIN_LUT 1
#define JPEGR_CHECK(x) \
{ \
@@ -69,7 +69,7 @@ static const size_t kMapDimensionScaleFactor = 4;
// JPEG encoding / decoding will require 8 x 8 DCT transform.
// Width must be 8 dividable, and height must be 2 dividable.
static const size_t kJpegBlock = 8;
-// JPEG compress quality (0 ~ 100) for recovery map
+// JPEG compress quality (0 ~ 100) for gain map
static const int kMapCompressQuality = 85;
#define CONFIG_MULTITHREAD 1
@@ -163,7 +163,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
JPEGR_CHECK(toneMap(uncompressed_p010_image, &uncompressed_yuv_420_image));
jpegr_uncompressed_struct map;
- JPEGR_CHECK(generateRecoveryMap(
+ JPEGR_CHECK(generateGainMap(
&uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map));
std::unique_ptr<uint8_t[]> map_data;
map_data.reset(reinterpret_cast<uint8_t*>(map.data));
@@ -172,7 +172,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
compressed_map.maxLength = map.width * map.height;
unique_ptr<uint8_t[]> compressed_map_data = make_unique<uint8_t[]>(compressed_map.maxLength);
compressed_map.data = compressed_map_data.get();
- JPEGR_CHECK(compressRecoveryMap(&map, &compressed_map));
+ JPEGR_CHECK(compressGainMap(&map, &compressed_map));
sp<DataStruct> icc = IccHelper::writeIccProfile(JPEGR_TF_SRGB,
uncompressed_yuv_420_image.colorGamut);
@@ -188,7 +188,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
jpeg.data = jpeg_encoder.getCompressedImagePtr();
jpeg.length = jpeg_encoder.getCompressedImageSize();
- JPEGR_CHECK(appendRecoveryMap(&jpeg, &compressed_map, exif, &metadata, dest));
+ JPEGR_CHECK(appendGainMap(&jpeg, &compressed_map, exif, &metadata, dest));
return NO_ERROR;
}
@@ -219,7 +219,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
metadata.version = kJpegrVersion;
jpegr_uncompressed_struct map;
- JPEGR_CHECK(generateRecoveryMap(
+ JPEGR_CHECK(generateGainMap(
uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map));
std::unique_ptr<uint8_t[]> map_data;
map_data.reset(reinterpret_cast<uint8_t*>(map.data));
@@ -228,7 +228,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
compressed_map.maxLength = map.width * map.height;
unique_ptr<uint8_t[]> compressed_map_data = make_unique<uint8_t[]>(compressed_map.maxLength);
compressed_map.data = compressed_map_data.get();
- JPEGR_CHECK(compressRecoveryMap(&map, &compressed_map));
+ JPEGR_CHECK(compressGainMap(&map, &compressed_map));
sp<DataStruct> icc = IccHelper::writeIccProfile(JPEGR_TF_SRGB,
uncompressed_yuv_420_image->colorGamut);
@@ -244,7 +244,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
jpeg.data = jpeg_encoder.getCompressedImagePtr();
jpeg.length = jpeg_encoder.getCompressedImageSize();
- JPEGR_CHECK(appendRecoveryMap(&jpeg, &compressed_map, exif, &metadata, dest));
+ JPEGR_CHECK(appendGainMap(&jpeg, &compressed_map, exif, &metadata, dest));
return NO_ERROR;
}
@@ -271,7 +271,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
metadata.version = kJpegrVersion;
jpegr_uncompressed_struct map;
- JPEGR_CHECK(generateRecoveryMap(
+ JPEGR_CHECK(generateGainMap(
uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map));
std::unique_ptr<uint8_t[]> map_data;
map_data.reset(reinterpret_cast<uint8_t*>(map.data));
@@ -280,9 +280,9 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
compressed_map.maxLength = map.width * map.height;
unique_ptr<uint8_t[]> compressed_map_data = make_unique<uint8_t[]>(compressed_map.maxLength);
compressed_map.data = compressed_map_data.get();
- JPEGR_CHECK(compressRecoveryMap(&map, &compressed_map));
+ JPEGR_CHECK(compressGainMap(&map, &compressed_map));
- JPEGR_CHECK(appendRecoveryMap(compressed_jpeg_image, &compressed_map, nullptr, &metadata, dest));
+ JPEGR_CHECK(appendGainMap(compressed_jpeg_image, &compressed_map, nullptr, &metadata, dest));
return NO_ERROR;
}
@@ -322,7 +322,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
metadata.version = kJpegrVersion;
jpegr_uncompressed_struct map;
- JPEGR_CHECK(generateRecoveryMap(
+ JPEGR_CHECK(generateGainMap(
&uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map));
std::unique_ptr<uint8_t[]> map_data;
map_data.reset(reinterpret_cast<uint8_t*>(map.data));
@@ -331,9 +331,9 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
compressed_map.maxLength = map.width * map.height;
unique_ptr<uint8_t[]> compressed_map_data = make_unique<uint8_t[]>(compressed_map.maxLength);
compressed_map.data = compressed_map_data.get();
- JPEGR_CHECK(compressRecoveryMap(&map, &compressed_map));
+ JPEGR_CHECK(compressGainMap(&map, &compressed_map));
- JPEGR_CHECK(appendRecoveryMap(compressed_jpeg_image, &compressed_map, nullptr, &metadata, dest));
+ JPEGR_CHECK(appendGainMap(compressed_jpeg_image, &compressed_map, nullptr, &metadata, dest));
return NO_ERROR;
}
@@ -343,9 +343,9 @@ status_t JpegR::getJPEGRInfo(jr_compressed_ptr compressed_jpegr_image, jr_info_p
return ERROR_JPEGR_INVALID_NULL_PTR;
}
- jpegr_compressed_struct primary_image, recovery_map;
- JPEGR_CHECK(extractPrimaryImageAndRecoveryMap(compressed_jpegr_image,
- &primary_image, &recovery_map));
+ jpegr_compressed_struct primary_image, gain_map;
+ JPEGR_CHECK(extractPrimaryImageAndGainMap(compressed_jpegr_image,
+ &primary_image, &gain_map));
JpegDecoderHelper jpeg_decoder;
if (!jpeg_decoder.getCompressedImageParameters(primary_image.data, primary_image.length,
@@ -363,7 +363,7 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr compressed_jpegr_image,
float max_display_boost,
jr_exif_ptr exif,
jpegr_output_format output_format,
- jr_uncompressed_ptr recovery_map,
+ jr_uncompressed_ptr gain_map,
jr_metadata_ptr metadata) {
if (compressed_jpegr_image == nullptr || dest == nullptr) {
return ERROR_JPEGR_INVALID_NULL_PTR;
@@ -388,7 +388,7 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr compressed_jpegr_image,
dest->width = uncompressed_rgba_image.width;
dest->height = uncompressed_rgba_image.height;
- if (recovery_map == nullptr && exif == nullptr) {
+ if (gain_map == nullptr && exif == nullptr) {
return NO_ERROR;
}
@@ -402,30 +402,30 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr compressed_jpegr_image,
memcpy(exif->data, jpeg_decoder.getEXIFPtr(), jpeg_decoder.getEXIFSize());
exif->length = jpeg_decoder.getEXIFSize();
}
- if (recovery_map == nullptr) {
+ if (gain_map == nullptr) {
return NO_ERROR;
}
}
jpegr_compressed_struct compressed_map;
- JPEGR_CHECK(extractRecoveryMap(compressed_jpegr_image, &compressed_map));
+ JPEGR_CHECK(extractGainMap(compressed_jpegr_image, &compressed_map));
- JpegDecoderHelper recovery_map_decoder;
- if (!recovery_map_decoder.decompressImage(compressed_map.data, compressed_map.length)) {
+ JpegDecoderHelper gain_map_decoder;
+ if (!gain_map_decoder.decompressImage(compressed_map.data, compressed_map.length)) {
return ERROR_JPEGR_DECODE_ERROR;
}
- if (recovery_map != nullptr) {
- recovery_map->width = recovery_map_decoder.getDecompressedImageWidth();
- recovery_map->height = recovery_map_decoder.getDecompressedImageHeight();
- int size = recovery_map->width * recovery_map->height;
- recovery_map->data = malloc(size);
- memcpy(recovery_map->data, recovery_map_decoder.getDecompressedImagePtr(), size);
+ if (gain_map != nullptr) {
+ gain_map->width = gain_map_decoder.getDecompressedImageWidth();
+ gain_map->height = gain_map_decoder.getDecompressedImageHeight();
+ int size = gain_map->width * gain_map->height;
+ gain_map->data = malloc(size);
+ memcpy(gain_map->data, gain_map_decoder.getDecompressedImagePtr(), size);
}
jpegr_metadata_struct jr_metadata;
- if (!getMetadataFromXMP(static_cast<uint8_t*>(recovery_map_decoder.getXMPPtr()),
- recovery_map_decoder.getXMPSize(), &jr_metadata)) {
+ if (!getMetadataFromXMP(static_cast<uint8_t*>(gain_map_decoder.getXMPPtr()),
+ gain_map_decoder.getXMPSize(), &jr_metadata)) {
return ERROR_JPEGR_DECODE_ERROR;
}
@@ -456,30 +456,30 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr compressed_jpegr_image,
}
jpegr_uncompressed_struct map;
- map.data = recovery_map_decoder.getDecompressedImagePtr();
- map.width = recovery_map_decoder.getDecompressedImageWidth();
- map.height = recovery_map_decoder.getDecompressedImageHeight();
+ map.data = gain_map_decoder.getDecompressedImagePtr();
+ map.width = gain_map_decoder.getDecompressedImageWidth();
+ map.height = gain_map_decoder.getDecompressedImageHeight();
jpegr_uncompressed_struct uncompressed_yuv_420_image;
uncompressed_yuv_420_image.data = jpeg_decoder.getDecompressedImagePtr();
uncompressed_yuv_420_image.width = jpeg_decoder.getDecompressedImageWidth();
uncompressed_yuv_420_image.height = jpeg_decoder.getDecompressedImageHeight();
- JPEGR_CHECK(applyRecoveryMap(&uncompressed_yuv_420_image, &map, &jr_metadata, output_format,
- max_display_boost, dest));
+ JPEGR_CHECK(applyGainMap(&uncompressed_yuv_420_image, &map, &jr_metadata, output_format,
+ max_display_boost, dest));
return NO_ERROR;
}
-status_t JpegR::compressRecoveryMap(jr_uncompressed_ptr uncompressed_recovery_map,
- jr_compressed_ptr dest) {
- if (uncompressed_recovery_map == nullptr || dest == nullptr) {
+status_t JpegR::compressGainMap(jr_uncompressed_ptr uncompressed_gain_map,
+ jr_compressed_ptr dest) {
+ if (uncompressed_gain_map == nullptr || dest == nullptr) {
return ERROR_JPEGR_INVALID_NULL_PTR;
}
JpegEncoderHelper jpeg_encoder;
- if (!jpeg_encoder.compressImage(uncompressed_recovery_map->data,
- uncompressed_recovery_map->width,
- uncompressed_recovery_map->height,
+ if (!jpeg_encoder.compressImage(uncompressed_gain_map->data,
+ uncompressed_gain_map->width,
+ uncompressed_gain_map->height,
kMapCompressQuality,
nullptr,
0,
@@ -554,11 +554,11 @@ void JobQueue::reset() {
mQueuedAllJobs = false;
}
-status_t JpegR::generateRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
- jr_uncompressed_ptr uncompressed_p010_image,
- jpegr_transfer_function hdr_tf,
- jr_metadata_ptr metadata,
- jr_uncompressed_ptr dest) {
+status_t JpegR::generateGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
+ jr_uncompressed_ptr uncompressed_p010_image,
+ jpegr_transfer_function hdr_tf,
+ jr_metadata_ptr metadata,
+ jr_uncompressed_ptr dest) {
if (uncompressed_yuv_420_image == nullptr
|| uncompressed_p010_image == nullptr
|| metadata == nullptr
@@ -675,7 +675,7 @@ status_t JpegR::generateRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_ima
size_t pixel_idx = x + y * dest_map_stride;
reinterpret_cast<uint8_t*>(dest->data)[pixel_idx] =
- encodeRecovery(sdr_y_nits, hdr_y_nits, metadata, log2MinBoost, log2MaxBoost);
+ encodeGain(sdr_y_nits, hdr_y_nits, metadata, log2MinBoost, log2MaxBoost);
}
}
}
@@ -701,14 +701,14 @@ status_t JpegR::generateRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_ima
return NO_ERROR;
}
-status_t JpegR::applyRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
- jr_uncompressed_ptr uncompressed_recovery_map,
- jr_metadata_ptr metadata,
- jpegr_output_format output_format,
- float max_display_boost,
- jr_uncompressed_ptr dest) {
+status_t JpegR::applyGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
+ jr_uncompressed_ptr uncompressed_gain_map,
+ jr_metadata_ptr metadata,
+ jpegr_output_format output_format,
+ float max_display_boost,
+ jr_uncompressed_ptr dest) {
if (uncompressed_yuv_420_image == nullptr
- || uncompressed_recovery_map == nullptr
+ || uncompressed_gain_map == nullptr
|| metadata == nullptr
|| dest == nullptr) {
return ERROR_JPEGR_INVALID_NULL_PTR;
@@ -718,12 +718,12 @@ status_t JpegR::applyRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
dest->height = uncompressed_yuv_420_image->height;
ShepardsIDW idwTable(kMapDimensionScaleFactor);
float display_boost = std::min(max_display_boost, metadata->maxContentBoost);
- RecoveryLUT recoveryLUT(metadata, display_boost);
+ GainLUT gainLUT(metadata, display_boost);
JobQueue jobQueue;
- std::function<void()> applyRecMap = [uncompressed_yuv_420_image, uncompressed_recovery_map,
+ std::function<void()> applyRecMap = [uncompressed_yuv_420_image, uncompressed_gain_map,
metadata, dest, &jobQueue, &idwTable, output_format,
- &recoveryLUT, display_boost]() -> void {
+ &gainLUT, display_boost]() -> void {
size_t width = uncompressed_yuv_420_image->width;
size_t height = uncompressed_yuv_420_image->height;
@@ -738,22 +738,22 @@ status_t JpegR::applyRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
#else
Color rgb_sdr = srgbInvOetf(rgb_gamma_sdr);
#endif
- float recovery;
+ float gain;
// TODO: determine map scaling factor based on actual map dims
size_t map_scale_factor = kMapDimensionScaleFactor;
// TODO: If map_scale_factor is guaranteed to be an integer, then remove the following.
// Currently map_scale_factor is of type size_t, but it could be changed to a float
// later.
if (map_scale_factor != floorf(map_scale_factor)) {
- recovery = sampleMap(uncompressed_recovery_map, map_scale_factor, x, y);
+ gain = sampleMap(uncompressed_gain_map, map_scale_factor, x, y);
} else {
- recovery = sampleMap(uncompressed_recovery_map, map_scale_factor, x, y, idwTable);
+ gain = sampleMap(uncompressed_gain_map, map_scale_factor, x, y, idwTable);
}
-#if USE_APPLY_RECOVERY_LUT
- Color rgb_hdr = applyRecoveryLUT(rgb_sdr, recovery, recoveryLUT);
+#if USE_APPLY_GAIN_LUT
+ Color rgb_hdr = applyGainLUT(rgb_sdr, gain, gainLUT);
#else
- Color rgb_hdr = applyRecovery(rgb_sdr, recovery, metadata, display_boost);
+ Color rgb_hdr = applyGain(rgb_sdr, gain, metadata, display_boost);
#endif
rgb_hdr = rgb_hdr / display_boost;
size_t pixel_idx = x + y * width;
@@ -815,9 +815,9 @@ status_t JpegR::applyRecoveryMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
return NO_ERROR;
}
-status_t JpegR::extractPrimaryImageAndRecoveryMap(jr_compressed_ptr compressed_jpegr_image,
- jr_compressed_ptr primary_image,
- jr_compressed_ptr recovery_map) {
+status_t JpegR::extractPrimaryImageAndGainMap(jr_compressed_ptr compressed_jpegr_image,
+ jr_compressed_ptr primary_image,
+ jr_compressed_ptr gain_map) {
if (compressed_jpegr_image == nullptr) {
return ERROR_JPEGR_INVALID_NULL_PTR;
}
@@ -855,23 +855,23 @@ status_t JpegR::extractPrimaryImageAndRecoveryMap(jr_compressed_ptr compressed_j
primary_image->length = image_ranges[0].GetLength();
}
- if (recovery_map != nullptr) {
- recovery_map->data = static_cast<uint8_t*>(compressed_jpegr_image->data) +
+ if (gain_map != nullptr) {
+ gain_map->data = static_cast<uint8_t*>(compressed_jpegr_image->data) +
image_ranges[1].GetBegin();
- recovery_map->length = image_ranges[1].GetLength();
+ gain_map->length = image_ranges[1].GetLength();
}
return NO_ERROR;
}
-status_t JpegR::extractRecoveryMap(jr_compressed_ptr compressed_jpegr_image,
- jr_compressed_ptr dest) {
+status_t JpegR::extractGainMap(jr_compressed_ptr compressed_jpegr_image,
+ jr_compressed_ptr dest) {
if (compressed_jpegr_image == nullptr || dest == nullptr) {
return ERROR_JPEGR_INVALID_NULL_PTR;
}
- return extractPrimaryImageAndRecoveryMap(compressed_jpegr_image, nullptr, dest);
+ return extractPrimaryImageAndGainMap(compressed_jpegr_image, nullptr, dest);
}
// JPEG/R structure:
@@ -900,20 +900,20 @@ status_t JpegR::extractRecoveryMap(jr_compressed_ptr compressed_jpegr_image,
// name space ("http://ns.adobe.com/xap/1.0/\0")
// XMP
//
-// (Required) secondary image (the recovery map, without the first two bytes (SOI))
+// (Required) secondary image (the gain map, without the first two bytes (SOI))
//
// Metadata versions we are using:
// ECMA TR-98 for JFIF marker
// Exif 2.2 spec for EXIF marker
// Adobe XMP spec part 3 for XMP marker
// ICC v4.3 spec for ICC
-status_t JpegR::appendRecoveryMap(jr_compressed_ptr compressed_jpeg_image,
- jr_compressed_ptr compressed_recovery_map,
- jr_exif_ptr exif,
- jr_metadata_ptr metadata,
- jr_compressed_ptr dest) {
+status_t JpegR::appendGainMap(jr_compressed_ptr compressed_jpeg_image,
+ jr_compressed_ptr compressed_gain_map,
+ jr_exif_ptr exif,
+ jr_metadata_ptr metadata,
+ jr_compressed_ptr dest) {
if (compressed_jpeg_image == nullptr
- || compressed_recovery_map == nullptr
+ || compressed_gain_map == nullptr
|| metadata == nullptr
|| dest == nullptr) {
return ERROR_JPEGR_INVALID_NULL_PTR;
@@ -930,7 +930,7 @@ status_t JpegR::appendRecoveryMap(jr_compressed_ptr compressed_jpeg_image,
+ xmp_secondary.size(); /* length of xmp packet */
const int secondary_image_size = 2 /* 2 bytes length of APP1 sign */
+ xmp_secondary_length
- + compressed_recovery_map->length;
+ + compressed_gain_map->length;
// primary image
const string xmp_primary = generateXmpForPrimaryImage(secondary_image_size);
// same as primary
@@ -994,7 +994,7 @@ status_t JpegR::appendRecoveryMap(jr_compressed_ptr compressed_jpeg_image,
(uint8_t*)compressed_jpeg_image->data + 2, compressed_jpeg_image->length - 2, pos));
// Finish primary image
- // Begin secondary image (recovery map)
+ // Begin secondary image (gain map)
// Write SOI
JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kSOI, 1, pos));
@@ -1014,7 +1014,7 @@ status_t JpegR::appendRecoveryMap(jr_compressed_ptr compressed_jpeg_image,
// Write secondary image
JPEGR_CHECK(Write(dest,
- (uint8_t*)compressed_recovery_map->data + 2, compressed_recovery_map->length - 2, pos));
+ (uint8_t*)compressed_gain_map->data + 2, compressed_gain_map->length - 2, pos));
// Set back length
dest->length = pos;
diff --git a/libs/jpegrecoverymap/tests/Android.bp b/libs/jpegrecoverymap/tests/Android.bp
index d5da7fb646..59b1237a68 100644
--- a/libs/jpegrecoverymap/tests/Android.bp
+++ b/libs/jpegrecoverymap/tests/Android.bp
@@ -26,7 +26,7 @@ cc_test {
test_suites: ["device-tests"],
srcs: [
"jpegr_test.cpp",
- "recoverymapmath_test.cpp",
+ "gainmapmath_test.cpp",
],
shared_libs: [
"libimage_io",
diff --git a/libs/jpegrecoverymap/tests/recoverymapmath_test.cpp b/libs/jpegrecoverymap/tests/gainmapmath_test.cpp
index 2369a7e4e7..21de2e6c22 100644
--- a/libs/jpegrecoverymap/tests/recoverymapmath_test.cpp
+++ b/libs/jpegrecoverymap/tests/gainmapmath_test.cpp
@@ -17,14 +17,14 @@
#include <cmath>
#include <gtest/gtest.h>
#include <gmock/gmock.h>
-#include <jpegrecoverymap/recoverymapmath.h>
+#include <jpegrecoverymap/gainmapmath.h>
namespace android::jpegrecoverymap {
-class RecoveryMapMathTest : public testing::Test {
+class GainMapMathTest : public testing::Test {
public:
- RecoveryMapMathTest();
- ~RecoveryMapMathTest();
+ GainMapMathTest();
+ ~GainMapMathTest();
float ComparisonEpsilon() { return 1e-4f; }
float LuminanceEpsilon() { return 1e-2f; }
@@ -88,10 +88,10 @@ public:
return luminance_scaled * scale_factor;
}
- Color Recover(Color yuv_gamma, float recovery, jr_metadata_ptr metadata) {
+ Color Recover(Color yuv_gamma, float gain, jr_metadata_ptr metadata) {
Color rgb_gamma = srgbYuvToRgb(yuv_gamma);
Color rgb = srgbInvOetf(rgb_gamma);
- return applyRecovery(rgb, recovery, metadata);
+ return applyGain(rgb, gain, metadata);
}
jpegr_uncompressed_struct Yuv420Image() {
@@ -193,11 +193,11 @@ protected:
virtual void TearDown();
};
-RecoveryMapMathTest::RecoveryMapMathTest() {}
-RecoveryMapMathTest::~RecoveryMapMathTest() {}
+GainMapMathTest::GainMapMathTest() {}
+GainMapMathTest::~GainMapMathTest() {}
-void RecoveryMapMathTest::SetUp() {}
-void RecoveryMapMathTest::TearDown() {}
+void GainMapMathTest::SetUp() {}
+void GainMapMathTest::TearDown() {}
#define EXPECT_RGB_EQ(e1, e2) \
EXPECT_FLOAT_EQ((e1).r, (e2).r); \
@@ -231,7 +231,7 @@ void RecoveryMapMathTest::TearDown() {}
// TODO: a bunch of these tests can be parameterized.
-TEST_F(RecoveryMapMathTest, ColorConstruct) {
+TEST_F(GainMapMathTest, ColorConstruct) {
Color e1 = {{{ 0.1f, 0.2f, 0.3f }}};
EXPECT_FLOAT_EQ(e1.r, 0.1f);
@@ -243,7 +243,7 @@ TEST_F(RecoveryMapMathTest, ColorConstruct) {
EXPECT_FLOAT_EQ(e1.v, 0.3f);
}
-TEST_F(RecoveryMapMathTest, ColorAddColor) {
+TEST_F(GainMapMathTest, ColorAddColor) {
Color e1 = {{{ 0.1f, 0.2f, 0.3f }}};
Color e2 = e1 + e1;
@@ -257,7 +257,7 @@ TEST_F(RecoveryMapMathTest, ColorAddColor) {
EXPECT_FLOAT_EQ(e2.b, e1.b * 3.0f);
}
-TEST_F(RecoveryMapMathTest, ColorAddFloat) {
+TEST_F(GainMapMathTest, ColorAddFloat) {
Color e1 = {{{ 0.1f, 0.2f, 0.3f }}};
Color e2 = e1 + 0.1f;
@@ -271,7 +271,7 @@ TEST_F(RecoveryMapMathTest, ColorAddFloat) {
EXPECT_FLOAT_EQ(e2.b, e1.b + 0.2f);
}
-TEST_F(RecoveryMapMathTest, ColorSubtractColor) {
+TEST_F(GainMapMathTest, ColorSubtractColor) {
Color e1 = {{{ 0.1f, 0.2f, 0.3f }}};
Color e2 = e1 - e1;
@@ -285,7 +285,7 @@ TEST_F(RecoveryMapMathTest, ColorSubtractColor) {
EXPECT_FLOAT_EQ(e2.b, -e1.b);
}
-TEST_F(RecoveryMapMathTest, ColorSubtractFloat) {
+TEST_F(GainMapMathTest, ColorSubtractFloat) {
Color e1 = {{{ 0.1f, 0.2f, 0.3f }}};
Color e2 = e1 - 0.1f;
@@ -299,7 +299,7 @@ TEST_F(RecoveryMapMathTest, ColorSubtractFloat) {
EXPECT_FLOAT_EQ(e2.b, e1.b - 0.2f);
}
-TEST_F(RecoveryMapMathTest, ColorMultiplyFloat) {
+TEST_F(GainMapMathTest, ColorMultiplyFloat) {
Color e1 = {{{ 0.1f, 0.2f, 0.3f }}};
Color e2 = e1 * 2.0f;
@@ -313,7 +313,7 @@ TEST_F(RecoveryMapMathTest, ColorMultiplyFloat) {
EXPECT_FLOAT_EQ(e2.b, e1.b * 4.0f);
}
-TEST_F(RecoveryMapMathTest, ColorDivideFloat) {
+TEST_F(GainMapMathTest, ColorDivideFloat) {
Color e1 = {{{ 0.1f, 0.2f, 0.3f }}};
Color e2 = e1 / 2.0f;
@@ -327,7 +327,7 @@ TEST_F(RecoveryMapMathTest, ColorDivideFloat) {
EXPECT_FLOAT_EQ(e2.b, e1.b / 4.0f);
}
-TEST_F(RecoveryMapMathTest, SrgbLuminance) {
+TEST_F(GainMapMathTest, SrgbLuminance) {
EXPECT_FLOAT_EQ(srgbLuminance(RgbBlack()), 0.0f);
EXPECT_FLOAT_EQ(srgbLuminance(RgbWhite()), 1.0f);
EXPECT_FLOAT_EQ(srgbLuminance(RgbRed()), 0.2126f);
@@ -335,7 +335,7 @@ TEST_F(RecoveryMapMathTest, SrgbLuminance) {
EXPECT_FLOAT_EQ(srgbLuminance(RgbBlue()), 0.0722f);
}
-TEST_F(RecoveryMapMathTest, SrgbYuvToRgb) {
+TEST_F(GainMapMathTest, SrgbYuvToRgb) {
Color rgb_black = srgbYuvToRgb(YuvBlack());
EXPECT_RGB_NEAR(rgb_black, RgbBlack());
@@ -352,7 +352,7 @@ TEST_F(RecoveryMapMathTest, SrgbYuvToRgb) {
EXPECT_RGB_NEAR(rgb_b, RgbBlue());
}
-TEST_F(RecoveryMapMathTest, SrgbRgbToYuv) {
+TEST_F(GainMapMathTest, SrgbRgbToYuv) {
Color yuv_black = srgbRgbToYuv(RgbBlack());
EXPECT_YUV_NEAR(yuv_black, YuvBlack());
@@ -369,7 +369,7 @@ TEST_F(RecoveryMapMathTest, SrgbRgbToYuv) {
EXPECT_YUV_NEAR(yuv_b, SrgbYuvBlue());
}
-TEST_F(RecoveryMapMathTest, SrgbRgbYuvRoundtrip) {
+TEST_F(GainMapMathTest, SrgbRgbYuvRoundtrip) {
Color rgb_black = srgbYuvToRgb(srgbRgbToYuv(RgbBlack()));
EXPECT_RGB_NEAR(rgb_black, RgbBlack());
@@ -386,7 +386,7 @@ TEST_F(RecoveryMapMathTest, SrgbRgbYuvRoundtrip) {
EXPECT_RGB_NEAR(rgb_b, RgbBlue());
}
-TEST_F(RecoveryMapMathTest, SrgbTransferFunction) {
+TEST_F(GainMapMathTest, SrgbTransferFunction) {
EXPECT_FLOAT_EQ(srgbInvOetf(0.0f), 0.0f);
EXPECT_NEAR(srgbInvOetf(0.02f), 0.00154f, ComparisonEpsilon());
EXPECT_NEAR(srgbInvOetf(0.04045f), 0.00313f, ComparisonEpsilon());
@@ -394,7 +394,7 @@ TEST_F(RecoveryMapMathTest, SrgbTransferFunction) {
EXPECT_FLOAT_EQ(srgbInvOetf(1.0f), 1.0f);
}
-TEST_F(RecoveryMapMathTest, P3Luminance) {
+TEST_F(GainMapMathTest, P3Luminance) {
EXPECT_FLOAT_EQ(p3Luminance(RgbBlack()), 0.0f);
EXPECT_FLOAT_EQ(p3Luminance(RgbWhite()), 1.0f);
EXPECT_FLOAT_EQ(p3Luminance(RgbRed()), 0.20949f);
@@ -402,7 +402,7 @@ TEST_F(RecoveryMapMathTest, P3Luminance) {
EXPECT_FLOAT_EQ(p3Luminance(RgbBlue()), 0.06891f);
}
-TEST_F(RecoveryMapMathTest, Bt2100Luminance) {
+TEST_F(GainMapMathTest, Bt2100Luminance) {
EXPECT_FLOAT_EQ(bt2100Luminance(RgbBlack()), 0.0f);
EXPECT_FLOAT_EQ(bt2100Luminance(RgbWhite()), 1.0f);
EXPECT_FLOAT_EQ(bt2100Luminance(RgbRed()), 0.2627f);
@@ -410,7 +410,7 @@ TEST_F(RecoveryMapMathTest, Bt2100Luminance) {
EXPECT_FLOAT_EQ(bt2100Luminance(RgbBlue()), 0.0593f);
}
-TEST_F(RecoveryMapMathTest, Bt2100YuvToRgb) {
+TEST_F(GainMapMathTest, Bt2100YuvToRgb) {
Color rgb_black = bt2100YuvToRgb(YuvBlack());
EXPECT_RGB_NEAR(rgb_black, RgbBlack());
@@ -427,7 +427,7 @@ TEST_F(RecoveryMapMathTest, Bt2100YuvToRgb) {
EXPECT_RGB_NEAR(rgb_b, RgbBlue());
}
-TEST_F(RecoveryMapMathTest, Bt2100RgbToYuv) {
+TEST_F(GainMapMathTest, Bt2100RgbToYuv) {
Color yuv_black = bt2100RgbToYuv(RgbBlack());
EXPECT_YUV_NEAR(yuv_black, YuvBlack());
@@ -444,7 +444,7 @@ TEST_F(RecoveryMapMathTest, Bt2100RgbToYuv) {
EXPECT_YUV_NEAR(yuv_b, Bt2100YuvBlue());
}
-TEST_F(RecoveryMapMathTest, Bt2100RgbYuvRoundtrip) {
+TEST_F(GainMapMathTest, Bt2100RgbYuvRoundtrip) {
Color rgb_black = bt2100YuvToRgb(bt2100RgbToYuv(RgbBlack()));
EXPECT_RGB_NEAR(rgb_black, RgbBlack());
@@ -461,7 +461,7 @@ TEST_F(RecoveryMapMathTest, Bt2100RgbYuvRoundtrip) {
EXPECT_RGB_NEAR(rgb_b, RgbBlue());
}
-TEST_F(RecoveryMapMathTest, HlgOetf) {
+TEST_F(GainMapMathTest, HlgOetf) {
EXPECT_FLOAT_EQ(hlgOetf(0.0f), 0.0f);
EXPECT_NEAR(hlgOetf(0.04167f), 0.35357f, ComparisonEpsilon());
EXPECT_NEAR(hlgOetf(0.08333f), 0.5f, ComparisonEpsilon());
@@ -473,7 +473,7 @@ TEST_F(RecoveryMapMathTest, HlgOetf) {
EXPECT_RGB_NEAR(hlgOetf(e), e_gamma);
}
-TEST_F(RecoveryMapMathTest, HlgInvOetf) {
+TEST_F(GainMapMathTest, HlgInvOetf) {
EXPECT_FLOAT_EQ(hlgInvOetf(0.0f), 0.0f);
EXPECT_NEAR(hlgInvOetf(0.25f), 0.02083f, ComparisonEpsilon());
EXPECT_NEAR(hlgInvOetf(0.5f), 0.08333f, ComparisonEpsilon());
@@ -485,7 +485,7 @@ TEST_F(RecoveryMapMathTest, HlgInvOetf) {
EXPECT_RGB_NEAR(hlgInvOetf(e_gamma), e);
}
-TEST_F(RecoveryMapMathTest, HlgTransferFunctionRoundtrip) {
+TEST_F(GainMapMathTest, HlgTransferFunctionRoundtrip) {
EXPECT_FLOAT_EQ(hlgInvOetf(hlgOetf(0.0f)), 0.0f);
EXPECT_NEAR(hlgInvOetf(hlgOetf(0.04167f)), 0.04167f, ComparisonEpsilon());
EXPECT_NEAR(hlgInvOetf(hlgOetf(0.08333f)), 0.08333f, ComparisonEpsilon());
@@ -493,7 +493,7 @@ TEST_F(RecoveryMapMathTest, HlgTransferFunctionRoundtrip) {
EXPECT_FLOAT_EQ(hlgInvOetf(hlgOetf(1.0f)), 1.0f);
}
-TEST_F(RecoveryMapMathTest, PqOetf) {
+TEST_F(GainMapMathTest, PqOetf) {
EXPECT_FLOAT_EQ(pqOetf(0.0f), 0.0f);
EXPECT_NEAR(pqOetf(0.01f), 0.50808f, ComparisonEpsilon());
EXPECT_NEAR(pqOetf(0.5f), 0.92655f, ComparisonEpsilon());
@@ -505,7 +505,7 @@ TEST_F(RecoveryMapMathTest, PqOetf) {
EXPECT_RGB_NEAR(pqOetf(e), e_gamma);
}
-TEST_F(RecoveryMapMathTest, PqInvOetf) {
+TEST_F(GainMapMathTest, PqInvOetf) {
EXPECT_FLOAT_EQ(pqInvOetf(0.0f), 0.0f);
EXPECT_NEAR(pqInvOetf(0.01f), 2.31017e-7f, ComparisonEpsilon());
EXPECT_NEAR(pqInvOetf(0.5f), 0.00922f, ComparisonEpsilon());
@@ -517,99 +517,99 @@ TEST_F(RecoveryMapMathTest, PqInvOetf) {
EXPECT_RGB_NEAR(pqInvOetf(e_gamma), e);
}
-TEST_F(RecoveryMapMathTest, PqInvOetfLUT) {
+TEST_F(GainMapMathTest, PqInvOetfLUT) {
for (int idx = 0; idx < kPqInvOETFNumEntries; idx++) {
float value = static_cast<float>(idx) / static_cast<float>(kPqInvOETFNumEntries - 1);
EXPECT_FLOAT_EQ(pqInvOetf(value), pqInvOetfLUT(value));
}
}
-TEST_F(RecoveryMapMathTest, HlgInvOetfLUT) {
+TEST_F(GainMapMathTest, HlgInvOetfLUT) {
for (int idx = 0; idx < kHlgInvOETFNumEntries; idx++) {
float value = static_cast<float>(idx) / static_cast<float>(kHlgInvOETFNumEntries - 1);
EXPECT_FLOAT_EQ(hlgInvOetf(value), hlgInvOetfLUT(value));
}
}
-TEST_F(RecoveryMapMathTest, pqOetfLUT) {
+TEST_F(GainMapMathTest, pqOetfLUT) {
for (int idx = 0; idx < kPqOETFNumEntries; idx++) {
float value = static_cast<float>(idx) / static_cast<float>(kPqOETFNumEntries - 1);
EXPECT_FLOAT_EQ(pqOetf(value), pqOetfLUT(value));
}
}
-TEST_F(RecoveryMapMathTest, hlgOetfLUT) {
+TEST_F(GainMapMathTest, hlgOetfLUT) {
for (int idx = 0; idx < kHlgOETFNumEntries; idx++) {
float value = static_cast<float>(idx) / static_cast<float>(kHlgOETFNumEntries - 1);
EXPECT_FLOAT_EQ(hlgOetf(value), hlgOetfLUT(value));
}
}
-TEST_F(RecoveryMapMathTest, srgbInvOetfLUT) {
+TEST_F(GainMapMathTest, srgbInvOetfLUT) {
for (int idx = 0; idx < kSrgbInvOETFNumEntries; idx++) {
float value = static_cast<float>(idx) / static_cast<float>(kSrgbInvOETFNumEntries - 1);
EXPECT_FLOAT_EQ(srgbInvOetf(value), srgbInvOetfLUT(value));
}
}
-TEST_F(RecoveryMapMathTest, applyRecoveryLUT) {
+TEST_F(GainMapMathTest, applyGainLUT) {
for (int boost = 1; boost <= 10; boost++) {
jpegr_metadata_struct metadata = { .maxContentBoost = static_cast<float>(boost),
.minContentBoost = 1.0f / static_cast<float>(boost) };
- RecoveryLUT recoveryLUT(&metadata);
- RecoveryLUT recoveryLUTWithBoost(&metadata, metadata.maxContentBoost);
- for (int idx = 0; idx < kRecoveryFactorNumEntries; idx++) {
- float value = static_cast<float>(idx) / static_cast<float>(kRecoveryFactorNumEntries - 1);
- EXPECT_RGB_NEAR(applyRecovery(RgbBlack(), value, &metadata),
- applyRecoveryLUT(RgbBlack(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), value, &metadata),
- applyRecoveryLUT(RgbWhite(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbRed(), value, &metadata),
- applyRecoveryLUT(RgbRed(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbGreen(), value, &metadata),
- applyRecoveryLUT(RgbGreen(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbBlue(), value, &metadata),
- applyRecoveryLUT(RgbBlue(), value, recoveryLUT));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbBlack(), value, recoveryLUT),
- applyRecoveryLUT(RgbBlack(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbWhite(), value, recoveryLUT),
- applyRecoveryLUT(RgbWhite(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbRed(), value, recoveryLUT),
- applyRecoveryLUT(RgbRed(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbGreen(), value, recoveryLUT),
- applyRecoveryLUT(RgbGreen(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbBlue(), value, recoveryLUT),
- applyRecoveryLUT(RgbBlue(), value, recoveryLUTWithBoost));
+ GainLUT gainLUT(&metadata);
+ GainLUT gainLUTWithBoost(&metadata, metadata.maxContentBoost);
+ for (int idx = 0; idx < kGainFactorNumEntries; idx++) {
+ float value = static_cast<float>(idx) / static_cast<float>(kGainFactorNumEntries - 1);
+ EXPECT_RGB_NEAR(applyGain(RgbBlack(), value, &metadata),
+ applyGainLUT(RgbBlack(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), value, &metadata),
+ applyGainLUT(RgbWhite(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbRed(), value, &metadata),
+ applyGainLUT(RgbRed(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbGreen(), value, &metadata),
+ applyGainLUT(RgbGreen(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbBlue(), value, &metadata),
+ applyGainLUT(RgbBlue(), value, gainLUT));
+ EXPECT_RGB_EQ(applyGainLUT(RgbBlack(), value, gainLUT),
+ applyGainLUT(RgbBlack(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbWhite(), value, gainLUT),
+ applyGainLUT(RgbWhite(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbRed(), value, gainLUT),
+ applyGainLUT(RgbRed(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbGreen(), value, gainLUT),
+ applyGainLUT(RgbGreen(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbBlue(), value, gainLUT),
+ applyGainLUT(RgbBlue(), value, gainLUTWithBoost));
}
}
for (int boost = 1; boost <= 10; boost++) {
jpegr_metadata_struct metadata = { .maxContentBoost = static_cast<float>(boost),
.minContentBoost = 1.0f };
- RecoveryLUT recoveryLUT(&metadata);
- RecoveryLUT recoveryLUTWithBoost(&metadata, metadata.maxContentBoost);
- for (int idx = 0; idx < kRecoveryFactorNumEntries; idx++) {
- float value = static_cast<float>(idx) / static_cast<float>(kRecoveryFactorNumEntries - 1);
- EXPECT_RGB_NEAR(applyRecovery(RgbBlack(), value, &metadata),
- applyRecoveryLUT(RgbBlack(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), value, &metadata),
- applyRecoveryLUT(RgbWhite(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbRed(), value, &metadata),
- applyRecoveryLUT(RgbRed(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbGreen(), value, &metadata),
- applyRecoveryLUT(RgbGreen(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbBlue(), value, &metadata),
- applyRecoveryLUT(RgbBlue(), value, recoveryLUT));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbBlack(), value, recoveryLUT),
- applyRecoveryLUT(RgbBlack(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbWhite(), value, recoveryLUT),
- applyRecoveryLUT(RgbWhite(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbRed(), value, recoveryLUT),
- applyRecoveryLUT(RgbRed(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbGreen(), value, recoveryLUT),
- applyRecoveryLUT(RgbGreen(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbBlue(), value, recoveryLUT),
- applyRecoveryLUT(RgbBlue(), value, recoveryLUTWithBoost));
+ GainLUT gainLUT(&metadata);
+ GainLUT gainLUTWithBoost(&metadata, metadata.maxContentBoost);
+ for (int idx = 0; idx < kGainFactorNumEntries; idx++) {
+ float value = static_cast<float>(idx) / static_cast<float>(kGainFactorNumEntries - 1);
+ EXPECT_RGB_NEAR(applyGain(RgbBlack(), value, &metadata),
+ applyGainLUT(RgbBlack(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), value, &metadata),
+ applyGainLUT(RgbWhite(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbRed(), value, &metadata),
+ applyGainLUT(RgbRed(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbGreen(), value, &metadata),
+ applyGainLUT(RgbGreen(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbBlue(), value, &metadata),
+ applyGainLUT(RgbBlue(), value, gainLUT));
+ EXPECT_RGB_EQ(applyGainLUT(RgbBlack(), value, gainLUT),
+ applyGainLUT(RgbBlack(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbWhite(), value, gainLUT),
+ applyGainLUT(RgbWhite(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbRed(), value, gainLUT),
+ applyGainLUT(RgbRed(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbGreen(), value, gainLUT),
+ applyGainLUT(RgbGreen(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbBlue(), value, gainLUT),
+ applyGainLUT(RgbBlue(), value, gainLUTWithBoost));
}
}
@@ -617,35 +617,35 @@ TEST_F(RecoveryMapMathTest, applyRecoveryLUT) {
jpegr_metadata_struct metadata = { .maxContentBoost = static_cast<float>(boost),
.minContentBoost = 1.0f / pow(static_cast<float>(boost),
1.0f / 3.0f) };
- RecoveryLUT recoveryLUT(&metadata);
- RecoveryLUT recoveryLUTWithBoost(&metadata, metadata.maxContentBoost);
- for (int idx = 0; idx < kRecoveryFactorNumEntries; idx++) {
- float value = static_cast<float>(idx) / static_cast<float>(kRecoveryFactorNumEntries - 1);
- EXPECT_RGB_NEAR(applyRecovery(RgbBlack(), value, &metadata),
- applyRecoveryLUT(RgbBlack(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), value, &metadata),
- applyRecoveryLUT(RgbWhite(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbRed(), value, &metadata),
- applyRecoveryLUT(RgbRed(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbGreen(), value, &metadata),
- applyRecoveryLUT(RgbGreen(), value, recoveryLUT));
- EXPECT_RGB_NEAR(applyRecovery(RgbBlue(), value, &metadata),
- applyRecoveryLUT(RgbBlue(), value, recoveryLUT));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbBlack(), value, recoveryLUT),
- applyRecoveryLUT(RgbBlack(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbWhite(), value, recoveryLUT),
- applyRecoveryLUT(RgbWhite(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbRed(), value, recoveryLUT),
- applyRecoveryLUT(RgbRed(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbGreen(), value, recoveryLUT),
- applyRecoveryLUT(RgbGreen(), value, recoveryLUTWithBoost));
- EXPECT_RGB_EQ(applyRecoveryLUT(RgbBlue(), value, recoveryLUT),
- applyRecoveryLUT(RgbBlue(), value, recoveryLUTWithBoost));
+ GainLUT gainLUT(&metadata);
+ GainLUT gainLUTWithBoost(&metadata, metadata.maxContentBoost);
+ for (int idx = 0; idx < kGainFactorNumEntries; idx++) {
+ float value = static_cast<float>(idx) / static_cast<float>(kGainFactorNumEntries - 1);
+ EXPECT_RGB_NEAR(applyGain(RgbBlack(), value, &metadata),
+ applyGainLUT(RgbBlack(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), value, &metadata),
+ applyGainLUT(RgbWhite(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbRed(), value, &metadata),
+ applyGainLUT(RgbRed(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbGreen(), value, &metadata),
+ applyGainLUT(RgbGreen(), value, gainLUT));
+ EXPECT_RGB_NEAR(applyGain(RgbBlue(), value, &metadata),
+ applyGainLUT(RgbBlue(), value, gainLUT));
+ EXPECT_RGB_EQ(applyGainLUT(RgbBlack(), value, gainLUT),
+ applyGainLUT(RgbBlack(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbWhite(), value, gainLUT),
+ applyGainLUT(RgbWhite(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbRed(), value, gainLUT),
+ applyGainLUT(RgbRed(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbGreen(), value, gainLUT),
+ applyGainLUT(RgbGreen(), value, gainLUTWithBoost));
+ EXPECT_RGB_EQ(applyGainLUT(RgbBlue(), value, gainLUT),
+ applyGainLUT(RgbBlue(), value, gainLUTWithBoost));
}
}
}
-TEST_F(RecoveryMapMathTest, PqTransferFunctionRoundtrip) {
+TEST_F(GainMapMathTest, PqTransferFunctionRoundtrip) {
EXPECT_FLOAT_EQ(pqInvOetf(pqOetf(0.0f)), 0.0f);
EXPECT_NEAR(pqInvOetf(pqOetf(0.01f)), 0.01f, ComparisonEpsilon());
EXPECT_NEAR(pqInvOetf(pqOetf(0.5f)), 0.5f, ComparisonEpsilon());
@@ -653,7 +653,7 @@ TEST_F(RecoveryMapMathTest, PqTransferFunctionRoundtrip) {
EXPECT_FLOAT_EQ(pqInvOetf(pqOetf(1.0f)), 1.0f);
}
-TEST_F(RecoveryMapMathTest, ColorConversionLookup) {
+TEST_F(GainMapMathTest, ColorConversionLookup) {
EXPECT_EQ(getHdrConversionFn(JPEGR_COLORGAMUT_BT709, JPEGR_COLORGAMUT_UNSPECIFIED),
nullptr);
EXPECT_EQ(getHdrConversionFn(JPEGR_COLORGAMUT_BT709, JPEGR_COLORGAMUT_BT709),
@@ -691,139 +691,139 @@ TEST_F(RecoveryMapMathTest, ColorConversionLookup) {
nullptr);
}
-TEST_F(RecoveryMapMathTest, EncodeRecovery) {
+TEST_F(GainMapMathTest, EncodeGain) {
jpegr_metadata_struct metadata = { .maxContentBoost = 4.0f,
.minContentBoost = 1.0f / 4.0f };
- EXPECT_EQ(encodeRecovery(0.0f, 0.0f, &metadata), 127);
- EXPECT_EQ(encodeRecovery(0.0f, 1.0f, &metadata), 127);
- EXPECT_EQ(encodeRecovery(1.0f, 0.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(0.5f, 0.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(0.0f, 0.0f, &metadata), 127);
+ EXPECT_EQ(encodeGain(0.0f, 1.0f, &metadata), 127);
+ EXPECT_EQ(encodeGain(1.0f, 0.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(0.5f, 0.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 1.0f, &metadata), 127);
- EXPECT_EQ(encodeRecovery(1.0f, 4.0f, &metadata), 255);
- EXPECT_EQ(encodeRecovery(1.0f, 5.0f, &metadata), 255);
- EXPECT_EQ(encodeRecovery(4.0f, 1.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(4.0f, 0.5f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 2.0f, &metadata), 191);
- EXPECT_EQ(encodeRecovery(2.0f, 1.0f, &metadata), 63);
+ EXPECT_EQ(encodeGain(1.0f, 1.0f, &metadata), 127);
+ EXPECT_EQ(encodeGain(1.0f, 4.0f, &metadata), 255);
+ EXPECT_EQ(encodeGain(1.0f, 5.0f, &metadata), 255);
+ EXPECT_EQ(encodeGain(4.0f, 1.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(4.0f, 0.5f, &metadata), 0);
+ EXPECT_EQ(encodeGain(1.0f, 2.0f, &metadata), 191);
+ EXPECT_EQ(encodeGain(2.0f, 1.0f, &metadata), 63);
metadata.maxContentBoost = 2.0f;
metadata.minContentBoost = 1.0f / 2.0f;
- EXPECT_EQ(encodeRecovery(1.0f, 2.0f, &metadata), 255);
- EXPECT_EQ(encodeRecovery(2.0f, 1.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 1.41421f, &metadata), 191);
- EXPECT_EQ(encodeRecovery(1.41421f, 1.0f, &metadata), 63);
+ EXPECT_EQ(encodeGain(1.0f, 2.0f, &metadata), 255);
+ EXPECT_EQ(encodeGain(2.0f, 1.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(1.0f, 1.41421f, &metadata), 191);
+ EXPECT_EQ(encodeGain(1.41421f, 1.0f, &metadata), 63);
metadata.maxContentBoost = 8.0f;
metadata.minContentBoost = 1.0f / 8.0f;
- EXPECT_EQ(encodeRecovery(1.0f, 8.0f, &metadata), 255);
- EXPECT_EQ(encodeRecovery(8.0f, 1.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 2.82843f, &metadata), 191);
- EXPECT_EQ(encodeRecovery(2.82843f, 1.0f, &metadata), 63);
+ EXPECT_EQ(encodeGain(1.0f, 8.0f, &metadata), 255);
+ EXPECT_EQ(encodeGain(8.0f, 1.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(1.0f, 2.82843f, &metadata), 191);
+ EXPECT_EQ(encodeGain(2.82843f, 1.0f, &metadata), 63);
metadata.maxContentBoost = 8.0f;
metadata.minContentBoost = 1.0f;
- EXPECT_EQ(encodeRecovery(0.0f, 0.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 0.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(0.0f, 0.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(1.0f, 0.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 1.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 8.0f, &metadata), 255);
- EXPECT_EQ(encodeRecovery(1.0f, 4.0f, &metadata), 170);
- EXPECT_EQ(encodeRecovery(1.0f, 2.0f, &metadata), 85);
+ EXPECT_EQ(encodeGain(1.0f, 1.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(1.0f, 8.0f, &metadata), 255);
+ EXPECT_EQ(encodeGain(1.0f, 4.0f, &metadata), 170);
+ EXPECT_EQ(encodeGain(1.0f, 2.0f, &metadata), 85);
metadata.maxContentBoost = 8.0f;
metadata.minContentBoost = 0.5f;
- EXPECT_EQ(encodeRecovery(0.0f, 0.0f, &metadata), 63);
- EXPECT_EQ(encodeRecovery(1.0f, 0.0f, &metadata), 0);
+ EXPECT_EQ(encodeGain(0.0f, 0.0f, &metadata), 63);
+ EXPECT_EQ(encodeGain(1.0f, 0.0f, &metadata), 0);
- EXPECT_EQ(encodeRecovery(1.0f, 1.0f, &metadata), 63);
- EXPECT_EQ(encodeRecovery(1.0f, 8.0f, &metadata), 255);
- EXPECT_EQ(encodeRecovery(1.0f, 4.0f, &metadata), 191);
- EXPECT_EQ(encodeRecovery(1.0f, 2.0f, &metadata), 127);
- EXPECT_EQ(encodeRecovery(1.0f, 0.7071f, &metadata), 31);
- EXPECT_EQ(encodeRecovery(1.0f, 0.5f, &metadata), 0);
+ EXPECT_EQ(encodeGain(1.0f, 1.0f, &metadata), 63);
+ EXPECT_EQ(encodeGain(1.0f, 8.0f, &metadata), 255);
+ EXPECT_EQ(encodeGain(1.0f, 4.0f, &metadata), 191);
+ EXPECT_EQ(encodeGain(1.0f, 2.0f, &metadata), 127);
+ EXPECT_EQ(encodeGain(1.0f, 0.7071f, &metadata), 31);
+ EXPECT_EQ(encodeGain(1.0f, 0.5f, &metadata), 0);
}
-TEST_F(RecoveryMapMathTest, ApplyRecovery) {
+TEST_F(GainMapMathTest, ApplyGain) {
jpegr_metadata_struct metadata = { .maxContentBoost = 4.0f,
.minContentBoost = 1.0f / 4.0f };
float displayBoost = metadata.maxContentBoost;
- EXPECT_RGB_NEAR(applyRecovery(RgbBlack(), 0.0f, &metadata), RgbBlack());
- EXPECT_RGB_NEAR(applyRecovery(RgbBlack(), 0.5f, &metadata), RgbBlack());
- EXPECT_RGB_NEAR(applyRecovery(RgbBlack(), 1.0f, &metadata), RgbBlack());
+ EXPECT_RGB_NEAR(applyGain(RgbBlack(), 0.0f, &metadata), RgbBlack());
+ EXPECT_RGB_NEAR(applyGain(RgbBlack(), 0.5f, &metadata), RgbBlack());
+ EXPECT_RGB_NEAR(applyGain(RgbBlack(), 1.0f, &metadata), RgbBlack());
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.0f, &metadata), RgbWhite() / 4.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.25f, &metadata), RgbWhite() / 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.5f, &metadata), RgbWhite());
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.75f, &metadata), RgbWhite() * 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 1.0f, &metadata), RgbWhite() * 4.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite() / 4.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.25f, &metadata), RgbWhite() / 2.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.5f, &metadata), RgbWhite());
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.75f, &metadata), RgbWhite() * 2.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 1.0f, &metadata), RgbWhite() * 4.0f);
metadata.maxContentBoost = 2.0f;
metadata.minContentBoost = 1.0f / 2.0f;
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.0f, &metadata), RgbWhite() / 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.25f, &metadata), RgbWhite() / 1.41421f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.5f, &metadata), RgbWhite());
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.75f, &metadata), RgbWhite() * 1.41421f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 1.0f, &metadata), RgbWhite() * 2.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite() / 2.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.25f, &metadata), RgbWhite() / 1.41421f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.5f, &metadata), RgbWhite());
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.75f, &metadata), RgbWhite() * 1.41421f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 1.0f, &metadata), RgbWhite() * 2.0f);
metadata.maxContentBoost = 8.0f;
metadata.minContentBoost = 1.0f / 8.0f;
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.0f, &metadata), RgbWhite() / 8.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.25f, &metadata), RgbWhite() / 2.82843f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.5f, &metadata), RgbWhite());
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.75f, &metadata), RgbWhite() * 2.82843f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 1.0f, &metadata), RgbWhite() * 8.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite() / 8.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.25f, &metadata), RgbWhite() / 2.82843f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.5f, &metadata), RgbWhite());
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.75f, &metadata), RgbWhite() * 2.82843f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 1.0f, &metadata), RgbWhite() * 8.0f);
metadata.maxContentBoost = 8.0f;
metadata.minContentBoost = 1.0f;
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.0f, &metadata), RgbWhite());
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 1.0f / 3.0f, &metadata), RgbWhite() * 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 2.0f / 3.0f, &metadata), RgbWhite() * 4.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 1.0f, &metadata), RgbWhite() * 8.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite());
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 1.0f / 3.0f, &metadata), RgbWhite() * 2.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 2.0f / 3.0f, &metadata), RgbWhite() * 4.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 1.0f, &metadata), RgbWhite() * 8.0f);
metadata.maxContentBoost = 8.0f;
metadata.minContentBoost = 0.5f;
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.0f, &metadata), RgbWhite() / 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.25f, &metadata), RgbWhite());
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.5f, &metadata), RgbWhite() * 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 0.75f, &metadata), RgbWhite() * 4.0f);
- EXPECT_RGB_NEAR(applyRecovery(RgbWhite(), 1.0f, &metadata), RgbWhite() * 8.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite() / 2.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.25f, &metadata), RgbWhite());
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.5f, &metadata), RgbWhite() * 2.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.75f, &metadata), RgbWhite() * 4.0f);
+ EXPECT_RGB_NEAR(applyGain(RgbWhite(), 1.0f, &metadata), RgbWhite() * 8.0f);
Color e = {{{ 0.0f, 0.5f, 1.0f }}};
metadata.maxContentBoost = 4.0f;
metadata.minContentBoost = 1.0f / 4.0f;
- EXPECT_RGB_NEAR(applyRecovery(e, 0.0f, &metadata), e / 4.0f);
- EXPECT_RGB_NEAR(applyRecovery(e, 0.25f, &metadata), e / 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(e, 0.5f, &metadata), e);
- EXPECT_RGB_NEAR(applyRecovery(e, 0.75f, &metadata), e * 2.0f);
- EXPECT_RGB_NEAR(applyRecovery(e, 1.0f, &metadata), e * 4.0f);
-
- EXPECT_RGB_EQ(applyRecovery(RgbBlack(), 1.0f, &metadata),
- applyRecovery(RgbBlack(), 1.0f, &metadata, displayBoost));
- EXPECT_RGB_EQ(applyRecovery(RgbWhite(), 1.0f, &metadata),
- applyRecovery(RgbWhite(), 1.0f, &metadata, displayBoost));
- EXPECT_RGB_EQ(applyRecovery(RgbRed(), 1.0f, &metadata),
- applyRecovery(RgbRed(), 1.0f, &metadata, displayBoost));
- EXPECT_RGB_EQ(applyRecovery(RgbGreen(), 1.0f, &metadata),
- applyRecovery(RgbGreen(), 1.0f, &metadata, displayBoost));
- EXPECT_RGB_EQ(applyRecovery(RgbBlue(), 1.0f, &metadata),
- applyRecovery(RgbBlue(), 1.0f, &metadata, displayBoost));
- EXPECT_RGB_EQ(applyRecovery(e, 1.0f, &metadata),
- applyRecovery(e, 1.0f, &metadata, displayBoost));
+ EXPECT_RGB_NEAR(applyGain(e, 0.0f, &metadata), e / 4.0f);
+ EXPECT_RGB_NEAR(applyGain(e, 0.25f, &metadata), e / 2.0f);
+ EXPECT_RGB_NEAR(applyGain(e, 0.5f, &metadata), e);
+ EXPECT_RGB_NEAR(applyGain(e, 0.75f, &metadata), e * 2.0f);
+ EXPECT_RGB_NEAR(applyGain(e, 1.0f, &metadata), e * 4.0f);
+
+ EXPECT_RGB_EQ(applyGain(RgbBlack(), 1.0f, &metadata),
+ applyGain(RgbBlack(), 1.0f, &metadata, displayBoost));
+ EXPECT_RGB_EQ(applyGain(RgbWhite(), 1.0f, &metadata),
+ applyGain(RgbWhite(), 1.0f, &metadata, displayBoost));
+ EXPECT_RGB_EQ(applyGain(RgbRed(), 1.0f, &metadata),
+ applyGain(RgbRed(), 1.0f, &metadata, displayBoost));
+ EXPECT_RGB_EQ(applyGain(RgbGreen(), 1.0f, &metadata),
+ applyGain(RgbGreen(), 1.0f, &metadata, displayBoost));
+ EXPECT_RGB_EQ(applyGain(RgbBlue(), 1.0f, &metadata),
+ applyGain(RgbBlue(), 1.0f, &metadata, displayBoost));
+ EXPECT_RGB_EQ(applyGain(e, 1.0f, &metadata),
+ applyGain(e, 1.0f, &metadata, displayBoost));
}
-TEST_F(RecoveryMapMathTest, GetYuv420Pixel) {
+TEST_F(GainMapMathTest, GetYuv420Pixel) {
jpegr_uncompressed_struct image = Yuv420Image();
Color (*colors)[4] = Yuv420Colors();
@@ -834,7 +834,7 @@ TEST_F(RecoveryMapMathTest, GetYuv420Pixel) {
}
}
-TEST_F(RecoveryMapMathTest, GetP010Pixel) {
+TEST_F(GainMapMathTest, GetP010Pixel) {
jpegr_uncompressed_struct image = P010Image();
Color (*colors)[4] = P010Colors();
@@ -845,7 +845,7 @@ TEST_F(RecoveryMapMathTest, GetP010Pixel) {
}
}
-TEST_F(RecoveryMapMathTest, SampleYuv420) {
+TEST_F(GainMapMathTest, SampleYuv420) {
jpegr_uncompressed_struct image = Yuv420Image();
Color (*colors)[4] = Yuv420Colors();
@@ -871,7 +871,7 @@ TEST_F(RecoveryMapMathTest, SampleYuv420) {
}
}
-TEST_F(RecoveryMapMathTest, SampleP010) {
+TEST_F(GainMapMathTest, SampleP010) {
jpegr_uncompressed_struct image = P010Image();
Color (*colors)[4] = P010Colors();
@@ -897,7 +897,7 @@ TEST_F(RecoveryMapMathTest, SampleP010) {
}
}
-TEST_F(RecoveryMapMathTest, SampleMap) {
+TEST_F(GainMapMathTest, SampleMap) {
jpegr_uncompressed_struct image = MapImage();
float (*values)[4] = MapValues();
@@ -937,7 +937,7 @@ TEST_F(RecoveryMapMathTest, SampleMap) {
}
}
-TEST_F(RecoveryMapMathTest, ColorToRgba1010102) {
+TEST_F(GainMapMathTest, ColorToRgba1010102) {
EXPECT_EQ(colorToRgba1010102(RgbBlack()), 0x3 << 30);
EXPECT_EQ(colorToRgba1010102(RgbWhite()), 0xFFFFFFFF);
EXPECT_EQ(colorToRgba1010102(RgbRed()), 0x3 << 30 | 0x3ff);
@@ -952,7 +952,7 @@ TEST_F(RecoveryMapMathTest, ColorToRgba1010102) {
| static_cast<uint32_t>(0.3f * static_cast<float>(0x3ff)) << 20);
}
-TEST_F(RecoveryMapMathTest, ColorToRgbaF16) {
+TEST_F(GainMapMathTest, ColorToRgbaF16) {
EXPECT_EQ(colorToRgbaF16(RgbBlack()), ((uint64_t) 0x3C00) << 48);
EXPECT_EQ(colorToRgbaF16(RgbWhite()), 0x3C003C003C003C00);
EXPECT_EQ(colorToRgbaF16(RgbRed()), (((uint64_t) 0x3C00) << 48) | ((uint64_t) 0x3C00));
@@ -963,7 +963,7 @@ TEST_F(RecoveryMapMathTest, ColorToRgbaF16) {
EXPECT_EQ(colorToRgbaF16(e_gamma), 0x3C0034CD32662E66);
}
-TEST_F(RecoveryMapMathTest, Float32ToFloat16) {
+TEST_F(GainMapMathTest, Float32ToFloat16) {
EXPECT_EQ(floatToHalf(0.1f), 0x2E66);
EXPECT_EQ(floatToHalf(0.0f), 0x0);
EXPECT_EQ(floatToHalf(1.0f), 0x3C00);
@@ -973,7 +973,7 @@ TEST_F(RecoveryMapMathTest, Float32ToFloat16) {
EXPECT_EQ(floatToHalf(0x1.0p-126f), 0x0); // float zero
}
-TEST_F(RecoveryMapMathTest, GenerateMapLuminanceSrgb) {
+TEST_F(GainMapMathTest, GenerateMapLuminanceSrgb) {
EXPECT_FLOAT_EQ(SrgbYuvToLuminance(YuvBlack(), srgbLuminance),
0.0f);
EXPECT_FLOAT_EQ(SrgbYuvToLuminance(YuvWhite(), srgbLuminance),
@@ -986,7 +986,7 @@ TEST_F(RecoveryMapMathTest, GenerateMapLuminanceSrgb) {
srgbLuminance(RgbBlue()) * kSdrWhiteNits, LuminanceEpsilon());
}
-TEST_F(RecoveryMapMathTest, GenerateMapLuminanceSrgbP3) {
+TEST_F(GainMapMathTest, GenerateMapLuminanceSrgbP3) {
EXPECT_FLOAT_EQ(SrgbYuvToLuminance(YuvBlack(), p3Luminance),
0.0f);
EXPECT_FLOAT_EQ(SrgbYuvToLuminance(YuvWhite(), p3Luminance),
@@ -999,7 +999,7 @@ TEST_F(RecoveryMapMathTest, GenerateMapLuminanceSrgbP3) {
p3Luminance(RgbBlue()) * kSdrWhiteNits, LuminanceEpsilon());
}
-TEST_F(RecoveryMapMathTest, GenerateMapLuminanceSrgbBt2100) {
+TEST_F(GainMapMathTest, GenerateMapLuminanceSrgbBt2100) {
EXPECT_FLOAT_EQ(SrgbYuvToLuminance(YuvBlack(), bt2100Luminance),
0.0f);
EXPECT_FLOAT_EQ(SrgbYuvToLuminance(YuvWhite(), bt2100Luminance),
@@ -1012,7 +1012,7 @@ TEST_F(RecoveryMapMathTest, GenerateMapLuminanceSrgbBt2100) {
bt2100Luminance(RgbBlue()) * kSdrWhiteNits, LuminanceEpsilon());
}
-TEST_F(RecoveryMapMathTest, GenerateMapLuminanceHlg) {
+TEST_F(GainMapMathTest, GenerateMapLuminanceHlg) {
EXPECT_FLOAT_EQ(Bt2100YuvToLuminance(YuvBlack(), hlgInvOetf, identityConversion,
bt2100Luminance, kHlgMaxNits),
0.0f);
@@ -1030,7 +1030,7 @@ TEST_F(RecoveryMapMathTest, GenerateMapLuminanceHlg) {
bt2100Luminance(RgbBlue()) * kHlgMaxNits, LuminanceEpsilon());
}
-TEST_F(RecoveryMapMathTest, GenerateMapLuminancePq) {
+TEST_F(GainMapMathTest, GenerateMapLuminancePq) {
EXPECT_FLOAT_EQ(Bt2100YuvToLuminance(YuvBlack(), pqInvOetf, identityConversion,
bt2100Luminance, kPqMaxNits),
0.0f);
@@ -1048,7 +1048,7 @@ TEST_F(RecoveryMapMathTest, GenerateMapLuminancePq) {
bt2100Luminance(RgbBlue()) * kPqMaxNits, LuminanceEpsilon());
}
-TEST_F(RecoveryMapMathTest, ApplyMap) {
+TEST_F(GainMapMathTest, ApplyMap) {
jpegr_metadata_struct metadata = { .maxContentBoost = 8.0f,
.minContentBoost = 1.0f / 8.0f };
diff --git a/libs/jpegrecoverymap/tests/jpegr_test.cpp b/libs/jpegrecoverymap/tests/jpegr_test.cpp
index 229d7dc93b..620f4310df 100644
--- a/libs/jpegrecoverymap/tests/jpegr_test.cpp
+++ b/libs/jpegrecoverymap/tests/jpegr_test.cpp
@@ -16,7 +16,7 @@
#include <jpegrecoverymap/jpegr.h>
#include <jpegrecoverymap/jpegrutils.h>
-#include <jpegrecoverymap/recoverymapmath.h>
+#include <jpegrecoverymap/gainmapmath.h>
#include <fcntl.h>
#include <fstream>
#include <gtest/gtest.h>
@@ -117,18 +117,18 @@ void JpegRTest::TearDown() {
class JpegRBenchmark : public JpegR {
public:
- void BenchmarkGenerateRecoveryMap(jr_uncompressed_ptr yuv420Image, jr_uncompressed_ptr p010Image,
- jr_metadata_ptr metadata, jr_uncompressed_ptr map);
- void BenchmarkApplyRecoveryMap(jr_uncompressed_ptr yuv420Image, jr_uncompressed_ptr map,
- jr_metadata_ptr metadata, jr_uncompressed_ptr dest);
+ void BenchmarkGenerateGainMap(jr_uncompressed_ptr yuv420Image, jr_uncompressed_ptr p010Image,
+ jr_metadata_ptr metadata, jr_uncompressed_ptr map);
+ void BenchmarkApplyGainMap(jr_uncompressed_ptr yuv420Image, jr_uncompressed_ptr map,
+ jr_metadata_ptr metadata, jr_uncompressed_ptr dest);
private:
const int kProfileCount = 10;
};
-void JpegRBenchmark::BenchmarkGenerateRecoveryMap(jr_uncompressed_ptr yuv420Image,
- jr_uncompressed_ptr p010Image,
- jr_metadata_ptr metadata,
- jr_uncompressed_ptr map) {
+void JpegRBenchmark::BenchmarkGenerateGainMap(jr_uncompressed_ptr yuv420Image,
+ jr_uncompressed_ptr p010Image,
+ jr_metadata_ptr metadata,
+ jr_uncompressed_ptr map) {
ASSERT_EQ(yuv420Image->width, p010Image->width);
ASSERT_EQ(yuv420Image->height, p010Image->height);
@@ -136,38 +136,38 @@ void JpegRBenchmark::BenchmarkGenerateRecoveryMap(jr_uncompressed_ptr yuv420Imag
timerStart(&genRecMapTime);
for (auto i = 0; i < kProfileCount; i++) {
- ASSERT_EQ(OK, generateRecoveryMap(
+ ASSERT_EQ(OK, generateGainMap(
yuv420Image, p010Image, jpegr_transfer_function::JPEGR_TF_HLG, metadata, map));
if (i != kProfileCount - 1) delete[] static_cast<uint8_t *>(map->data);
}
timerStop(&genRecMapTime);
- ALOGE("Generate Recovery Map:- Res = %i x %i, time = %f ms",
+ ALOGE("Generate Gain Map:- Res = %i x %i, time = %f ms",
yuv420Image->width, yuv420Image->height,
elapsedTime(&genRecMapTime) / (kProfileCount * 1000.f));
}
-void JpegRBenchmark::BenchmarkApplyRecoveryMap(jr_uncompressed_ptr yuv420Image,
- jr_uncompressed_ptr map,
- jr_metadata_ptr metadata,
- jr_uncompressed_ptr dest) {
+void JpegRBenchmark::BenchmarkApplyGainMap(jr_uncompressed_ptr yuv420Image,
+ jr_uncompressed_ptr map,
+ jr_metadata_ptr metadata,
+ jr_uncompressed_ptr dest) {
Timer applyRecMapTime;
timerStart(&applyRecMapTime);
for (auto i = 0; i < kProfileCount; i++) {
- ASSERT_EQ(OK, applyRecoveryMap(yuv420Image, map, metadata, JPEGR_OUTPUT_HDR_HLG,
- metadata->maxContentBoost /* displayBoost */, dest));
+ ASSERT_EQ(OK, applyGainMap(yuv420Image, map, metadata, JPEGR_OUTPUT_HDR_HLG,
+ metadata->maxContentBoost /* displayBoost */, dest));
}
timerStop(&applyRecMapTime);
- ALOGE("Apply Recovery Map:- Res = %i x %i, time = %f ms",
+ ALOGE("Apply Gain Map:- Res = %i x %i, time = %f ms",
yuv420Image->width, yuv420Image->height,
elapsedTime(&applyRecMapTime) / (kProfileCount * 1000.f));
}
TEST_F(JpegRTest, build) {
- // Force all of the recovery map lib to be linked by calling all public functions.
+ // Force all of the gain map lib to be linked by calling all public functions.
JpegR jpegRCodec;
jpegRCodec.encodeJPEGR(nullptr, static_cast<jpegr_transfer_function>(0), nullptr, 0, nullptr);
jpegRCodec.encodeJPEGR(nullptr, nullptr, static_cast<jpegr_transfer_function>(0),
@@ -515,7 +515,7 @@ TEST_F(JpegRTest, encodeFromJpegThenDecode) {
free(decodedJpegR.data);
}
-TEST_F(JpegRTest, ProfileRecoveryMapFuncs) {
+TEST_F(JpegRTest, ProfileGainMapFuncs) {
const size_t kWidth = TEST_IMAGE_WIDTH;
const size_t kHeight = TEST_IMAGE_HEIGHT;
@@ -545,7 +545,7 @@ TEST_F(JpegRTest, ProfileRecoveryMapFuncs) {
.height = 0,
.colorGamut = JPEGR_COLORGAMUT_UNSPECIFIED };
- benchmark.BenchmarkGenerateRecoveryMap(&mRawYuv420Image, &mRawP010Image, &metadata, &map);
+ benchmark.BenchmarkGenerateGainMap(&mRawYuv420Image, &mRawP010Image, &metadata, &map);
const int dstSize = mRawYuv420Image.width * mRawYuv420Image.height * 4;
auto bufferDst = std::make_unique<uint8_t[]>(dstSize);
@@ -554,7 +554,7 @@ TEST_F(JpegRTest, ProfileRecoveryMapFuncs) {
.height = 0,
.colorGamut = JPEGR_COLORGAMUT_UNSPECIFIED };
- benchmark.BenchmarkApplyRecoveryMap(&mRawYuv420Image, &map, &metadata, &dest);
+ benchmark.BenchmarkApplyGainMap(&mRawYuv420Image, &map, &metadata, &dest);
}
} // namespace android::recoverymap
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-10-22 10:18:35 +0000