diff --git a/examples/ultrahdr_app.cpp b/examples/ultrahdr_app.cpp
index 4c67e2b0..7c96882d 100644
--- a/examples/ultrahdr_app.cpp
+++ b/examples/ultrahdr_app.cpp
@@ -244,17 +244,20 @@ static bool writeFile(const char* filename, uhdr_raw_image_t* img) {
 
 class UltraHdrAppInput {
  public:
-  UltraHdrAppInput(
-      const char* hdrIntentRawFile, const char* sdrIntentRawFile,
-      const char* sdrIntentCompressedFile, const char* gainmapCompressedFile,
-      const char* gainmapMetadataCfgFile, const char* exifFile, const char* outputFile,
-      size_t width, size_t height, uhdr_img_fmt_t hdrCf = UHDR_IMG_FMT_32bppRGBA1010102,
-      uhdr_img_fmt_t sdrCf = UHDR_IMG_FMT_32bppRGBA8888,
-      uhdr_color_gamut_t hdrCg = UHDR_CG_DISPLAY_P3, uhdr_color_gamut_t sdrCg = UHDR_CG_BT_709,
-      uhdr_color_transfer_t hdrTf = UHDR_CT_HLG, int quality = 95,
-      uhdr_color_transfer_t oTf = UHDR_CT_HLG, uhdr_img_fmt_t oFmt = UHDR_IMG_FMT_32bppRGBA1010102,
-      bool isHdrCrFull = false, int gainmapScaleFactor = 4, int gainmapQuality = 85,
-      bool enableMultiChannelGainMap = false, float gamma = 1.0f, bool enableGLES = false)
+  UltraHdrAppInput(const char* hdrIntentRawFile, const char* sdrIntentRawFile,
+                   const char* sdrIntentCompressedFile, const char* gainmapCompressedFile,
+                   const char* gainmapMetadataCfgFile, const char* exifFile, const char* outputFile,
+                   size_t width, size_t height,
+                   uhdr_img_fmt_t hdrCf = UHDR_IMG_FMT_32bppRGBA1010102,
+                   uhdr_img_fmt_t sdrCf = UHDR_IMG_FMT_32bppRGBA8888,
+                   uhdr_color_gamut_t hdrCg = UHDR_CG_DISPLAY_P3,
+                   uhdr_color_gamut_t sdrCg = UHDR_CG_BT_709,
+                   uhdr_color_transfer_t hdrTf = UHDR_CT_HLG, int quality = 95,
+                   uhdr_color_transfer_t oTf = UHDR_CT_HLG,
+                   uhdr_img_fmt_t oFmt = UHDR_IMG_FMT_32bppRGBA1010102, bool isHdrCrFull = false,
+                   int gainmapScaleFactor = 4, int gainmapQuality = 85,
+                   bool enableMultiChannelGainMap = false, float gamma = 1.0f,
+                   bool enableGLES = false, uhdr_enc_preset_t encPreset = UHDR_USAGE_REALTIME)
       : mHdrIntentRawFile(hdrIntentRawFile),
         mSdrIntentRawFile(sdrIntentRawFile),
         mSdrIntentCompressedFile(sdrIntentCompressedFile),
@@ -279,6 +282,7 @@ class UltraHdrAppInput {
         mUseMultiChannelGainMap(enableMultiChannelGainMap),
         mGamma(gamma),
         mEnableGLES(enableGLES),
+        mEncPreset(encPreset),
         mMode(0){};
 
   UltraHdrAppInput(const char* gainmapMetadataCfgFile, const char* uhdrFile, const char* outputFile,
@@ -308,6 +312,7 @@ class UltraHdrAppInput {
         mUseMultiChannelGainMap(false),
         mGamma(1.0f),
         mEnableGLES(enableGLES),
+        mEncPreset(UHDR_USAGE_REALTIME),
         mMode(1){};
 
   ~UltraHdrAppInput() {
@@ -387,6 +392,7 @@ class UltraHdrAppInput {
   const bool mUseMultiChannelGainMap;
   const float mGamma;
   const bool mEnableGLES;
+  const uhdr_enc_preset_t mEncPreset;
   const int mMode;
 
   uhdr_raw_image_t mRawP010Image{};
@@ -683,6 +689,7 @@ bool UltraHdrAppInput::encode() {
   RET_IF_ERR(uhdr_enc_set_using_multi_channel_gainmap(handle, mUseMultiChannelGainMap))
   RET_IF_ERR(uhdr_enc_set_gainmap_scale_factor(handle, mMapDimensionScaleFactor))
   RET_IF_ERR(uhdr_enc_set_gainmap_gamma(handle, mGamma))
+  RET_IF_ERR(uhdr_enc_set_preset(handle, mEncPreset))
   if (mEnableGLES) {
     RET_IF_ERR(uhdr_enable_gpu_acceleration(handle, mEnableGLES))
   }
@@ -1348,6 +1355,9 @@ static void usage(const char* name) {
           "real number (1.0 : default)].\n");
   fprintf(stderr,
           "    -M    select multi channel gain map, optional. [0:disable (default), 1:enable]. \n");
+  fprintf(
+      stderr,
+      "    -D    select encoding preset, optional. [0:real time (default), 1:best quality]. \n");
   fprintf(stderr, "    -x    binary input resource containing exif data to insert, optional. \n");
   fprintf(stderr, "\n## decoder options : \n");
   fprintf(stderr, "    -j    ultra hdr compressed input resource, required. \n");
@@ -1425,7 +1435,7 @@ static void usage(const char* name) {
   fprintf(stderr, "\n## encode at high quality :\n");
   fprintf(stderr,
           "    ultrahdr_app -m 0 -p hdr_intent.raw -y sdr_intent.raw -w 640 -h 480 -c <select> -C "
-          "<select> -t <select> -s 1 -M 1 -Q 98 -q 98\n");
+          "<select> -t <select> -s 1 -M 1 -Q 98 -q 98 -D 1\n");
 
   fprintf(stderr, "\n## decode api :\n");
   fprintf(stderr, "    ultrahdr_app -m 1 -j cosmat_1920x1080_hdr.jpg \n");
@@ -1435,7 +1445,7 @@ static void usage(const char* name) {
 }
 
 int main(int argc, char* argv[]) {
-  char opt_string[] = "p:y:i:g:f:w:h:C:c:t:q:o:O:m:j:e:a:b:z:R:s:M:Q:G:x:u:";
+  char opt_string[] = "p:y:i:g:f:w:h:C:c:t:q:o:O:m:j:e:a:b:z:R:s:M:Q:G:x:u:D:";
   char *hdr_intent_raw_file = nullptr, *sdr_intent_raw_file = nullptr, *uhdr_file = nullptr,
        *sdr_intent_compressed_file = nullptr, *gainmap_compressed_file = nullptr,
        *gainmap_metadata_cfg_file = nullptr, *output_file = nullptr, *exif_file = nullptr;
@@ -1456,6 +1466,7 @@ int main(int argc, char* argv[]) {
   int compute_psnr = 0;
   float gamma = 1.0f;
   bool enable_gles = false;
+  uhdr_enc_preset_t enc_preset = UHDR_USAGE_REALTIME;
   int ch;
   while ((ch = getopt_s(argc, argv, opt_string)) != -1) {
     switch (ch) {
@@ -1541,6 +1552,9 @@ int main(int argc, char* argv[]) {
       case 'u':
         enable_gles = atoi(optarg_s) == 1 ? true : false;
         break;
+      case 'D':
+        enc_preset = static_cast<uhdr_enc_preset_t>(atoi(optarg_s));
+        break;
       default:
         usage(argv[0]);
         return -1;
@@ -1568,7 +1582,7 @@ int main(int argc, char* argv[]) {
         gainmap_compressed_file, gainmap_metadata_cfg_file, exif_file,
         output_file ? output_file : "out.jpeg", width, height, hdr_cf, sdr_cf, hdr_cg, sdr_cg,
         hdr_tf, quality, out_tf, out_cf, use_full_range_color_hdr, gainmap_scale_factor,
-        gainmap_compression_quality, use_multi_channel_gainmap, gamma, enable_gles);
+        gainmap_compression_quality, use_multi_channel_gainmap, gamma, enable_gles, enc_preset);
     if (!appInput.encode()) return -1;
     if (compute_psnr == 1) {
       if (!appInput.decode()) return -1;
diff --git a/fuzzer/ultrahdr_enc_fuzzer.cpp b/fuzzer/ultrahdr_enc_fuzzer.cpp
index d91c569e..8aad4feb 100644
--- a/fuzzer/ultrahdr_enc_fuzzer.cpp
+++ b/fuzzer/ultrahdr_enc_fuzzer.cpp
@@ -113,6 +113,9 @@ void UltraHdrEncFuzzer::process() {
     // gainmap scale factor
     auto gm_scale_factor = mFdp.ConsumeIntegralInRange<int>(1, 128);
 
+    // encoding speed preset
+    auto enc_preset = static_cast<uhdr_enc_preset_t>(mFdp.ConsumeIntegralInRange<int>(0, 1));
+
     std::unique_ptr<uint32_t[]> bufferHdr = nullptr;
     std::unique_ptr<uint16_t[]> bufferYHdr = nullptr;
     std::unique_ptr<uint16_t[]> bufferUVHdr = nullptr;
@@ -265,6 +268,7 @@ void UltraHdrEncFuzzer::process() {
     ON_ERR(uhdr_enc_set_quality(enc_handle, gainmap_quality, UHDR_GAIN_MAP_IMG))
     ON_ERR(uhdr_enc_set_gainmap_scale_factor(enc_handle, gm_scale_factor))
     ON_ERR(uhdr_enc_set_using_multi_channel_gainmap(enc_handle, multi_channel_gainmap))
+    ON_ERR(uhdr_enc_set_preset(enc_handle, enc_preset))
 
     uhdr_error_info_t status = {UHDR_CODEC_OK, 0, ""};
     if (muxSwitch == 0 || muxSwitch == 1) {  // api 0 or api 1
diff --git a/lib/include/ultrahdr/gainmapmath.h b/lib/include/ultrahdr/gainmapmath.h
index 9ffef38e..4470525a 100644
--- a/lib/include/ultrahdr/gainmapmath.h
+++ b/lib/include/ultrahdr/gainmapmath.h
@@ -194,7 +194,7 @@ struct GainLUT {
 
   GainLUT(uhdr_gainmap_metadata_ext_t* metadata, float displayBoost) {
     this->mGammaInv = 1.0f / metadata->gamma;
-    float boostFactor = displayBoost > 0 ? displayBoost / metadata->max_content_boost : 1.0f;
+    float boostFactor = displayBoost > 0 ? displayBoost / metadata->hdr_capacity_max : 1.0f;
     for (int32_t idx = 0; idx < kGainFactorNumEntries; idx++) {
       float value = static_cast<float>(idx) / static_cast<float>(kGainFactorNumEntries - 1);
       float logBoost = log2(metadata->min_content_boost) * (1.0f - value) +
@@ -540,23 +540,17 @@ void transformYuv444(uhdr_raw_image_t* image, const std::array<float, 9>& coeffs
 
 /*
  * 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.
- *
- * Note: since this library always uses gamma of 1.0, offsetSdr of 0.0, and
- * offsetHdr of 0.0, this function doesn't handle different metadata values for
- * these fields.
+ * luminances in linear space and gainmap metadata fields.
  */
 uint8_t encodeGain(float y_sdr, float y_hdr, uhdr_gainmap_metadata_ext_t* metadata);
 uint8_t encodeGain(float y_sdr, float y_hdr, uhdr_gainmap_metadata_ext_t* metadata,
                    float log2MinContentBoost, float log2MaxContentBoost);
+float computeGain(float sdr, float hdr);
+uint8_t affineMapGain(float gainlog2, float mingainlog2, float maxgainlog2, float gamma);
 
 /*
  * 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].
- *
- * Note: similar to encodeGain(), this function only supports gamma 1.0,
- * offsetSdr 0.0, offsetHdr 0.0, hdrCapacityMin 1.0, and hdrCapacityMax equal to
- * gainMapMax, as this library encodes.
  */
 Color applyGain(Color e, float gain, uhdr_gainmap_metadata_ext_t* metadata);
 Color applyGain(Color e, float gain, uhdr_gainmap_metadata_ext_t* metadata, float displayBoost);
@@ -565,10 +559,6 @@ Color applyGainLUT(Color e, float gain, GainLUT& gainLUT);
 /*
  * Apply gain in R, G and B channels, with the given hdr ratio, to the given sdr input
  * in the range [0, 1].
- *
- * Note: similar to encodeGain(), this function only supports gamma 1.0,
- * offsetSdr 0.0, offsetHdr 0.0, hdrCapacityMin 1.0, and hdrCapacityMax equal to
- * gainMapMax, as this library encodes.
  */
 Color applyGain(Color e, Color gain, uhdr_gainmap_metadata_ext_t* metadata);
 Color applyGain(Color e, Color gain, uhdr_gainmap_metadata_ext_t* metadata, float displayBoost);
diff --git a/lib/include/ultrahdr/jpegr.h b/lib/include/ultrahdr/jpegr.h
index 48d89e7c..225525a9 100644
--- a/lib/include/ultrahdr/jpegr.h
+++ b/lib/include/ultrahdr/jpegr.h
@@ -77,7 +77,7 @@ class JpegR {
         size_t mapDimensionScaleFactor = kMapDimensionScaleFactorDefault,
         int mapCompressQuality = kMapCompressQualityDefault,
         bool useMultiChannelGainMap = kUseMultiChannelGainMapDefault,
-        float gamma = kGainMapGammaDefault);
+        float gamma = kGainMapGammaDefault, uhdr_enc_preset_t preset = UHDR_USAGE_REALTIME);
 
   /*!\brief Encode API-0.
    *
@@ -571,6 +571,7 @@ class JpegR {
   int mMapCompressQuality;          // gain map quality factor
   bool mUseMultiChannelGainMap;     // enable multichannel gain map
   float mGamma;                     // gain map gamma parameter
+  uhdr_enc_preset_t mEncPreset;     // encoding speed preset
 };
 
 struct GlobalTonemapOutputs {
diff --git a/lib/include/ultrahdr/ultrahdrcommon.h b/lib/include/ultrahdr/ultrahdrcommon.h
index bd5a52e1..1364bec0 100644
--- a/lib/include/ultrahdr/ultrahdrcommon.h
+++ b/lib/include/ultrahdr/ultrahdrcommon.h
@@ -327,6 +327,7 @@ struct uhdr_encoder_private : uhdr_codec_private {
   int m_gainmap_scale_factor;
   bool m_use_multi_channel_gainmap;
   float m_gamma;
+  uhdr_enc_preset_t m_enc_preset;
 
   // internal data
   std::unique_ptr<ultrahdr::uhdr_compressed_image_ext_t> m_compressed_output_buffer;
diff --git a/lib/src/gainmapmath.cpp b/lib/src/gainmapmath.cpp
index bfc33a47..fe32904b 100644
--- a/lib/src/gainmapmath.cpp
+++ b/lib/src/gainmapmath.cpp
@@ -490,7 +490,7 @@ SamplePixelFn getSamplePixelFn(uhdr_img_fmt_t format) {
 float getMaxDisplayMasteringLuminance(uhdr_color_transfer_t transfer) {
   switch (transfer) {
     case UHDR_CT_LINEAR:
-      // TODO: configure maxCLL correctly for linear tf
+      // TODO: configure MDML correctly for linear tf
       return kHlgMaxNits;
     case UHDR_CT_HLG:
       return kHlgMaxNits;
@@ -647,6 +647,22 @@ uint8_t encodeGain(float y_sdr, float y_hdr, uhdr_gainmap_metadata_ext_t* metada
   return static_cast<uint8_t>(gain_normalized_gamma * 255.0f);
 }
 
+float computeGain(float sdr, float hdr) {
+  if (sdr == 0.0f) return 0.0f;  // for sdr black return no gain
+  if (hdr == 0.0f) {  // for hdr black, return a gain large enough to attenuate the sdr pel
+    float offset = (1.0f / 64);
+    return log2(offset / (offset + sdr));
+  }
+  return log2(hdr / sdr);
+}
+
+uint8_t affineMapGain(float gainlog2, float mingainlog2, float maxgainlog2, float gamma) {
+  float mappedVal = (gainlog2 - mingainlog2) / (maxgainlog2 - mingainlog2);
+  if (gamma != 1.0f) mappedVal = pow(mappedVal, gamma);
+  mappedVal *= 255;
+  return CLIP3(mappedVal + 0.5f, 0, 255);
+}
+
 Color applyGain(Color e, float gain, uhdr_gainmap_metadata_ext_t* metadata) {
   gain = pow(gain, 1.0f / metadata->gamma);
   float logBoost =
@@ -659,7 +675,7 @@ Color applyGain(Color e, float gain, uhdr_gainmap_metadata_ext_t* metadata, floa
   gain = pow(gain, 1.0f / metadata->gamma);
   float logBoost =
       log2(metadata->min_content_boost) * (1.0f - gain) + log2(metadata->max_content_boost) * gain;
-  float gainFactor = exp2(logBoost * displayBoost / metadata->max_content_boost);
+  float gainFactor = exp2(logBoost * displayBoost / metadata->hdr_capacity_max);
   return e * gainFactor;
 }
 
@@ -694,9 +710,9 @@ Color applyGain(Color e, Color gain, uhdr_gainmap_metadata_ext_t* metadata, floa
                     log2(metadata->max_content_boost) * gain.g;
   float logBoostB = log2(metadata->min_content_boost) * (1.0f - gain.b) +
                     log2(metadata->max_content_boost) * gain.b;
-  float gainFactorR = exp2(logBoostR * displayBoost / metadata->max_content_boost);
-  float gainFactorG = exp2(logBoostG * displayBoost / metadata->max_content_boost);
-  float gainFactorB = exp2(logBoostB * displayBoost / metadata->max_content_boost);
+  float gainFactorR = exp2(logBoostR * displayBoost / metadata->hdr_capacity_max);
+  float gainFactorG = exp2(logBoostG * displayBoost / metadata->hdr_capacity_max);
+  float gainFactorB = exp2(logBoostB * displayBoost / metadata->hdr_capacity_max);
   return {{{e.r * gainFactorR, e.g * gainFactorG, e.b * gainFactorB}}};
 }
 
diff --git a/lib/src/jpegr.cpp b/lib/src/jpegr.cpp
index 62311948..d1d6763a 100644
--- a/lib/src/jpegr.cpp
+++ b/lib/src/jpegr.cpp
@@ -148,12 +148,13 @@ int GetCPUCoreCount() {
 }
 
 JpegR::JpegR(void* uhdrGLESCtxt, size_t mapDimensionScaleFactor, int mapCompressQuality,
-             bool useMultiChannelGainMap, float gamma) {
+             bool useMultiChannelGainMap, float gamma, uhdr_enc_preset_t preset) {
   mUhdrGLESCtxt = uhdrGLESCtxt;
   mMapDimensionScaleFactor = mapDimensionScaleFactor;
   mMapCompressQuality = mapCompressQuality;
   mUseMultiChannelGainMap = useMultiChannelGainMap;
   mGamma = gamma;
+  mEncPreset = preset;
 }
 
 /*
@@ -202,6 +203,10 @@ uhdr_error_info_t JpegR::encodeJPEGR(uhdr_raw_image_t* hdr_intent, uhdr_compress
   // tone map
   UHDR_ERR_CHECK(toneMap(hdr_intent, sdr_intent.get()));
 
+  // If hdr intent is tonemapped internally, it is observed from quality pov,
+  // generateGainMapOnePass() is sufficient
+  mEncPreset = UHDR_USAGE_REALTIME;  // overriding the config option
+
   // generate gain map
   uhdr_gainmap_metadata_ext_t metadata(kJpegrVersion);
   std::unique_ptr<uhdr_raw_image_ext_t> gainmap;
@@ -519,22 +524,11 @@ uhdr_error_info_t JpegR::generateGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_
     status.error_code = UHDR_CODEC_UNSUPPORTED_FEATURE;
     status.has_detail = 1;
     snprintf(status.detail, sizeof status.detail,
-             "Did not receive valid maxCLL for display with transfer characteristics %d",
+             "Did not receive valid MDML for display with transfer characteristics %d",
              hdr_intent->ct);
     return status;
   }
 
-  gainmap_metadata->max_content_boost = hdr_white_nits / kSdrWhiteNits;
-  gainmap_metadata->min_content_boost = 1.0f;
-  gainmap_metadata->gamma = mGamma;
-  gainmap_metadata->offset_sdr = 0.0f;
-  gainmap_metadata->offset_hdr = 0.0f;
-  gainmap_metadata->hdr_capacity_min = 1.0f;
-  gainmap_metadata->hdr_capacity_max = gainmap_metadata->max_content_boost;
-
-  float log2MinBoost = log2(gainmap_metadata->min_content_boost);
-  float log2MaxBoost = log2(gainmap_metadata->max_content_boost);
-
   ColorTransformFn hdrGamutConversionFn = getGamutConversionFn(sdr_intent->cg, hdr_intent->cg);
   if (hdrGamutConversionFn == nullptr) {
     status.error_code = UHDR_CODEC_UNSUPPORTED_FEATURE;
@@ -618,78 +612,265 @@ uhdr_error_info_t JpegR::generateGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_
       UHDR_CG_UNSPECIFIED, UHDR_CT_UNSPECIFIED, UHDR_CR_UNSPECIFIED, map_width, map_height, 64);
   uhdr_raw_image_ext_t* dest = gainmap_img.get();
 
-  const int threads = (std::min)(GetCPUCoreCount(), 4);
-  const int jobSizeInRows = 1;
-  size_t rowStep = threads == 1 ? map_height : jobSizeInRows;
-  JobQueue jobQueue;
-  std::function<void()> generateMap =
-      [this, sdr_intent, hdr_intent, gainmap_metadata, dest, hdrInvOetf, hdrGamutConversionFn,
-       luminanceFn, sdrYuvToRgbFn, hdrYuvToRgbFn, sdr_sample_pixel_fn, hdr_sample_pixel_fn,
-       hdr_white_nits, log2MinBoost, log2MaxBoost, use_luminance, &jobQueue]() -> void {
-    size_t rowStart, rowEnd;
-    while (jobQueue.dequeueJob(rowStart, rowEnd)) {
-      for (size_t y = rowStart; y < rowEnd; ++y) {
-        for (size_t x = 0; x < dest->w; ++x) {
-          Color sdr_yuv_gamma = sdr_sample_pixel_fn(sdr_intent, mMapDimensionScaleFactor, x, y);
-          Color sdr_rgb_gamma = sdrYuvToRgbFn(sdr_yuv_gamma);
-          // We are assuming the SDR input is always sRGB transfer.
+  auto generateGainMapOnePass = [this, sdr_intent, hdr_intent, gainmap_metadata, dest, map_height,
+                                 hdrInvOetf, hdrGamutConversionFn, luminanceFn, sdrYuvToRgbFn,
+                                 hdrYuvToRgbFn, sdr_sample_pixel_fn, hdr_sample_pixel_fn,
+                                 hdr_white_nits, use_luminance]() -> void {
+    gainmap_metadata->max_content_boost = hdr_white_nits / kSdrWhiteNits;
+    gainmap_metadata->min_content_boost = 1.0f;
+    gainmap_metadata->gamma = mGamma;
+    gainmap_metadata->offset_sdr = 0.0f;
+    gainmap_metadata->offset_hdr = 0.0f;
+    gainmap_metadata->hdr_capacity_min = 1.0f;
+    gainmap_metadata->hdr_capacity_max = gainmap_metadata->max_content_boost;
+
+    float log2MinBoost = log2(gainmap_metadata->min_content_boost);
+    float log2MaxBoost = log2(gainmap_metadata->max_content_boost);
+
+    const int threads = (std::min)(GetCPUCoreCount(), 4);
+    const int jobSizeInRows = 1;
+    size_t rowStep = threads == 1 ? map_height : jobSizeInRows;
+    JobQueue jobQueue;
+    std::function<void()> generateMap =
+        [this, sdr_intent, hdr_intent, gainmap_metadata, dest, hdrInvOetf, hdrGamutConversionFn,
+         luminanceFn, sdrYuvToRgbFn, hdrYuvToRgbFn, sdr_sample_pixel_fn, hdr_sample_pixel_fn,
+         hdr_white_nits, log2MinBoost, log2MaxBoost, use_luminance, &jobQueue]() -> void {
+      size_t rowStart, rowEnd;
+      while (jobQueue.dequeueJob(rowStart, rowEnd)) {
+        for (size_t y = rowStart; y < rowEnd; ++y) {
+          for (size_t x = 0; x < dest->w; ++x) {
+            Color sdr_yuv_gamma = sdr_sample_pixel_fn(sdr_intent, mMapDimensionScaleFactor, x, y);
+            Color sdr_rgb_gamma = sdrYuvToRgbFn(sdr_yuv_gamma);
+            // We are assuming the SDR input is always sRGB transfer.
 #if USE_SRGB_INVOETF_LUT
-          Color sdr_rgb = srgbInvOetfLUT(sdr_rgb_gamma);
+            Color sdr_rgb = srgbInvOetfLUT(sdr_rgb_gamma);
 #else
-          Color sdr_rgb = srgbInvOetf(sdr_rgb_gamma);
+            Color sdr_rgb = srgbInvOetf(sdr_rgb_gamma);
 #endif
 
-          Color hdr_yuv_gamma = hdr_sample_pixel_fn(hdr_intent, mMapDimensionScaleFactor, x, y);
-          Color hdr_rgb_gamma = hdrYuvToRgbFn(hdr_yuv_gamma);
-          Color hdr_rgb = hdrInvOetf(hdr_rgb_gamma);
-          hdr_rgb = hdrGamutConversionFn(hdr_rgb);
-
-          if (mUseMultiChannelGainMap) {
-            Color sdr_rgb_nits = sdr_rgb * kSdrWhiteNits;
-            Color hdr_rgb_nits = hdr_rgb * hdr_white_nits;
-            size_t pixel_idx = (x + y * dest->stride[UHDR_PLANE_PACKED]) * 3;
-
-            reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_PACKED])[pixel_idx] = encodeGain(
-                sdr_rgb_nits.r, hdr_rgb_nits.r, gainmap_metadata, log2MinBoost, log2MaxBoost);
-            reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_PACKED])[pixel_idx + 1] = encodeGain(
-                sdr_rgb_nits.g, hdr_rgb_nits.g, gainmap_metadata, log2MinBoost, log2MaxBoost);
-            reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_PACKED])[pixel_idx + 2] = encodeGain(
-                sdr_rgb_nits.b, hdr_rgb_nits.b, gainmap_metadata, log2MinBoost, log2MaxBoost);
-          } else {
-            float sdr_y_nits;
-            float hdr_y_nits;
-            if (use_luminance) {
-              sdr_y_nits = luminanceFn(sdr_rgb) * kSdrWhiteNits;
-              hdr_y_nits = luminanceFn(hdr_rgb) * hdr_white_nits;
+            Color hdr_yuv_gamma = hdr_sample_pixel_fn(hdr_intent, mMapDimensionScaleFactor, x, y);
+            Color hdr_rgb_gamma = hdrYuvToRgbFn(hdr_yuv_gamma);
+            Color hdr_rgb = hdrInvOetf(hdr_rgb_gamma);
+            hdr_rgb = hdrGamutConversionFn(hdr_rgb);
+
+            if (mUseMultiChannelGainMap) {
+              Color sdr_rgb_nits = sdr_rgb * kSdrWhiteNits;
+              Color hdr_rgb_nits = hdr_rgb * hdr_white_nits;
+              size_t pixel_idx = (x + y * dest->stride[UHDR_PLANE_PACKED]) * 3;
+
+              reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_PACKED])[pixel_idx] = encodeGain(
+                  sdr_rgb_nits.r, hdr_rgb_nits.r, gainmap_metadata, log2MinBoost, log2MaxBoost);
+              reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_PACKED])[pixel_idx + 1] =
+                  encodeGain(sdr_rgb_nits.g, hdr_rgb_nits.g, gainmap_metadata, log2MinBoost,
+                             log2MaxBoost);
+              reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_PACKED])[pixel_idx + 2] =
+                  encodeGain(sdr_rgb_nits.b, hdr_rgb_nits.b, gainmap_metadata, log2MinBoost,
+                             log2MaxBoost);
             } else {
-              sdr_y_nits = fmax(sdr_rgb.r, fmax(sdr_rgb.g, sdr_rgb.b)) * kSdrWhiteNits;
-              hdr_y_nits = fmax(hdr_rgb.r, fmax(hdr_rgb.g, hdr_rgb.b)) * hdr_white_nits;
+              float sdr_y_nits;
+              float hdr_y_nits;
+              if (use_luminance) {
+                sdr_y_nits = luminanceFn(sdr_rgb) * kSdrWhiteNits;
+                hdr_y_nits = luminanceFn(hdr_rgb) * hdr_white_nits;
+              } else {
+                sdr_y_nits = fmax(sdr_rgb.r, fmax(sdr_rgb.g, sdr_rgb.b)) * kSdrWhiteNits;
+                hdr_y_nits = fmax(hdr_rgb.r, fmax(hdr_rgb.g, hdr_rgb.b)) * hdr_white_nits;
+              }
+
+              size_t pixel_idx = x + y * dest->stride[UHDR_PLANE_Y];
+
+              reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_Y])[pixel_idx] =
+                  encodeGain(sdr_y_nits, hdr_y_nits, gainmap_metadata, log2MinBoost, log2MaxBoost);
             }
+          }
+        }
+      }
+    };
+
+    // generate map
+    std::vector<std::thread> workers;
+    for (int th = 0; th < threads - 1; th++) {
+      workers.push_back(std::thread(generateMap));
+    }
+
+    for (size_t rowStart = 0; rowStart < map_height;) {
+      size_t rowEnd = (std::min)(rowStart + rowStep, map_height);
+      jobQueue.enqueueJob(rowStart, rowEnd);
+      rowStart = rowEnd;
+    }
+    jobQueue.markQueueForEnd();
+    generateMap();
+    std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
+  };
 
-            size_t pixel_idx = x + y * dest->stride[UHDR_PLANE_Y];
+  auto generateGainMapTwoPass = [this, sdr_intent, hdr_intent, gainmap_metadata, dest, map_width,
+                                 map_height, hdrInvOetf, hdrGamutConversionFn, luminanceFn,
+                                 sdrYuvToRgbFn, hdrYuvToRgbFn, sdr_sample_pixel_fn,
+                                 hdr_sample_pixel_fn, hdr_white_nits, use_luminance]() -> void {
+    uhdr_memory_block_t gainmap_mem(map_width * map_height * sizeof(float) *
+                                    (mUseMultiChannelGainMap ? 3 : 1));
+    float* gainmap_data = reinterpret_cast<float*>(gainmap_mem.m_buffer.get());
+    float gainmap_min[3] = {127.0f, 127.0f, 127.0f};
+    float gainmap_max[3] = {-128.0f, -128.0f, -128.0f};
+    std::mutex gainmap_minmax;
+
+    const int threads = (std::min)(GetCPUCoreCount(), 4);
+    const int jobSizeInRows = 1;
+    size_t rowStep = threads == 1 ? map_height : jobSizeInRows;
+    JobQueue jobQueue;
+    std::function<void()> generateMap =
+        [this, sdr_intent, hdr_intent, gainmap_data, map_width, hdrInvOetf, hdrGamutConversionFn,
+         luminanceFn, sdrYuvToRgbFn, hdrYuvToRgbFn, sdr_sample_pixel_fn, hdr_sample_pixel_fn,
+         hdr_white_nits, use_luminance, &gainmap_min, &gainmap_max, &gainmap_minmax,
+         &jobQueue]() -> void {
+      size_t rowStart, rowEnd;
+      float gainmap_min_th[3] = {127.0f, 127.0f, 127.0f};
+      float gainmap_max_th[3] = {-128.0f, -128.0f, -128.0f};
+
+      while (jobQueue.dequeueJob(rowStart, rowEnd)) {
+        for (size_t y = rowStart; y < rowEnd; ++y) {
+          for (size_t x = 0; x < map_width; ++x) {
+            Color sdr_yuv_gamma = sdr_sample_pixel_fn(sdr_intent, mMapDimensionScaleFactor, x, y);
+            Color sdr_rgb_gamma = sdrYuvToRgbFn(sdr_yuv_gamma);
+            // We are assuming the SDR input is always sRGB transfer.
+#if USE_SRGB_INVOETF_LUT
+            Color sdr_rgb = srgbInvOetfLUT(sdr_rgb_gamma);
+#else
+            Color sdr_rgb = srgbInvOetf(sdr_rgb_gamma);
+#endif
 
-            reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_Y])[pixel_idx] =
-                encodeGain(sdr_y_nits, hdr_y_nits, gainmap_metadata, log2MinBoost, log2MaxBoost);
+            Color hdr_yuv_gamma = hdr_sample_pixel_fn(hdr_intent, mMapDimensionScaleFactor, x, y);
+            Color hdr_rgb_gamma = hdrYuvToRgbFn(hdr_yuv_gamma);
+            Color hdr_rgb = hdrInvOetf(hdr_rgb_gamma);
+            hdr_rgb = hdrGamutConversionFn(hdr_rgb);
+
+            if (mUseMultiChannelGainMap) {
+              Color sdr_rgb_nits = sdr_rgb * kSdrWhiteNits;
+              Color hdr_rgb_nits = hdr_rgb * hdr_white_nits;
+              size_t pixel_idx = (x + y * map_width) * 3;
+
+              gainmap_data[pixel_idx] = computeGain(sdr_rgb_nits.r, hdr_rgb_nits.r);
+              gainmap_data[pixel_idx + 1] = computeGain(sdr_rgb_nits.g, hdr_rgb_nits.g);
+              gainmap_data[pixel_idx + 2] = computeGain(sdr_rgb_nits.b, hdr_rgb_nits.b);
+              for (int i = 0; i < 3; i++) {
+                gainmap_min_th[i] = (std::min)(gainmap_data[pixel_idx + i], gainmap_min_th[i]);
+                gainmap_max_th[i] = (std::max)(gainmap_data[pixel_idx + i], gainmap_max_th[i]);
+              }
+            } else {
+              float sdr_y_nits;
+              float hdr_y_nits;
+
+              if (use_luminance) {
+                sdr_y_nits = luminanceFn(sdr_rgb) * kSdrWhiteNits;
+                hdr_y_nits = luminanceFn(hdr_rgb) * hdr_white_nits;
+              } else {
+                sdr_y_nits = fmax(sdr_rgb.r, fmax(sdr_rgb.g, sdr_rgb.b)) * kSdrWhiteNits;
+                hdr_y_nits = fmax(hdr_rgb.r, fmax(hdr_rgb.g, hdr_rgb.b)) * hdr_white_nits;
+              }
+
+              size_t pixel_idx = x + y * map_width;
+              gainmap_data[pixel_idx] = computeGain(sdr_y_nits, hdr_y_nits);
+              gainmap_min_th[0] = (std::min)(gainmap_data[pixel_idx], gainmap_min_th[0]);
+              gainmap_max_th[0] = (std::max)(gainmap_data[pixel_idx], gainmap_max_th[0]);
+            }
           }
         }
       }
+      {
+        std::unique_lock<std::mutex> lock{gainmap_minmax};
+        for (int index = 0; index < (mUseMultiChannelGainMap ? 3 : 1); index++) {
+          gainmap_min[index] = (std::min)(gainmap_min[index], gainmap_min_th[index]);
+          gainmap_max[index] = (std::max)(gainmap_max[index], gainmap_max_th[index]);
+        }
+      }
+    };
+
+    // generate map
+    std::vector<std::thread> workers;
+    for (int th = 0; th < threads - 1; th++) {
+      workers.push_back(std::thread(generateMap));
     }
-  };
 
-  // generate map
-  std::vector<std::thread> workers;
-  for (int th = 0; th < threads - 1; th++) {
-    workers.push_back(std::thread(generateMap));
-  }
+    for (size_t rowStart = 0; rowStart < map_height;) {
+      size_t rowEnd = (std::min)(rowStart + rowStep, map_height);
+      jobQueue.enqueueJob(rowStart, rowEnd);
+      rowStart = rowEnd;
+    }
+    jobQueue.markQueueForEnd();
+    generateMap();
+    std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
+
+    float min_content_boost_log2 = gainmap_min[0];
+    float max_content_boost_log2 = gainmap_max[0];
+    for (int index = 1; index < (mUseMultiChannelGainMap ? 3 : 1); index++) {
+      min_content_boost_log2 = (std::min)(gainmap_min[index], min_content_boost_log2);
+      max_content_boost_log2 = (std::max)(gainmap_max[index], max_content_boost_log2);
+    }
+    // -13.0 emphirically is a small enough gain factor that is capable of representing hdr
+    // black from any sdr luminance. Allowing further excursion might not offer any benefit and on
+    // the downside can cause bigger error during affine map and inverse map.
+    min_content_boost_log2 = (std::max)(-13.0f, min_content_boost_log2);
+    if (fabs(max_content_boost_log2 - min_content_boost_log2) < FLT_EPSILON) {
+      max_content_boost_log2 += 0.1;  // to avoid div by zero during affine transform
+    }
 
-  for (size_t rowStart = 0; rowStart < map_height;) {
-    size_t rowEnd = (std::min)(rowStart + rowStep, map_height);
-    jobQueue.enqueueJob(rowStart, rowEnd);
-    rowStart = rowEnd;
+    std::function<void()> encodeMap = [this, gainmap_data, map_width, dest, min_content_boost_log2,
+                                       max_content_boost_log2, &jobQueue]() -> void {
+      size_t rowStart, rowEnd;
+
+      while (jobQueue.dequeueJob(rowStart, rowEnd)) {
+        if (mUseMultiChannelGainMap) {
+          for (size_t j = rowStart; j < rowEnd; j++) {
+            size_t dst_pixel_idx = j * dest->stride[UHDR_PLANE_PACKED] * 3;
+            size_t src_pixel_idx = j * map_width * 3;
+            for (size_t i = 0; i < map_width * 3; i++) {
+              reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_PACKED])[dst_pixel_idx + i] =
+                  affineMapGain(gainmap_data[src_pixel_idx + i], min_content_boost_log2,
+                                max_content_boost_log2, this->mGamma);
+            }
+          }
+        } else {
+          for (size_t j = rowStart; j < rowEnd; j++) {
+            size_t dst_pixel_idx = j * dest->stride[UHDR_PLANE_Y];
+            size_t src_pixel_idx = j * map_width;
+            for (size_t i = 0; i < map_width; i++) {
+              reinterpret_cast<uint8_t*>(dest->planes[UHDR_PLANE_Y])[dst_pixel_idx + i] =
+                  affineMapGain(gainmap_data[src_pixel_idx + i], min_content_boost_log2,
+                                max_content_boost_log2, this->mGamma);
+            }
+          }
+        }
+      }
+    };
+    workers.clear();
+    jobQueue.reset();
+    rowStep = threads == 1 ? map_height : 1;
+    for (int th = 0; th < threads - 1; th++) {
+      workers.push_back(std::thread(encodeMap));
+    }
+    for (size_t rowStart = 0; rowStart < map_height;) {
+      size_t rowEnd = (std::min)(rowStart + rowStep, map_height);
+      jobQueue.enqueueJob(rowStart, rowEnd);
+      rowStart = rowEnd;
+    }
+    jobQueue.markQueueForEnd();
+    encodeMap();
+    std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
+
+    gainmap_metadata->max_content_boost = exp2(max_content_boost_log2);
+    gainmap_metadata->min_content_boost = exp2(min_content_boost_log2);
+    gainmap_metadata->gamma = this->mGamma;
+    gainmap_metadata->offset_sdr = 0.0f;
+    gainmap_metadata->offset_hdr = 0.0f;
+    gainmap_metadata->hdr_capacity_min = 1.0f;
+    gainmap_metadata->hdr_capacity_max = hdr_white_nits / kSdrWhiteNits;
+  };
+
+  if (mEncPreset == UHDR_USAGE_REALTIME) {
+    generateGainMapOnePass();
+  } else {
+    generateGainMapTwoPass();
   }
-  jobQueue.markQueueForEnd();
-  generateMap();
-  std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
 
   return status;
 }
@@ -1086,26 +1267,6 @@ uhdr_error_info_t JpegR::applyGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_ima
              gainmap_metadata->offset_hdr);
     return status;
   }
-  if (gainmap_metadata->hdr_capacity_min != gainmap_metadata->min_content_boost) {
-    uhdr_error_info_t status;
-    status.error_code = UHDR_CODEC_UNSUPPORTED_FEATURE;
-    status.has_detail = 1;
-    snprintf(status.detail, sizeof status.detail,
-             "Unsupported gainmap metadata, min_content_boost. Min content boost is expected to be "
-             "same as hdr capacity min. Min content boost %f, Hdr Capacity min %f",
-             gainmap_metadata->min_content_boost, gainmap_metadata->hdr_capacity_min);
-    return status;
-  }
-  if (gainmap_metadata->hdr_capacity_max != gainmap_metadata->max_content_boost) {
-    uhdr_error_info_t status;
-    status.error_code = UHDR_CODEC_UNSUPPORTED_FEATURE;
-    status.has_detail = 1;
-    snprintf(status.detail, sizeof status.detail,
-             "Unsupported gainmap metadata, max_content_boost. Max content boost is expected to be "
-             "same as hdr capacity max. Max content boost %f, Hdr Capacity max %f",
-             gainmap_metadata->max_content_boost, gainmap_metadata->hdr_capacity_max);
-    return status;
-  }
   if (sdr_intent->fmt != UHDR_IMG_FMT_24bppYCbCr444 &&
       sdr_intent->fmt != UHDR_IMG_FMT_16bppYCbCr422 &&
       sdr_intent->fmt != UHDR_IMG_FMT_12bppYCbCr420) {
@@ -1175,7 +1336,7 @@ uhdr_error_info_t JpegR::applyGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_ima
   dest->cg = sdr_intent->cg;
   // Table will only be used when map scale factor is integer.
   ShepardsIDW idwTable(static_cast<int>(map_scale_factor));
-  float display_boost = (std::min)(max_display_boost, gainmap_metadata->max_content_boost);
+  float display_boost = (std::min)(max_display_boost, gainmap_metadata->hdr_capacity_max);
   GainLUT gainLUT(gainmap_metadata, display_boost);
 
   GetPixelFn get_pixel_fn = getPixelFn(sdr_intent->fmt);
@@ -1190,11 +1351,14 @@ uhdr_error_info_t JpegR::applyGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_ima
 
   JobQueue jobQueue;
   std::function<void()> applyRecMap = [sdr_intent, gainmap_img, dest, &jobQueue, &idwTable,
-                                       output_ct, &gainLUT, display_boost, map_scale_factor,
-                                       get_pixel_fn]() -> void {
+                                       output_ct, &gainLUT, display_boost,
+#if !USE_APPLY_GAIN_LUT
+                                       gainmap_metadata,
+#endif
+                                       map_scale_factor, get_pixel_fn]() -> void {
     size_t width = sdr_intent->w;
-
     size_t rowStart, rowEnd;
+
     while (jobQueue.dequeueJob(rowStart, rowEnd)) {
       for (size_t y = rowStart; y < rowEnd; ++y) {
         for (size_t x = 0; x < width; ++x) {
@@ -1220,7 +1384,7 @@ uhdr_error_info_t JpegR::applyGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_ima
 #if USE_APPLY_GAIN_LUT
             rgb_hdr = applyGainLUT(rgb_sdr, gain, gainLUT);
 #else
-            rgb_hdr = applyGain(rgb_sdr, gain, metadata, display_boost);
+            rgb_hdr = applyGain(rgb_sdr, gain, gainmap_metadata, display_boost);
 #endif
           } else {
             Color gain;
@@ -1236,7 +1400,7 @@ uhdr_error_info_t JpegR::applyGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_ima
 #if USE_APPLY_GAIN_LUT
             rgb_hdr = applyGainLUT(rgb_sdr, gain, gainLUT);
 #else
-            rgb_hdr = applyGain(rgb_sdr, gain, metadata, display_boost);
+            rgb_hdr = applyGain(rgb_sdr, gain, gainmap_metadata, display_boost);
 #endif
           }
 
@@ -1296,6 +1460,7 @@ uhdr_error_info_t JpegR::applyGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_ima
   jobQueue.markQueueForEnd();
   applyRecMap();
   std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
+
   return g_no_error;
 }
 
@@ -1529,7 +1694,7 @@ uhdr_error_info_t JpegR::toneMap(uhdr_raw_image_t* hdr_intent, uhdr_raw_image_t*
     status.error_code = UHDR_CODEC_UNSUPPORTED_FEATURE;
     status.has_detail = 1;
     snprintf(status.detail, sizeof status.detail,
-             "Did not receive valid maxCLL for display with transfer characteristics %d",
+             "Did not receive valid MDML for display with transfer characteristics %d",
              hdr_intent->ct);
     return status;
   }
diff --git a/lib/src/ultrahdr_api.cpp b/lib/src/ultrahdr_api.cpp
index 701aaba1..0b1dbafa 100644
--- a/lib/src/ultrahdr_api.cpp
+++ b/lib/src/ultrahdr_api.cpp
@@ -529,6 +529,41 @@ UHDR_EXTERN uhdr_error_info_t uhdr_enc_set_gainmap_gamma(uhdr_codec_private_t* e
   return status;
 }
 
+uhdr_error_info_t uhdr_enc_set_preset(uhdr_codec_private_t* enc, uhdr_enc_preset_t preset) {
+  uhdr_error_info_t status = g_no_error;
+
+  if (dynamic_cast<uhdr_encoder_private*>(enc) == nullptr) {
+    status.error_code = UHDR_CODEC_INVALID_PARAM;
+    status.has_detail = 1;
+    snprintf(status.detail, sizeof status.detail, "received nullptr for uhdr codec instance");
+    return status;
+  }
+
+  if (preset != UHDR_USAGE_REALTIME && preset != UHDR_USAGE_BEST_QUALITY) {
+    status.error_code = UHDR_CODEC_INVALID_PARAM;
+    status.has_detail = 1;
+    snprintf(status.detail, sizeof status.detail,
+             "invalid preset %d, expects one of {UHDR_USAGE_REALTIME, UHDR_USAGE_BEST_QUALITY}",
+             preset);
+    return status;
+  }
+
+  uhdr_encoder_private* handle = dynamic_cast<uhdr_encoder_private*>(enc);
+
+  if (handle->m_sailed) {
+    status.error_code = UHDR_CODEC_INVALID_OPERATION;
+    status.has_detail = 1;
+    snprintf(status.detail, sizeof status.detail,
+             "An earlier call to uhdr_encode() has switched the context from configurable state to "
+             "end state. The context is no longer configurable. To reuse, call reset()");
+    return status;
+  }
+
+  handle->m_enc_preset = preset;
+
+  return status;
+}
+
 uhdr_error_info_t uhdr_enc_set_raw_image(uhdr_codec_private_t* enc, uhdr_raw_image_t* img,
                                          uhdr_img_label_t intent) {
   uhdr_error_info_t status = g_no_error;
@@ -984,9 +1019,9 @@ uhdr_error_info_t uhdr_encode(uhdr_codec_private_t* enc) {
       exif.capacity = exif.data_sz = handle->m_exif.size();
     }
 
-    ultrahdr::JpegR jpegr(nullptr, handle->m_gainmap_scale_factor,
-                          handle->m_quality.find(UHDR_GAIN_MAP_IMG)->second,
-                          handle->m_use_multi_channel_gainmap, handle->m_gamma);
+    ultrahdr::JpegR jpegr(
+        nullptr, handle->m_gainmap_scale_factor, handle->m_quality.find(UHDR_GAIN_MAP_IMG)->second,
+        handle->m_use_multi_channel_gainmap, handle->m_gamma, handle->m_enc_preset);
     if (handle->m_compressed_images.find(UHDR_BASE_IMG) != handle->m_compressed_images.end() &&
         handle->m_compressed_images.find(UHDR_GAIN_MAP_IMG) != handle->m_compressed_images.end()) {
       auto& base_entry = handle->m_compressed_images.find(UHDR_BASE_IMG)->second;
@@ -1086,6 +1121,7 @@ void uhdr_reset_encoder(uhdr_codec_private_t* enc) {
     handle->m_gainmap_scale_factor = ultrahdr::kMapDimensionScaleFactorDefault;
     handle->m_use_multi_channel_gainmap = ultrahdr::kUseMultiChannelGainMapDefault;
     handle->m_gamma = ultrahdr::kGainMapGammaDefault;
+    handle->m_enc_preset = UHDR_USAGE_REALTIME;
 
     handle->m_compressed_output_buffer.reset();
     handle->m_encode_call_status = g_no_error;
diff --git a/tests/gainmapmath_test.cpp b/tests/gainmapmath_test.cpp
index 16e85185..9bf9eabf 100644
--- a/tests/gainmapmath_test.cpp
+++ b/tests/gainmapmath_test.cpp
@@ -1132,6 +1132,8 @@ TEST_F(GainMapMathTest, applyGainLUT) {
     metadata.min_content_boost = 1.0f / static_cast<float>(boost);
     metadata.max_content_boost = static_cast<float>(boost);
     metadata.gamma = 1.0f;
+    metadata.hdr_capacity_max = metadata.max_content_boost;
+    metadata.hdr_capacity_min = metadata.min_content_boost;
     GainLUT gainLUT(&metadata);
     GainLUT gainLUTWithBoost(&metadata, metadata.max_content_boost);
     for (size_t idx = 0; idx < kGainFactorNumEntries; idx++) {
@@ -1165,6 +1167,8 @@ TEST_F(GainMapMathTest, applyGainLUT) {
     metadata.min_content_boost = 1.0f;
     metadata.max_content_boost = static_cast<float>(boost);
     metadata.gamma = 1.0f;
+    metadata.hdr_capacity_max = metadata.max_content_boost;
+    metadata.hdr_capacity_min = metadata.min_content_boost;
     GainLUT gainLUT(&metadata);
     GainLUT gainLUTWithBoost(&metadata, metadata.max_content_boost);
     for (size_t idx = 0; idx < kGainFactorNumEntries; idx++) {
@@ -1198,6 +1202,8 @@ TEST_F(GainMapMathTest, applyGainLUT) {
     metadata.min_content_boost = 1.0f / powf(static_cast<float>(boost), 1.0f / 3.0f);
     metadata.max_content_boost = static_cast<float>(boost);
     metadata.gamma = 1.0f;
+    metadata.hdr_capacity_max = metadata.max_content_boost;
+    metadata.hdr_capacity_min = metadata.min_content_boost;
     GainLUT gainLUT(&metadata);
     GainLUT gainLUTWithBoost(&metadata, metadata.max_content_boost);
     for (size_t idx = 0; idx < kGainFactorNumEntries; idx++) {
@@ -1257,64 +1263,59 @@ TEST_F(GainMapMathTest, ColorConversionLookup) {
 }
 
 TEST_F(GainMapMathTest, EncodeGain) {
-  uhdr_gainmap_metadata_ext_t metadata;
-
-  metadata.min_content_boost = 1.0f / 4.0f;
-  metadata.max_content_boost = 4.0f;
-  metadata.gamma = 1.0f;
-
-  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(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.max_content_boost = 2.0f;
-  metadata.min_content_boost = 1.0f / 2.0f;
-
-  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.max_content_boost = 8.0f;
-  metadata.min_content_boost = 1.0f / 8.0f;
-
-  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.max_content_boost = 8.0f;
-  metadata.min_content_boost = 1.0f;
-
-  EXPECT_EQ(encodeGain(0.0f, 0.0f, &metadata), 0);
-  EXPECT_EQ(encodeGain(1.0f, 0.0f, &metadata), 0);
-
-  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.max_content_boost = 8.0f;
-  metadata.min_content_boost = 0.5f;
-
-  EXPECT_EQ(encodeGain(0.0f, 0.0f, &metadata), 63);
-  EXPECT_EQ(encodeGain(1.0f, 0.0f, &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);
+  float min_boost = log2(1.0f / 4.0f);
+  float max_boost = log2(4.0f);
+  float gamma = 1.0f;
+
+  EXPECT_EQ(affineMapGain(computeGain(0.0f, 1.0f), min_boost, max_boost, 1.0f), 128);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 0.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(0.5f, 0.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 1.0), min_boost, max_boost, 1.0f), 128);
+
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 4.0f), min_boost, max_boost, 1.0f), 255);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 5.0f), min_boost, max_boost, 1.0f), 255);
+  EXPECT_EQ(affineMapGain(computeGain(4.0f, 1.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(4.0f, 0.5f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 2.0f), min_boost, max_boost, 1.0f), 191);
+  EXPECT_EQ(affineMapGain(computeGain(2.0f, 1.0f), min_boost, max_boost, 1.0f), 64);
+
+  min_boost = log2(1.0f / 2.0f);
+  max_boost = log2(2.0f);
+
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 2.0f), min_boost, max_boost, 1.0f), 255);
+  EXPECT_EQ(affineMapGain(computeGain(2.0f, 1.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 1.41421f), min_boost, max_boost, 1.0f), 191);
+  EXPECT_EQ(affineMapGain(computeGain(1.41421f, 1.0f), min_boost, max_boost, 1.0f), 64);
+
+  min_boost = log2(1.0f / 8.0f);
+  max_boost = log2(8.0f);
+
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 8.0f), min_boost, max_boost, 1.0f), 255);
+  EXPECT_EQ(affineMapGain(computeGain(8.0f, 1.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 2.82843f), min_boost, max_boost, 1.0f), 191);
+  EXPECT_EQ(affineMapGain(computeGain(2.82843f, 1.0f), min_boost, max_boost, 1.0f), 64);
+
+  min_boost = log2(1.0f);
+  max_boost = log2(8.0f);
+
+  EXPECT_EQ(affineMapGain(computeGain(0.0f, 0.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 0.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 1.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 8.0f), min_boost, max_boost, 1.0f), 255);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 4.0f), min_boost, max_boost, 1.0f), 170);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 2.0f), min_boost, max_boost, 1.0f), 85);
+
+  min_boost = log2(1.0f / 2.0f);
+  max_boost = log2(8.0f);
+
+  EXPECT_EQ(affineMapGain(computeGain(0.0f, 0.0f), min_boost, max_boost, 1.0f), 64);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 0.0f), min_boost, max_boost, 1.0f), 0);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 1.0f), min_boost, max_boost, 1.0f), 64);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 8.0f), min_boost, max_boost, 1.0f), 255);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 4.0f), min_boost, max_boost, 1.0f), 191);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 2.0f), min_boost, max_boost, 1.0f), 128);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 0.7071f), min_boost, max_boost, 1.0f), 32);
+  EXPECT_EQ(affineMapGain(computeGain(1.0f, 0.5f), min_boost, max_boost, 1.0f), 0);
 }
 
 TEST_F(GainMapMathTest, ApplyGain) {
@@ -1322,6 +1323,8 @@ TEST_F(GainMapMathTest, ApplyGain) {
 
   metadata.min_content_boost = 1.0f / 4.0f;
   metadata.max_content_boost = 4.0f;
+  metadata.hdr_capacity_max = metadata.max_content_boost;
+  metadata.hdr_capacity_min = metadata.min_content_boost;
   metadata.gamma = 1.0f;
   float displayBoost = metadata.max_content_boost;
 
@@ -1337,6 +1340,8 @@ TEST_F(GainMapMathTest, ApplyGain) {
 
   metadata.max_content_boost = 2.0f;
   metadata.min_content_boost = 1.0f / 2.0f;
+  metadata.hdr_capacity_max = metadata.max_content_boost;
+  metadata.hdr_capacity_min = metadata.min_content_boost;
 
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite() / 2.0f);
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.25f, &metadata), RgbWhite() / 1.41421f);
@@ -1346,6 +1351,8 @@ TEST_F(GainMapMathTest, ApplyGain) {
 
   metadata.max_content_boost = 8.0f;
   metadata.min_content_boost = 1.0f / 8.0f;
+  metadata.hdr_capacity_max = metadata.max_content_boost;
+  metadata.hdr_capacity_min = metadata.min_content_boost;
 
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite() / 8.0f);
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.25f, &metadata), RgbWhite() / 2.82843f);
@@ -1355,6 +1362,8 @@ TEST_F(GainMapMathTest, ApplyGain) {
 
   metadata.max_content_boost = 8.0f;
   metadata.min_content_boost = 1.0f;
+  metadata.hdr_capacity_max = metadata.max_content_boost;
+  metadata.hdr_capacity_min = metadata.min_content_boost;
 
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite());
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 1.0f / 3.0f, &metadata), RgbWhite() * 2.0f);
@@ -1363,6 +1372,8 @@ TEST_F(GainMapMathTest, ApplyGain) {
 
   metadata.max_content_boost = 8.0f;
   metadata.min_content_boost = 0.5f;
+  metadata.hdr_capacity_max = metadata.max_content_boost;
+  metadata.hdr_capacity_min = metadata.min_content_boost;
 
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.0f, &metadata), RgbWhite() / 2.0f);
   EXPECT_RGB_NEAR(applyGain(RgbWhite(), 0.25f, &metadata), RgbWhite());
@@ -1373,6 +1384,8 @@ TEST_F(GainMapMathTest, ApplyGain) {
   Color e = {{{0.0f, 0.5f, 1.0f}}};
   metadata.max_content_boost = 4.0f;
   metadata.min_content_boost = 1.0f / 4.0f;
+  metadata.hdr_capacity_max = metadata.max_content_boost;
+  metadata.hdr_capacity_min = metadata.min_content_boost;
 
   EXPECT_RGB_NEAR(applyGain(e, 0.0f, &metadata), e / 4.0f);
   EXPECT_RGB_NEAR(applyGain(e, 0.25f, &metadata), e / 2.0f);
diff --git a/ultrahdr_api.h b/ultrahdr_api.h
index 053830ea..e0fafdeb 100644
--- a/ultrahdr_api.h
+++ b/ultrahdr_api.h
@@ -115,6 +115,12 @@ typedef enum uhdr_img_label {
   UHDR_GAIN_MAP_IMG, /**< Gain map image */
 } uhdr_img_label_t;  /**< alias for enum uhdr_img_label */
 
+/*!\brief uhdr encoder usage parameter */
+typedef enum uhdr_enc_preset {
+  UHDR_USAGE_REALTIME,     /**< real time preset */
+  UHDR_USAGE_BEST_QUALITY, /**< best encoding quality preset */
+} uhdr_enc_preset_t;       /**< alias for enum uhdr_img_label */
+
 /*!\brief Algorithm return codes */
 typedef enum uhdr_codec_err {
 
@@ -352,6 +358,17 @@ UHDR_EXTERN uhdr_error_info_t uhdr_enc_set_gainmap_scale_factor(uhdr_codec_priva
  */
 UHDR_EXTERN uhdr_error_info_t uhdr_enc_set_gainmap_gamma(uhdr_codec_private_t* enc, float gamma);
 
+/*!\brief Set encoding preset. Tunes the encoder configurations for performance or quality.
+ *
+ * \param[in]  enc  encoder instance.
+ * \param[in]  preset  encoding preset
+ *
+ * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds,
+ *                           #UHDR_CODEC_INVALID_PARAM otherwise.
+ */
+UHDR_EXTERN uhdr_error_info_t uhdr_enc_set_preset(uhdr_codec_private_t* enc,
+                                                  uhdr_enc_preset_t preset);
+
 /*!\brief Set output image compression format.
  *
  * \param[in]  enc  encoder instance.