From 22eee9787e4ea5c34d19407d66e1ecaf6197bd16 Mon Sep 17 00:00:00 2001
From: rom9 <4711834+rom9@users.noreply.github.com>
Date: Mon, 13 Apr 2020 17:20:56 +0200
Subject: [PATCH] Film negative stable multipliers (#5485)

* Added new feature to calculate channel multipliers from crop area. This also saves the crop area channel medians to the processing profiles, in order to get a more consistent color balance when batch-applying the same profile to multiple pictures from the same film roll.

* Fixed wrong initialization of array, and missing check for the result of `getFilmNegativeMedians()`.
Moved `ImProcCoordinator::translateCoord()` from private member to anonymous namespace.
Fixed some whitespace and formatting issues.

* Fixed some formatting issues

* Passed `ipf` parameter as const in `translateCoord`.
Narrowed `using namespace` to single class `Coord2D`.

* Added `scaleGain` entry to thumbnail metadata file, to make `scale_mul` multipliers available in thumbnail processing phase. This simplifies multiplier calculations, so that "faking" thumbnail multipliers in the main image processing is not necessary anymore. This way, output values are immune to slight variations of multipliers between successive shots taken with in-camera AWB turned on.
Shifted multipliers so that the output channel medians are balanced when "Camera WB" is selected. This way, just computing multipliers from crop and setting "Camera WB" (which is the default) gives a pretty well balanced image as a starting point.

* New channel scaling method, based on a film base color sample instead of crop area channel medians. Channels are scaled so that the converted film base values are equal to 1/512th of the output range (65k). This giver better black levels in the output, and more consistency when batch-processing multiple negatives.
The output is now compensated for a known fixed WB value, so that the film base will appear grey when WB is set to 3500K, Green=1.
Added PPVERSION 347 to preserve backwards compatibility: when a processing profile saved by RT 5.7 is loaded (PPVERSION=346), the new fields are initialized to the special value -1, which will instruct the main processing to follow the old channel scaling behaviour. The old channel scaling multipliers will then be converted to the new film base values so that the resulting image is the same, and the fields will be overwritten as soon as the PP is saved again. This will transparently upgrade the processing profile.
When the new behaviour is used, but the film base values are still unset, they are estimated based on channel medians, excluding a 20% border around the image. This should give a better result out-of-the-box for pictures containing a large film holder.

* Code cleanup from review

* Run astyle on film neg source files

* Fixed automated build failure caused by incompatible libraries on my dev PC.

* Simplified `Thumbnail::processFilmNegative` method signature. There is no need to pass in `rmi`,`gmi`,`bmi` multipliers from the caller, i can do the same with my own internal multipliers.

* Added `FilmNegListener` class to pass estimeted film base values to the GUI after first processing. Removed old `filmBaseValues` instance variable from RawImageSource.

* Code cleanup

* Forgot to set baseValues flag in `PartialPasteDlg::applyPaste`
Fixed `filmBaseValuesLabel` not updating when reading zero baseValues. Normally not needed (the label is updated later by the listener), but when the user is browsing through pictures the listener won't fire, so the label must be updated to show values are unset.

* Overwritten channel scaling multipliers by calling `get_colorsCoeff` with `forceAutoWB=false`.
Initially, in `RawImageSource::load`, channels are auto-balanced by averaging the whole picture when computing multipliers.
This can give different multipliers for multiple shots of the same camera, which will lead to inconsistent conversions when batch-processing multiple negatives.
This commit re-sets `scale_mul`, `ref_pre_mul`, etc., in order to "undo" the auto-WB and use the normal camera multipliers.

* Found an easier way to get stable overall multipliers, removed the (horrible) on-the-fly mutation of scaling instance variables.
---
 rtdata/languages/default      |   4 +
 rtengine/filmnegativeproc.cc  | 345 +++++++++++++++++++++++++---------
 rtengine/filmnegativethumb.cc | 211 ++++++++++++++++-----
 rtengine/imagesource.h        |   3 +-
 rtengine/improccoordinator.cc |  51 +++--
 rtengine/improccoordinator.h  |   7 +
 rtengine/procparams.cc        |  33 +++-
 rtengine/procparams.h         |   4 +
 rtengine/rawimagesource.h     |   3 +-
 rtengine/rtengine.h           |  10 +
 rtengine/rtthumbnail.cc       |  10 +-
 rtengine/rtthumbnail.h        |   3 +-
 rtengine/simpleprocess.cc     |   7 +-
 rtgui/filmnegative.cc         | 164 +++++++++++++---
 rtgui/filmnegative.h          |  16 +-
 rtgui/paramsedited.cc         |  12 +-
 rtgui/paramsedited.h          |   1 +
 rtgui/partialpastedlg.cc      |   1 +
 rtgui/ppversion.h             |   4 +-
 rtgui/toolpanelcoord.cc       |   6 +
 rtgui/toolpanelcoord.h        |   1 +
 21 files changed, 705 insertions(+), 191 deletions(-)

diff --git a/rtdata/languages/default b/rtdata/languages/default
index 64af97689..f33608903 100644
--- a/rtdata/languages/default
+++ b/rtdata/languages/default
@@ -752,6 +752,7 @@ HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
 HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
 HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
 HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
+HISTORY_MSG_FILMNEGATIVE_FILMBASE;Film base color
 HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
 HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
 HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
@@ -1693,6 +1694,9 @@ TP_EXPOSURE_TCMODE_WEIGHTEDSTD;Weighted Standard
 TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
 TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
 TP_FILMNEGATIVE_BLUE;Blue ratio
+TP_FILMNEGATIVE_FILMBASE_PICK;Pick film base color
+TP_FILMNEGATIVE_FILMBASE_TOOLTIP;Pick a spot of unexposed film (eg. the border between frames), to get the actual film base color values, and save them in the processing profile.\nThis makes it easy to get a more consistent color balance when batch-processing multiple pictures from the same roll.\nAlso use this when the converted image is extremely dark, bright, or color-unbalanced.
+TP_FILMNEGATIVE_FILMBASE_VALUES;Film base RGB:
 TP_FILMNEGATIVE_GREEN;Reference exponent (contrast)
 TP_FILMNEGATIVE_GUESS_TOOLTIP;Automatically set the red and blue ratios by picking two patches which had a neutral hue (no color) in the original scene. The patches should differ in brightness. Set the white balance afterwards.
 TP_FILMNEGATIVE_LABEL;Film Negative
diff --git a/rtengine/filmnegativeproc.cc b/rtengine/filmnegativeproc.cc
index c7de3c483..6d4fe1ad6 100644
--- a/rtengine/filmnegativeproc.cc
+++ b/rtengine/filmnegativeproc.cc
@@ -35,6 +35,9 @@
 
 namespace
 {
+using rtengine::ST_BAYER;
+using rtengine::ST_FUJI_XTRANS;
+using rtengine::settings;
 
 bool channelsAvg(
     const rtengine::RawImage* ri,
@@ -43,17 +46,16 @@ bool channelsAvg(
     const float* cblacksom,
     rtengine::Coord spotPos,
     int spotSize,
-    const rtengine::procparams::FilmNegativeParams& params,
     std::array<float, 3>& avgs
 )
 {
     avgs = {}; // Channel averages
 
-    if (ri->getSensorType() != rtengine::ST_BAYER && ri->getSensorType() != rtengine::ST_FUJI_XTRANS) {
+    if (ri->getSensorType() != ST_BAYER && ri->getSensorType() != ST_FUJI_XTRANS) {
         return false;
     }
 
-    if (rtengine::settings->verbose) {
+    if (settings->verbose) {
         printf("Spot coord:  x=%d y=%d\n", spotPos.x, spotPos.y);
     }
 
@@ -69,9 +71,10 @@ bool channelsAvg(
     }
 
     std::array<int, 3> pxCount = {}; // Per-channel sample counts
+
     for (int c = x1; c < x2; ++c) {
         for (int r = y1; r < y2; ++r) {
-            const int ch = ri->getSensorType() == rtengine::ST_BAYER ? ri->FC(r,c) : ri->XTRANSFC(r,c);
+            const int ch = ri->getSensorType() == ST_BAYER ? ri->FC(r, c) : ri->XTRANSFC(r, c);
 
             ++pxCount[ch];
 
@@ -88,6 +91,112 @@ bool channelsAvg(
     return true;
 }
 
+void calcMedians(
+    const rtengine::RawImage* ri,
+    float** data,
+    int x1, int y1, int x2, int y2,
+    std::array<float, 3>& meds
+)
+{
+
+    MyTime t1, t2, t3;
+    t1.set();
+
+    // Channel vectors to calculate medians
+    std::array<std::vector<float>, 3> cvs;
+
+    // Sample one every 5 pixels, and push the value in the appropriate channel vector.
+    // Choose an odd step, not a multiple of the CFA size, to get a chance to visit each channel.
+    if (ri->getSensorType() == ST_BAYER) {
+        for (int row = y1; row < y2; row += 5) {
+            const int c0 = ri->FC(row, x1 + 0);
+            const int c1 = ri->FC(row, x1 + 5);
+            int col = x1;
+
+            for (; col < x2 - 5; col += 10) {
+                cvs[c0].push_back(data[row][col]);
+                cvs[c1].push_back(data[row][col + 5]);
+            }
+
+            if (col < x2) {
+                cvs[c0].push_back(data[row][col]);
+            }
+        }
+    } else if (ri->getSensorType() == ST_FUJI_XTRANS) {
+        for (int row = y1; row < y2; row += 5) {
+            const std::array<unsigned int, 6> cs = {
+                ri->XTRANSFC(row, x1 + 0),
+                ri->XTRANSFC(row, x1 + 5),
+                ri->XTRANSFC(row, x1 + 10),
+                ri->XTRANSFC(row, x1 + 15),
+                ri->XTRANSFC(row, x1 + 20),
+                ri->XTRANSFC(row, x1 + 25)
+            };
+            int col = x1;
+
+            for (; col < x2 - 25; col += 30) {
+                for (int c = 0; c < 6; ++c) {
+                    cvs[cs[c]].push_back(data[row][col + c * 5]);
+                }
+            }
+
+            for (int c = 0; col < x2; col += 5, ++c) {
+                cvs[cs[c]].push_back(data[row][col]);
+            }
+        }
+    }
+
+    t2.set();
+
+    if (settings->verbose) {
+        printf("Median vector fill loop time us: %d\n", t2.etime(t1));
+    }
+
+    t2.set();
+
+    for (int c = 0; c < 3; ++c) {
+        // Find median values for each channel
+        if (!cvs[c].empty()) {
+            rtengine::findMinMaxPercentile(cvs[c].data(), cvs[c].size(), 0.5f, meds[c], 0.5f, meds[c], true);
+        }
+    }
+
+    t3.set();
+
+    if (settings->verbose) {
+        printf("Sample count: R=%zu, G=%zu, B=%zu\n", cvs[0].size(), cvs[1].size(), cvs[2].size());
+        printf("Median calc time us: %d\n", t3.etime(t2));
+    }
+
+}
+
+std::array<double, 3> calcWBMults(
+    const rtengine::ColorTemp& wb,
+    const rtengine::ImageMatrices& imatrices,
+    const rtengine::RawImage *ri,
+    const float ref_pre_mul[4])
+{
+    std::array<double, 3> wb_mul;
+    double r, g, b;
+    wb.getMultipliers(r, g, b);
+    wb_mul[0] = imatrices.cam_rgb[0][0] * r + imatrices.cam_rgb[0][1] * g + imatrices.cam_rgb[0][2] * b;
+    wb_mul[1] = imatrices.cam_rgb[1][0] * r + imatrices.cam_rgb[1][1] * g + imatrices.cam_rgb[1][2] * b;
+    wb_mul[2] = imatrices.cam_rgb[2][0] * r + imatrices.cam_rgb[2][1] * g + imatrices.cam_rgb[2][2] * b;
+
+    for (int c = 0; c < 3; ++c) {
+        wb_mul[c] = ri->get_pre_mul(c) / wb_mul[c] / ref_pre_mul[c];
+    }
+
+    // Normalize max channel gain to 1.0
+    float mg = rtengine::max(wb_mul[0], wb_mul[1], wb_mul[2]);
+
+    for (int c = 0; c < 3; ++c) {
+        wb_mul[c] /= mg;
+    }
+
+    return wb_mul;
+}
+
 }
 
 bool rtengine::RawImageSource::getFilmNegativeExponents(Coord2D spotA, Coord2D spotB, int tran, const procparams::FilmNegativeParams &currentParams, std::array<float, 3>& newExps)
@@ -104,21 +213,29 @@ bool rtengine::RawImageSource::getFilmNegativeExponents(Coord2D spotA, Coord2D s
     std::array<float, 3> clearVals;
     std::array<float, 3> denseVals;
 
+    // Get channel averages in the two spots, sampling from the original ri->data buffer.
+    // NOTE: rawData values might be affected by CA corection, FlatField, etc, so:
+    //   rawData[y][x] == (ri->data[y][x] - cblacksom[c]) * scale_mul[c]
+    // is not always true. To calculate exponents on the exact values, we should keep
+    // a copy of the rawData buffer after preprocessing. Worth the memory waste?
+
     // Sample first spot
     transformPosition(spotA.x, spotA.y, tran, spot.x, spot.y);
-    if (!channelsAvg(ri, W, H, cblacksom, spot, spotSize, currentParams, clearVals)) {
+
+    if (!channelsAvg(ri, W, H, cblacksom, spot, spotSize, clearVals)) {
         return false;
     }
 
     // Sample second spot
     transformPosition(spotB.x, spotB.y, tran, spot.x, spot.y);
-    if (!channelsAvg(ri, W, H, cblacksom, spot, spotSize, currentParams, denseVals)) {
+
+    if (!channelsAvg(ri, W, H, cblacksom, spot, spotSize, denseVals)) {
         return false;
     }
 
     // Detect which one is the dense spot, based on green channel
     if (clearVals[1] < denseVals[1]) {
-      std::swap(clearVals, denseVals);
+        std::swap(clearVals, denseVals);
     }
 
     if (settings->verbose) {
@@ -152,7 +269,32 @@ bool rtengine::RawImageSource::getFilmNegativeExponents(Coord2D spotA, Coord2D s
     return true;
 }
 
-void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativeParams &params)
+bool rtengine::RawImageSource::getRawSpotValues(Coord2D spotCoord, int spotSize, int tran, const procparams::FilmNegativeParams &params, std::array<float, 3>& rawValues)
+{
+    Coord spot;
+    transformPosition(spotCoord.x, spotCoord.y, tran, spot.x, spot.y);
+
+    if (settings->verbose) {
+        printf("Transformed coords: %d,%d\n", spot.x, spot.y);
+    }
+
+    if (spotSize < 4) {
+        return false;
+    }
+
+    // Calculate averages of raw unscaled channels
+    if (!channelsAvg(ri, W, H, cblacksom, spot, spotSize, rawValues)) {
+        return false;
+    }
+
+    if (settings->verbose) {
+        printf("Raw spot values: R=%g, G=%g, B=%g\n", rawValues[0], rawValues[1], rawValues[2]);
+    }
+
+    return true;
+}
+
+void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativeParams &params, std::array<float, 3>& filmBaseValues)
 {
 //    BENCHFUNMICRO
 
@@ -168,92 +310,114 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
         static_cast<float>(-params.blueRatio * params.greenExp)
     };
 
-    MyTime t1, t2, t3,t4, t5;
-
-    t1.set();
-
-    // Channel vectors to calculate medians
-    std::array<std::vector<float>, 3> cvs;
-
-    // Sample one every 5 pixels, and push the value in the appropriate channel vector.
-    // Choose an odd step, not a multiple of the CFA size, to get a chance to visit each channel.
-    if (ri->getSensorType() == ST_BAYER) {
-        for (int row = 0; row < H; row += 5) {
-            const int c0 = ri->FC(row, 0);
-            const int c1 = ri->FC(row, 5);
-            int col = 0;
-            for (; col < W - 5; col += 10) {
-                cvs[c0].push_back(rawData[row][col]);
-                cvs[c1].push_back(rawData[row][col + 5]);
-            }
-            if (col < W) {
-                cvs[c0].push_back(rawData[row][col]);
-            }
-        }
-    }
-    else if (ri->getSensorType() == ST_FUJI_XTRANS) {
-        for (int row = 0; row < H; row += 5) {
-            const std::array<unsigned int, 6> cs = {
-                ri->XTRANSFC(row, 0),
-                ri->XTRANSFC(row, 5),
-                ri->XTRANSFC(row, 10),
-                ri->XTRANSFC(row, 15),
-                ri->XTRANSFC(row, 20),
-                ri->XTRANSFC(row, 25)
-            };
-            int col = 0;
-            for (; col < W - 25; col += 30) {
-                for (int c = 0; c < 6; ++c) {
-                    cvs[cs[c]].push_back(rawData[row][col + c * 5]);
-                }
-            }
-            for (int c = 0; col < W; col += 5, ++c) {
-                cvs[cs[c]].push_back(rawData[row][col]);
-            }
-        }
-    }
-
     constexpr float MAX_OUT_VALUE = 65000.f;
 
-    t2.set();
+    // Get multipliers for a known, fixed WB setting, that will be the starting point
+    // for balancing the converted image.
+    const std::array<double, 3> wb_mul = calcWBMults(
+            ColorTemp(3500., 1., 1., "Custom"), imatrices, ri, ref_pre_mul);
 
-    if (settings->verbose) {
-        printf("Median vector fill loop time us: %d\n", t2.etime(t1));
+
+    if (rtengine::settings->verbose) {
+        printf("Fixed WB mults: %g %g %g\n", wb_mul[0], wb_mul[1], wb_mul[2]);
     }
 
-    t2.set();
+    // Compensation factor to restore the non-autoWB initialGain (see RawImageSource::load)
+    const float autoGainComp = camInitialGain / initialGain;
 
-    std::array<float, 3> medians; // Channel median values
-    std::array<float, 3> mults = {
-        1.f,
-        1.f,
-        1.f
-    };  // Channel normalization multipliers
+    std::array<float, 3> mults;  // Channel normalization multipliers
+
+    // If film base values are set in params, use those
+    if (filmBaseValues[0] <= 0.f) {
+        // ...otherwise, the film negative tool might have just been enabled on this image,
+        // whithout any previous setting. So, estimate film base values from channel medians
+
+        std::array<float, 3> medians;
+
+        // Special value for backwards compatibility with profiles saved by RT 5.7
+        const bool oldChannelScaling = filmBaseValues[0] == -1.f;
+
+        // If using the old channel scaling method, get medians from the whole current image,
+        // reading values from the already-scaled rawData buffer.
+        if (oldChannelScaling) {
+            calcMedians(ri, rawData, 0, 0, W, H, medians);
+        } else {
+            // Cut 20% border from medians calculation. It will probably contain outlier values
+            // from the film holder, which will bias the median result.
+            const int bW = W * 20 / 100;
+            const int bH = H * 20 / 100;
+            calcMedians(ri, rawData, bW, bH, W - bW, H - bH, medians);
+        }
+
+        // Un-scale rawData medians
+        for (int c = 0; c < 3; ++c) {
+            medians[c] /= scale_mul[c];
+        }
+
+        if (settings->verbose) {
+            printf("Channel medians: R=%g, G=%g, B=%g\n", medians[0], medians[1], medians[2]);
+        }
+
+        for (int c = 0; c < 3; ++c) {
+
+            // Estimate film base values, so that in the output data, each channel
+            // median will correspond to 1/24th of MAX.
+            filmBaseValues[c] = pow_F(24.f / 512.f, 1.f / exps[c]) * medians[c];
+
+            if (oldChannelScaling) {
+                // If using the old channel scaling method, apply WB multipliers here to undo their
+                // effect later, since fixed wb compensation was not used in previous version.
+                // Also, undo the effect of the autoGainComp factor (see below).
+                filmBaseValues[c] /= pow_F((wb_mul[c] / autoGainComp), 1.f / exps[c]);// / autoGainComp;
+            }
 
-    for (int c = 0; c < 3; ++c) {
-        // Find median values for each channel
-        if (!cvs[c].empty()) {
-            findMinMaxPercentile(cvs[c].data(), cvs[c].size(), 0.5f, medians[c], 0.5f, medians[c], true);
-            medians[c] = pow_F(rtengine::max(medians[c], 1.f), exps[c]);
-            // Determine the channel multiplier so that N times the median becomes 65k. This clips away
-            // the values in the dark border surrounding the negative (due to the film holder, for example),
-            // the reciprocal of which have blown up to stellar values.
-            mults[c] = MAX_OUT_VALUE / (medians[c] * 24.f);
         }
     }
 
-    t3.set();
+
+    // Calculate multipliers based on previously obtained film base input values.
+
+    // Apply current scaling coefficients to raw, unscaled base values.
+    std::array<float, 3> fb = {
+        filmBaseValues[0] * scale_mul[0],
+        filmBaseValues[1] * scale_mul[1],
+        filmBaseValues[2] * scale_mul[2]
+    };
 
     if (settings->verbose) {
-        printf("Sample count: %zu, %zu, %zu\n", cvs[0].size(), cvs[1].size(), cvs[2].size());
-        printf("Medians: %g %g %g\n", static_cast<double>(medians[0]), static_cast<double>(medians[1]), static_cast<double>(medians[2]));
-        printf("Computed multipliers: %g %g %g\n", static_cast<double>(mults[0]), static_cast<double>(mults[1]), static_cast<double>(mults[2]));
-        printf("Median calc time us: %d\n", t3.etime(t2));
+        printf("Input film base values: %g %g %g\n", fb[0], fb[1], fb[2]);
     }
 
+    for (int c = 0; c < 3; ++c) {
+        // Apply channel exponents, to obtain the corresponding base values in the output data
+        fb[c] = pow_F(rtengine::max(fb[c], 1.f), exps[c]);
+
+        // Determine the channel multiplier so that the film base value is 1/512th of max.
+        mults[c] = (MAX_OUT_VALUE / 512.f) / fb[c];
+
+        // Un-apply the fixed WB multipliers, to reverse their effect later in the WB tool.
+        // This way, the output image will be adapted to this fixed WB setting
+        mults[c] /= wb_mul[c];
+
+        // Also compensate for the initialGain difference between the default scaling (forceAutoWB=true)
+        // and the non-autoWB scaling (see camInitialGain).
+        // This effectively restores camera scaling multipliers, and gives us stable multipliers
+        // (not depending on image content).
+        mults[c] *= autoGainComp;
+
+    }
+
+    if (settings->verbose) {
+        printf("Output film base values: %g %g %g\n", static_cast<double>(fb[0]), static_cast<double>(fb[1]), static_cast<double>(fb[2]));
+        printf("Computed multipliers: %g %g %g\n", static_cast<double>(mults[0]), static_cast<double>(mults[1]), static_cast<double>(mults[2]));
+    }
+
+
     constexpr float CLIP_VAL = 65535.f;
 
-    t3.set();
+    MyTime t1, t2, t3;
+
+    t1.set();
 
     if (ri->getSensorType() == ST_BAYER) {
 #ifdef __SSE2__
@@ -264,6 +428,7 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
 #ifdef _OPENMP
         #pragma omp parallel for schedule(dynamic, 16)
 #endif
+
         for (int row = 0; row < H; ++row) {
             int col = 0;
             // Avoid trouble with zeroes, minimum pixel value is 1.
@@ -274,14 +439,18 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
 #ifdef __SSE2__
             const vfloat expsv = _mm_setr_ps(exps0, exps1, exps0, exps1);
             const vfloat multsv = _mm_setr_ps(mult0, mult1, mult0, mult1);
+
             for (; col < W - 3; col += 4) {
                 STVFU(rawData[row][col], vminf(multsv * pow_F(vmaxf(LVFU(rawData[row][col]), onev), expsv), clipv));
             }
+
 #endif // __SSE2__
+
             for (; col < W - 1; col += 2) {
                 rawData[row][col] = rtengine::min(mult0 * pow_F(rtengine::max(rawData[row][col], 1.f), exps0), CLIP_VAL);
                 rawData[row][col + 1] = rtengine::min(mult1 * pow_F(rtengine::max(rawData[row][col + 1], 1.f), exps1), CLIP_VAL);
             }
+
             if (col < W) {
                 rawData[row][col] = rtengine::min(mult0 * pow_F(rtengine::max(rawData[row][col], 1.f), exps0), CLIP_VAL);
             }
@@ -295,6 +464,7 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
 #ifdef _OPENMP
         #pragma omp parallel for schedule(dynamic, 16)
 #endif
+
         for (int row = 0; row < H; row ++) {
             int col = 0;
             // Avoid trouble with zeroes, minimum pixel value is 1.
@@ -321,30 +491,34 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
             const vfloat multsv0 = _mm_setr_ps(multsc[0], multsc[1], multsc[2], multsc[3]);
             const vfloat multsv1 = _mm_setr_ps(multsc[4], multsc[5], multsc[0], multsc[1]);
             const vfloat multsv2 = _mm_setr_ps(multsc[2], multsc[3], multsc[4], multsc[5]);
+
             for (; col < W - 11; col += 12) {
                 STVFU(rawData[row][col], vminf(multsv0 * pow_F(vmaxf(LVFU(rawData[row][col]), onev), expsv0), clipv));
                 STVFU(rawData[row][col + 4], vminf(multsv1 * pow_F(vmaxf(LVFU(rawData[row][col + 4]), onev), expsv1), clipv));
                 STVFU(rawData[row][col + 8], vminf(multsv2 * pow_F(vmaxf(LVFU(rawData[row][col + 8]), onev), expsv2), clipv));
             }
+
 #endif // __SSE2__
+
             for (; col < W - 5; col += 6) {
                 for (int c = 0; c < 6; ++c) {
                     rawData[row][col + c] = rtengine::min(multsc[c] * pow_F(rtengine::max(rawData[row][col + c], 1.f), expsc[c]), CLIP_VAL);
                 }
             }
+
             for (int c = 0; col < W; col++, c++) {
                 rawData[row][col + c] = rtengine::min(multsc[c] * pow_F(rtengine::max(rawData[row][col + c], 1.f), expsc[c]), CLIP_VAL);
             }
         }
     }
 
-    t4.set();
+    t2.set();
 
     if (settings->verbose) {
-        printf("Pow loop time us: %d\n", t4.etime(t3));
+        printf("Pow loop time us: %d\n", t2.etime(t1));
     }
 
-    t4.set();
+    t2.set();
 
     PixelsMap bitmapBads(W, H);
 
@@ -354,6 +528,7 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
 #ifdef _OPENMP
         #pragma omp parallel for reduction(+:totBP) schedule(dynamic,16)
 #endif
+
         for (int i = 0; i < H; ++i) {
             for (int j = 0; j < W; ++j) {
                 if (rawData[i][j] >= MAX_OUT_VALUE) {
@@ -367,11 +542,11 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
             interpolateBadPixelsBayer(bitmapBads, rawData);
         }
 
-    }
-    else if (ri->getSensorType() == ST_FUJI_XTRANS) {
+    } else if (ri->getSensorType() == ST_FUJI_XTRANS) {
 #ifdef _OPENMP
         #pragma omp parallel for reduction(+:totBP) schedule(dynamic,16)
 #endif
+
         for (int i = 0; i < H; ++i) {
             for (int j = 0; j < W; ++j) {
                 if (rawData[i][j] >= MAX_OUT_VALUE) {
@@ -386,10 +561,10 @@ void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativ
         }
     }
 
-    t5.set();
+    t3.set();
 
     if (settings->verbose) {
         printf("Bad pixels count: %d\n", totBP);
-        printf("Bad pixels interpolation time us: %d\n", t5.etime(t4));
+        printf("Bad pixels interpolation time us: %d\n", t3.etime(t2));
     }
 }
diff --git a/rtengine/filmnegativethumb.cc b/rtengine/filmnegativethumb.cc
index 003fab8e0..57f2601f9 100644
--- a/rtengine/filmnegativethumb.cc
+++ b/rtengine/filmnegativethumb.cc
@@ -18,6 +18,7 @@
  */
 #include <cmath>
 
+#include "colortemp.h"
 #include "LUT.h"
 #include "rtengine.h"
 #include "rtthumbnail.h"
@@ -29,70 +30,179 @@
 #define BENCHMARK
 #include "StopWatch.h"
 
+namespace
+{
+
+using rtengine::Imagefloat;
+using rtengine::findMinMaxPercentile;
+
+
+void calcMedians(
+    const Imagefloat* baseImg,
+    const int x1, const int y1,
+    const int x2, const int y2,
+    float &rmed, float &gmed, float &bmed
+)
+{
+    // Channel vectors to calculate medians
+    std::vector<float> rv, gv, bv;
+
+    const int sz = std::max(0, (y2 - y1) * (x2 - x1));
+    rv.reserve(sz);
+    gv.reserve(sz);
+    bv.reserve(sz);
+
+    for (int i = y1; i < y2; i++) {
+        for (int j = x1; j < x2; j++) {
+            rv.push_back(baseImg->r(i, j));
+            gv.push_back(baseImg->g(i, j));
+            bv.push_back(baseImg->b(i, j));
+        }
+    }
+
+    // Calculate channel medians from whole image
+    findMinMaxPercentile(rv.data(), rv.size(), 0.5f, rmed, 0.5f, rmed, true);
+    findMinMaxPercentile(gv.data(), gv.size(), 0.5f, gmed, 0.5f, gmed, true);
+    findMinMaxPercentile(bv.data(), bv.size(), 0.5f, bmed, 0.5f, bmed, true);
+}
+
+}
+
 void rtengine::Thumbnail::processFilmNegative(
     const procparams::ProcParams &params,
     const Imagefloat* baseImg,
-    const int rwidth, const int rheight,
-    float &rmi, float &gmi, float &bmi
-) {
+    const int rwidth, const int rheight
+)
+{
 
     // Channel exponents
     const float rexp = -params.filmNegative.redRatio * params.filmNegative.greenExp;
     const float gexp = -params.filmNegative.greenExp;
     const float bexp = -params.filmNegative.blueRatio * params.filmNegative.greenExp;
 
-    // Need to calculate channel averages, to fake the same conditions
-    // found in rawimagesource, where get_ColorsCoeff is called with
-    // forceAutoWB=true.
-    float rsum = 0.f, gsum = 0.f, bsum = 0.f;
-
-    // Channel vectors to calculate medians
-    std::vector<float> rv, gv, bv;
-
-    for (int i = 0; i < rheight; i++) {
-        for (int j = 0; j < rwidth; j++) {
-            const float r = baseImg->r(i, j);
-            const float g = baseImg->g(i, j);
-            const float b = baseImg->b(i, j);
-
-            rsum += r;
-            gsum += g;
-            bsum += b;
-
-            rv.push_back(r);
-            gv.push_back(g);
-            bv.push_back(b);
-        }
-    }
-
-    const float ravg = rsum / (rheight*rwidth);
-    const float gavg = gsum / (rheight*rwidth);
-    const float bavg = bsum / (rheight*rwidth);
-
-    // Shifting current WB multipliers, based on channel averages.
-    rmi /= (gavg/ravg);
-    // gmi /= (gAvg/gAvg);  green chosen as reference channel
-    bmi /= (gavg/bavg);
-
-    float rmed, gmed, bmed;
-    findMinMaxPercentile(rv.data(), rv.size(), 0.5f, rmed, 0.5f, rmed, true);
-    findMinMaxPercentile(gv.data(), gv.size(), 0.5f, gmed, 0.5f, gmed, true);
-    findMinMaxPercentile(bv.data(), bv.size(), 0.5f, bmed, 0.5f, bmed, true);
-
-    rmed = powf(rmed, rexp);
-    gmed = powf(gmed, gexp);
-    bmed = powf(bmed, bexp);
+    // Calculate output multipliers
+    float rmult, gmult, bmult;
 
     const float MAX_OUT_VALUE = 65000.f;
-    const float rmult = (MAX_OUT_VALUE / (rmed * 24)) ;
-    const float gmult = (MAX_OUT_VALUE / (gmed * 24)) ;
-    const float bmult = (MAX_OUT_VALUE / (bmed * 24)) ;
+
+    // For backwards compatibility with profiles saved by RT 5.7
+    const bool oldChannelScaling = params.filmNegative.redBase == -1.f;
+
+    // If the film base values are not set in params, estimate multipliers from each channel's median value.
+    if (params.filmNegative.redBase <= 0.f) {
+
+        // Channel medians
+        float rmed, gmed, bmed;
+
+        if (oldChannelScaling) {
+            // If using the old method, calculate nedians on the whole image
+            calcMedians(baseImg, 0, 0, rwidth, rheight, rmed, gmed, bmed);
+        } else {
+            // The new method cuts out a 20% border from medians calculation.
+            const int bW = rwidth * 20 / 100;
+            const int bH = rheight * 20 / 100;
+            calcMedians(baseImg, bW, bH, rwidth - bW, rheight - bH, rmed, gmed, bmed);
+        }
+
+        if (settings->verbose) {
+            printf("Thumbnail input channel medians: %g %g %g\n", rmed, gmed, bmed);
+        }
+
+        // Calculate output medians
+        rmed = powf(rmed, rexp);
+        gmed = powf(gmed, gexp);
+        bmed = powf(bmed, bexp);
+
+        // Calculate output multipliers so that the median value is 1/24 of the output range.
+        rmult = (MAX_OUT_VALUE / 24.f) / rmed;
+        gmult = (MAX_OUT_VALUE / 24.f) / gmed;
+        bmult = (MAX_OUT_VALUE / 24.f) / bmed;
+
+    } else {
+
+        // Read film-base values from params
+        float rbase = params.filmNegative.redBase;
+        float gbase = params.filmNegative.greenBase;
+        float bbase = params.filmNegative.blueBase;
+
+        // Reconstruct scale_mul coefficients from thumbnail metadata:
+        //   redMultiplier / camwbRed is pre_mul[0]
+        //   pre_mul[0] * scaleGain is scale_mul[0]
+        // Apply channel scaling to raw (unscaled) input base values, to
+        // match with actual (scaled) data in baseImg
+        rbase *= (redMultiplier / camwbRed)     * scaleGain;
+        gbase *= (greenMultiplier / camwbGreen) * scaleGain;
+        bbase *= (blueMultiplier / camwbBlue)   * scaleGain;
+
+        if (settings->verbose) {
+            printf("Thumbnail input film base values: %g %g %g\n", rbase, gbase, bbase);
+        }
+
+        // Apply exponents to get output film base values
+        rbase = powf(rbase, rexp);
+        gbase = powf(gbase, gexp);
+        bbase = powf(bbase, bexp);
+
+        if (settings->verbose) {
+            printf("Thumbnail output film base values: %g %g %g\n", rbase, gbase, bbase);
+        }
+
+        // Calculate multipliers so that film base value is 1/512th of the output range.
+        rmult = (MAX_OUT_VALUE / 512.f) / rbase;
+        gmult = (MAX_OUT_VALUE / 512.f) / gbase;
+        bmult = (MAX_OUT_VALUE / 512.f) / bbase;
+
+    }
+
+
+    if (oldChannelScaling) {
+        // Need to calculate channel averages, to fake the same conditions
+        // found in rawimagesource, where get_ColorsCoeff is called with
+        // forceAutoWB=true.
+        float rsum = 0.f, gsum = 0.f, bsum = 0.f;
+
+        for (int i = 0; i < rheight; i++) {
+            for (int j = 0; j < rwidth; j++) {
+                rsum += baseImg->r(i, j);
+                gsum += baseImg->g(i, j);
+                bsum += baseImg->b(i, j);
+            }
+        }
+
+        const float ravg = rsum / (rheight * rwidth);
+        const float gavg = gsum / (rheight * rwidth);
+        const float bavg = bsum / (rheight * rwidth);
+
+        // Shifting current WB multipliers, based on channel averages.
+        rmult /= gavg / ravg;
+        // gmult /= gAvg / gAvg;  green chosen as reference channel
+        bmult /= gavg / bavg;
+
+    } else {
+
+        // Get and un-apply multipliers to adapt the thumbnail to a known fixed WB setting,
+        // as in the main image processing.
+
+        double r, g, b;
+        ColorTemp(3500., 1., 1., "Custom").getMultipliers(r, g, b);
+        //iColorMatrix is cam_rgb
+        const double rm = camwbRed   / (iColorMatrix[0][0] * r + iColorMatrix[0][1] * g + iColorMatrix[0][2] * b);
+        const double gm = camwbGreen / (iColorMatrix[1][0] * r + iColorMatrix[1][1] * g + iColorMatrix[1][2] * b);
+        const double bm = camwbBlue  / (iColorMatrix[2][0] * r + iColorMatrix[2][1] * g + iColorMatrix[2][2] * b);
+
+        // Normalize max WB multiplier to 1.f
+        const double m = max(rm, gm, bm);
+        rmult /= rm / m;
+        gmult /= gm / m;
+        bmult /= bm / m;
+    }
+
 
     if (settings->verbose) {
-        printf("Thumbnail channel medians: %g %g %g\n", static_cast<double>(rmed), static_cast<double>(gmed), static_cast<double>(bmed));
         printf("Thumbnail computed multipliers: %g %g %g\n", static_cast<double>(rmult), static_cast<double>(gmult), static_cast<double>(bmult));
     }
 
+
 #ifdef __SSE2__
     const vfloat clipv = F2V(MAXVALF);
     const vfloat rexpv = F2V(rexp);
@@ -109,12 +219,15 @@ void rtengine::Thumbnail::processFilmNegative(
         float *bline = baseImg->b(i);
         int j = 0;
 #ifdef __SSE2__
-        for (; j < rwidth - 3; j +=4) {
+
+        for (; j < rwidth - 3; j += 4) {
             STVFU(rline[j], vminf(rmultv * pow_F(LVFU(rline[j]), rexpv), clipv));
             STVFU(gline[j], vminf(gmultv * pow_F(LVFU(gline[j]), gexpv), clipv));
             STVFU(bline[j], vminf(bmultv * pow_F(LVFU(bline[j]), bexpv), clipv));
         }
+
 #endif
+
         for (; j < rwidth; ++j) {
             rline[j] = CLIP(rmult * pow_F(rline[j], rexp));
             gline[j] = CLIP(gmult * pow_F(gline[j], gexp));
diff --git a/rtengine/imagesource.h b/rtengine/imagesource.h
index d1008837d..ea049d37c 100644
--- a/rtengine/imagesource.h
+++ b/rtengine/imagesource.h
@@ -92,8 +92,9 @@ public:
     ~ImageSource            () override {}
     virtual int         load        (const Glib::ustring &fname) = 0;
     virtual void        preprocess  (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) {};
-    virtual void        filmNegativeProcess (const procparams::FilmNegativeParams &params) {};
+    virtual void        filmNegativeProcess (const procparams::FilmNegativeParams &params, std::array<float, 3>& filmBaseValues) {};
     virtual bool        getFilmNegativeExponents (Coord2D spotA, Coord2D spotB, int tran, const procparams::FilmNegativeParams& currentParams, std::array<float, 3>& newExps) { return false; };
+    virtual bool        getRawSpotValues (Coord2D spot, int spotSize, int tran, const procparams::FilmNegativeParams &params, std::array<float, 3>& rawValues) { return false; };
     virtual void        demosaic    (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold, bool cache = false) {};
     virtual void        retinex       (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &deh, const procparams::ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) {};
     virtual void        retinexPrepareCurves       (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) {};
diff --git a/rtengine/improccoordinator.cc b/rtengine/improccoordinator.cc
index 6374cb837..f68616b96 100644
--- a/rtengine/improccoordinator.cc
+++ b/rtengine/improccoordinator.cc
@@ -44,6 +44,22 @@
 #include <omp.h>
 #endif
 
+namespace
+{
+using rtengine::Coord2D;
+Coord2D translateCoord(const rtengine::ImProcFunctions& ipf, int fw, int fh, int x, int y) {
+
+    const std::vector<Coord2D> points = {Coord2D(x, y)};
+
+    std::vector<Coord2D> red;
+    std::vector<Coord2D> green;
+    std::vector<Coord2D> blue;
+    ipf.transCoord(fw, fh, points, red, green, blue);
+
+    return green[0];
+}
+
+}
 
 namespace rtengine
 {
@@ -300,7 +316,15 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
                 )
                 && params->filmNegative.enabled
             ) {
-                imgsrc->filmNegativeProcess(params->filmNegative);
+                std::array<float, 3> filmBaseValues = {
+                    static_cast<float>(params->filmNegative.redBase),
+                    static_cast<float>(params->filmNegative.greenBase),
+                    static_cast<float>(params->filmNegative.blueBase)
+                };
+                imgsrc->filmNegativeProcess(params->filmNegative, filmBaseValues);
+                if (filmNegListener && params->filmNegative.redBase <= 0.f) {
+                    filmNegListener->filmBaseValuesChanged(filmBaseValues);
+                }
             }
         }
 
@@ -1481,27 +1505,22 @@ bool ImProcCoordinator::getFilmNegativeExponents(int xA, int yA, int xB, int yB,
 {
     MyMutex::MyLock lock(mProcessing);
 
-    const auto xlate =
-        [this](int x, int y) -> Coord2D
-        {
-            const std::vector<Coord2D> points = {Coord2D(x, y)};
-
-            std::vector<Coord2D> red;
-            std::vector<Coord2D> green;
-            std::vector<Coord2D> blue;
-            ipf.transCoord(fw, fh, points, red, green, blue);
-
-            return green[0];
-        };
-
     const int tr = getCoarseBitMask(params->coarse);
 
-    const Coord2D p1 = xlate(xA, yA);
-    const Coord2D p2 = xlate(xB, yB);
+    const Coord2D p1 = translateCoord(ipf, fw, fh, xA, yA);
+    const Coord2D p2 = translateCoord(ipf, fw, fh, xB, yB);
 
     return imgsrc->getFilmNegativeExponents(p1, p2, tr, params->filmNegative, newExps);
 }
 
+bool ImProcCoordinator::getRawSpotValues(int x, int y, int spotSize, std::array<float, 3>& rawValues)
+{
+    MyMutex::MyLock lock(mProcessing);
+
+    return imgsrc->getRawSpotValues(translateCoord(ipf, fw, fh, x, y), spotSize,
+        getCoarseBitMask(params->coarse), params->filmNegative, rawValues);
+}
+
 void ImProcCoordinator::getAutoCrop(double ratio, int &x, int &y, int &w, int &h)
 {
 
diff --git a/rtengine/improccoordinator.h b/rtengine/improccoordinator.h
index d7d6052e9..e17d88183 100644
--- a/rtengine/improccoordinator.h
+++ b/rtengine/improccoordinator.h
@@ -175,6 +175,7 @@ protected:
     AutoRadiusListener *pdSharpenAutoRadiusListener;
     FrameCountListener *frameCountListener;
     ImageTypeListener *imageTypeListener;
+    FilmNegListener *filmNegListener;
 
     AutoColorTonListener* actListener;
     AutoChromaListener* adnListener;
@@ -281,6 +282,7 @@ public:
     void getCamWB    (double& temp, double& green) override;
     void getSpotWB   (int x, int y, int rectSize, double& temp, double& green) override;
     bool getFilmNegativeExponents(int xA, int yA, int xB, int yB, std::array<float, 3>& newExps) override;
+    bool getRawSpotValues(int x, int y, int spotSize, std::array<float, 3>& rawValues) override;
     void getAutoCrop (double ratio, int &x, int &y, int &w, int &h) override;
     bool getHighQualComputed() override;
     void setHighQualComputed() override;
@@ -389,6 +391,11 @@ public:
         imageTypeListener = itl;
     }
 
+    void setFilmNegListener  (FilmNegListener* fnl) override
+    {
+        filmNegListener = fnl;
+    }
+
     void saveInputICCReference (const Glib::ustring& fname, bool apply_wb) override;
 
     InitialImage*  getInitialImage () override
diff --git a/rtengine/procparams.cc b/rtengine/procparams.cc
index b02f1970c..a198a6813 100644
--- a/rtengine/procparams.cc
+++ b/rtengine/procparams.cc
@@ -2890,7 +2890,10 @@ FilmNegativeParams::FilmNegativeParams() :
     enabled(false),
     redRatio(1.36),
     greenExp(1.5),
-    blueRatio(0.86)
+    blueRatio(0.86),
+    redBase(0),
+    greenBase(0),
+    blueBase(0)
 {
 }
 
@@ -2898,9 +2901,12 @@ bool FilmNegativeParams::operator ==(const FilmNegativeParams& other) const
 {
     return
         enabled == other.enabled
-        && redRatio   == other.redRatio
+        && redRatio == other.redRatio
         && greenExp == other.greenExp
-        && blueRatio  == other.blueRatio;
+        && blueRatio == other.blueRatio
+        && redBase == other.redBase
+        && greenBase == other.greenBase
+        && blueBase == other.blueBase;
 }
 
 bool FilmNegativeParams::operator !=(const FilmNegativeParams& other) const
@@ -3789,6 +3795,9 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
         saveToKeyfile(!pedited || pedited->filmNegative.redRatio, "Film Negative", "RedRatio", filmNegative.redRatio, keyFile);
         saveToKeyfile(!pedited || pedited->filmNegative.greenExp, "Film Negative", "GreenExponent", filmNegative.greenExp, keyFile);
         saveToKeyfile(!pedited || pedited->filmNegative.blueRatio, "Film Negative", "BlueRatio", filmNegative.blueRatio, keyFile);
+        saveToKeyfile(!pedited || pedited->filmNegative.baseValues, "Film Negative", "RedBase", filmNegative.redBase, keyFile);
+        saveToKeyfile(!pedited || pedited->filmNegative.baseValues, "Film Negative", "GreenBase", filmNegative.greenBase, keyFile);
+        saveToKeyfile(!pedited || pedited->filmNegative.baseValues, "Film Negative", "BlueBase", filmNegative.blueBase, keyFile);
 
 // EXIF change list
         if (!pedited || pedited->exif) {
@@ -5386,6 +5395,24 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
             assignFromKeyfile(keyFile, "Film Negative", "RedRatio", pedited, filmNegative.redRatio, pedited->filmNegative.redRatio);
             assignFromKeyfile(keyFile, "Film Negative", "GreenExponent", pedited, filmNegative.greenExp, pedited->filmNegative.greenExp);
             assignFromKeyfile(keyFile, "Film Negative", "BlueRatio", pedited, filmNegative.blueRatio, pedited->filmNegative.blueRatio);
+            if (ppVersion >= 347) {
+                bool r, g, b;
+                assignFromKeyfile(keyFile, "Film Negative", "RedBase", pedited, filmNegative.redBase, r);
+                assignFromKeyfile(keyFile, "Film Negative", "GreenBase", pedited, filmNegative.greenBase, g);
+                assignFromKeyfile(keyFile, "Film Negative", "BlueBase", pedited, filmNegative.blueBase, b);
+                if (pedited) {
+                    pedited->filmNegative.baseValues = r || g || b;
+                }
+            } else {
+                // Backwards compatibility with film negative in RT 5.7: use special film base value -1,
+                // to signal that the old channel scaling method should be used.
+                filmNegative.redBase = -1.f;
+                filmNegative.greenBase = -1.f;
+                filmNegative.blueBase = -1.f;
+                if (pedited) {
+                    pedited->filmNegative.baseValues = true;
+                }
+            }
         }
 
         if (keyFile.has_group("MetaData")) {
diff --git a/rtengine/procparams.h b/rtengine/procparams.h
index 4e2b0c275..f9710b01d 100644
--- a/rtengine/procparams.h
+++ b/rtengine/procparams.h
@@ -1559,6 +1559,10 @@ struct FilmNegativeParams {
     double greenExp;
     double blueRatio;
 
+    double redBase;
+    double greenBase;
+    double blueBase;
+    
     FilmNegativeParams();
 
     bool operator ==(const FilmNegativeParams& other) const;
diff --git a/rtengine/rawimagesource.h b/rtengine/rawimagesource.h
index 71478fbed..770c18ae3 100644
--- a/rtengine/rawimagesource.h
+++ b/rtengine/rawimagesource.h
@@ -124,8 +124,9 @@ public:
     int load(const Glib::ustring &fname) override { return load(fname, false); }
     int load(const Glib::ustring &fname, bool firstFrameOnly);
     void        preprocess  (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) override;
-    void        filmNegativeProcess (const procparams::FilmNegativeParams &params) override;
+    void        filmNegativeProcess (const procparams::FilmNegativeParams &params, std::array<float, 3>& filmBaseValues) override;
     bool        getFilmNegativeExponents (Coord2D spotA, Coord2D spotB, int tran, const procparams::FilmNegativeParams &currentParams, std::array<float, 3>& newExps) override;
+    bool        getRawSpotValues(Coord2D spot, int spotSize, int tran, const procparams::FilmNegativeParams &params, std::array<float, 3>& rawValues) override;
     void        demosaic    (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold, bool cache = false) override;
     void        retinex       (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &deh, const procparams::ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) override;
     void        retinexPrepareCurves       (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) override;
diff --git a/rtengine/rtengine.h b/rtengine/rtengine.h
index e6074d50b..028cedec9 100644
--- a/rtengine/rtengine.h
+++ b/rtengine/rtengine.h
@@ -439,6 +439,13 @@ public:
 
 };
 
+class FilmNegListener
+{
+public:
+    virtual ~FilmNegListener() = default;
+    virtual void filmBaseValuesChanged(std::array<float, 3> rgb) = 0;
+};
+
 /** This class represents a detailed part of the image (looking through a kind of window).
   * It can be created and destroyed with the appropriate members of StagedImageProcessor.
   * Several crops can be assigned to the same image.   */
@@ -524,6 +531,8 @@ public:
     virtual void        getCamWB    (double& temp, double& green) = 0;
     virtual void        getSpotWB  (int x, int y, int rectSize, double& temp, double& green) = 0;
     virtual bool        getFilmNegativeExponents(int xA, int yA, int xB, int yB, std::array<float, 3>& newExps) = 0;
+    virtual bool        getRawSpotValues  (int x, int y, int spotSize, std::array<float, 3>& rawValues) = 0;
+
     virtual void        getAutoCrop (double ratio, int &x, int &y, int &w, int &h) = 0;
 
     virtual void        saveInputICCReference (const Glib::ustring& fname, bool apply_wb) = 0;
@@ -548,6 +557,7 @@ public:
     virtual void        setRetinexListener      (RetinexListener* l) = 0;
     virtual void        setWaveletListener      (WaveletListener* l) = 0;
     virtual void        setImageTypeListener    (ImageTypeListener* l) = 0;
+    virtual void        setFilmNegListener      (FilmNegListener* l) = 0;
 
     virtual void        setMonitorProfile       (const Glib::ustring& monitorProfile, RenderingIntent intent) = 0;
     virtual void        getMonitorProfile       (Glib::ustring& monitorProfile, RenderingIntent& intent) const = 0;
diff --git a/rtengine/rtthumbnail.cc b/rtengine/rtthumbnail.cc
index a063d965b..e8126be36 100644
--- a/rtengine/rtthumbnail.cc
+++ b/rtengine/rtthumbnail.cc
@@ -594,6 +594,8 @@ Thumbnail* Thumbnail::loadFromRaw (const Glib::ustring& fname, RawMetaDataLocati
     tpp->defGain = max (scale_mul[0], scale_mul[1], scale_mul[2], scale_mul[3]) / min (scale_mul[0], scale_mul[1], scale_mul[2], scale_mul[3]);
     tpp->defGain *= std::pow(2, ri->getBaselineExposure());
 
+    tpp->scaleGain = scale_mul[0] / pre_mul[0]; // used to reconstruct scale_mul from filmnegativethumb.cc
+
     tpp->gammaCorrected = true;
 
     unsigned filter = ri->get_filters();
@@ -1042,6 +1044,7 @@ Thumbnail::Thumbnail () :
     scaleForSave (8192),
     gammaCorrected (false),
     colorMatrix{},
+    scaleGain (1.0),
     isRaw (true)
 {
 }
@@ -1179,7 +1182,7 @@ IImage8* Thumbnail::processImage (const procparams::ProcParams& params, eSensorT
     Imagefloat* baseImg = resizeTo<Imagefloat> (rwidth, rheight, interp, thumbImg);
 
     if (isRaw && params.filmNegative.enabled) {
-        processFilmNegative(params, baseImg, rwidth, rheight, rmi, gmi, bmi);
+        processFilmNegative(params, baseImg, rwidth, rheight);
     }
 
     if (params.coarse.rotate) {
@@ -2122,6 +2125,10 @@ bool Thumbnail::readData  (const Glib::ustring& fname)
                         colorMatrix[i][j] = cm[ix++];
                     }
             }
+            
+            if (keyFile.has_key ("LiveThumbData", "ScaleGain")) {
+                scaleGain           = keyFile.get_double ("LiveThumbData", "ScaleGain");
+            }
         }
 
         return true;
@@ -2173,6 +2180,7 @@ bool Thumbnail::writeData  (const Glib::ustring& fname)
         keyFile.set_boolean ("LiveThumbData", "GammaCorrected", gammaCorrected);
         Glib::ArrayHandle<double> cm ((double*)colorMatrix, 9, Glib::OWNERSHIP_NONE);
         keyFile.set_double_list ("LiveThumbData", "ColorMatrix", cm);
+        keyFile.set_double  ("LiveThumbData", "ScaleGain", scaleGain);
 
         keyData = keyFile.to_data ();
 
diff --git a/rtengine/rtthumbnail.h b/rtengine/rtthumbnail.h
index ccca1c582..a0033d35f 100644
--- a/rtengine/rtthumbnail.h
+++ b/rtengine/rtthumbnail.h
@@ -75,8 +75,9 @@ class Thumbnail
     int scaleForSave;
     bool gammaCorrected;
     double colorMatrix[3][3];
+    double scaleGain;
 
-    void processFilmNegative(const procparams::ProcParams& params, const Imagefloat* baseImg, int rwidth, int rheight, float &rmi, float &gmi, float &bmi);
+    void processFilmNegative(const procparams::ProcParams& params, const Imagefloat* baseImg, int rwidth, int rheight);
 
 public:
 
diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc
index 14df16550..14a594ac2 100644
--- a/rtengine/simpleprocess.cc
+++ b/rtengine/simpleprocess.cc
@@ -221,7 +221,12 @@ private:
 
         // After preprocess, run film negative processing if enabled
         if ((imgsrc->getSensorType() == ST_BAYER || (imgsrc->getSensorType() == ST_FUJI_XTRANS)) && params.filmNegative.enabled) {
-            imgsrc->filmNegativeProcess (params.filmNegative);
+            std::array<float, 3> filmBaseValues = {
+                static_cast<float>(params.filmNegative.redBase),
+                static_cast<float>(params.filmNegative.greenBase),
+                static_cast<float>(params.filmNegative.blueBase)
+            };
+            imgsrc->filmNegativeProcess (params.filmNegative, filmBaseValues);
         }
 
         if (pl) {
diff --git a/rtgui/filmnegative.cc b/rtgui/filmnegative.cc
index 90cedf148..1b105a3ec 100644
--- a/rtgui/filmnegative.cc
+++ b/rtgui/filmnegative.cc
@@ -44,6 +44,17 @@ Adjuster* createExponentAdjuster(AdjusterListener* listener, const Glib::ustring
     return adj;
 }
 
+Glib::ustring formatBaseValues(const std::array<float, 3>& rgb)
+{
+    if (rgb[0] <= 0.f && rgb[1] <= 0.f && rgb[2] <= 0.f) {
+        return "- - -";
+    } else {
+        return Glib::ustring::format(std::fixed, std::setprecision(1), rgb[0]) + " " +
+               Glib::ustring::format(std::fixed, std::setprecision(1), rgb[1]) + " " +
+               Glib::ustring::format(std::fixed, std::setprecision(1), rgb[2]);
+    }
+}
+
 }
 
 FilmNegative::FilmNegative() :
@@ -51,12 +62,17 @@ FilmNegative::FilmNegative() :
     EditSubscriber(ET_OBJECTS),
     evFilmNegativeExponents(ProcEventMapper::getInstance()->newEvent(FIRST, "HISTORY_MSG_FILMNEGATIVE_VALUES")),
     evFilmNegativeEnabled(ProcEventMapper::getInstance()->newEvent(FIRST, "HISTORY_MSG_FILMNEGATIVE_ENABLED")),
+    evFilmBaseValues(ProcEventMapper::getInstance()->newEvent(FIRST, "HISTORY_MSG_FILMNEGATIVE_FILMBASE")),
+    filmBaseValues({0.f, 0.f, 0.f}),
     fnp(nullptr),
     greenExp(createExponentAdjuster(this, M("TP_FILMNEGATIVE_GREEN"), 0.3, 4, 1.5)),  // master exponent (green channel)
     redRatio(createExponentAdjuster(this, M("TP_FILMNEGATIVE_RED"), 0.3, 3, (2.04 / 1.5))), // ratio of red exponent to master exponent
     blueRatio(createExponentAdjuster(this, M("TP_FILMNEGATIVE_BLUE"), 0.3, 3, (1.29 / 1.5))), // ratio of blue exponent to master exponent
     spotgrid(Gtk::manage(new Gtk::Grid())),
-    spotbutton(Gtk::manage(new Gtk::ToggleButton(M("TP_FILMNEGATIVE_PICK"))))
+    spotbutton(Gtk::manage(new Gtk::ToggleButton(M("TP_FILMNEGATIVE_PICK")))),
+    filmBaseLabel(Gtk::manage(new Gtk::Label(M("TP_FILMNEGATIVE_FILMBASE_VALUES"), Gtk::ALIGN_START))),
+    filmBaseValuesLabel(Gtk::manage(new Gtk::Label("- - -"))),
+    filmBaseSpotButton(Gtk::manage(new Gtk::ToggleButton(M("TP_FILMNEGATIVE_FILMBASE_PICK"))))
 {
     spotgrid->get_style_context()->add_class("grid-spacing");
     setExpandAlignProperties(spotgrid, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
@@ -64,7 +80,10 @@ FilmNegative::FilmNegative() :
     setExpandAlignProperties(spotbutton, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
     spotbutton->get_style_context()->add_class("independent");
     spotbutton->set_tooltip_text(M("TP_FILMNEGATIVE_GUESS_TOOLTIP"));
-    spotbutton->set_image (*Gtk::manage (new RTImage ("color-picker-small.png")));
+    spotbutton->set_image(*Gtk::manage(new RTImage("color-picker-small.png")));
+
+    filmBaseSpotButton->set_tooltip_text(M("TP_FILMNEGATIVE_FILMBASE_TOOLTIP"));
+    setExpandAlignProperties(filmBaseValuesLabel, false, false, Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
 
     // TODO make spot size configurable ?
 
@@ -81,7 +100,7 @@ FilmNegative::FilmNegative() :
     // spotsize->set_active(0);
     // spotsize->append ("4");
 
-    spotgrid->attach (*spotbutton, 0, 1, 1, 1);
+    spotgrid->attach(*spotbutton, 0, 1, 1, 1);
     // spotgrid->attach (*slab, 1, 0, 1, 1);
     // spotgrid->attach (*wbsizehelper, 2, 0, 1, 1);
 
@@ -90,13 +109,26 @@ FilmNegative::FilmNegative() :
     pack_start(*blueRatio, Gtk::PACK_SHRINK, 0);
     pack_start(*spotgrid, Gtk::PACK_SHRINK, 0);
 
+    Gtk::HSeparator* const sep = Gtk::manage(new  Gtk::HSeparator());
+    sep->get_style_context()->add_class("grid-row-separator");
+    pack_start(*sep, Gtk::PACK_SHRINK, 0);
+
+    Gtk::Grid* const fbGrid = Gtk::manage(new Gtk::Grid());
+    fbGrid->attach(*filmBaseLabel, 0, 0, 1, 1);
+    fbGrid->attach(*filmBaseValuesLabel, 1, 0, 1, 1);
+    pack_start(*fbGrid, Gtk::PACK_SHRINK, 0);
+
+    pack_start(*filmBaseSpotButton, Gtk::PACK_SHRINK, 0);
+
     spotbutton->signal_toggled().connect(sigc::mem_fun(*this, &FilmNegative::editToggled));
     // spotsize->signal_changed().connect( sigc::mem_fun(*this, &WhiteBalance::spotSizeChanged) );
 
+    filmBaseSpotButton->signal_toggled().connect(sigc::mem_fun(*this, &FilmNegative::baseSpotToggled));
+
     // Editing geometry; create the spot rectangle
     Rectangle* const spotRect = new Rectangle();
     spotRect->filled = false;
-    
+
     visibleGeometry.push_back(spotRect);
 
     // Stick a dummy rectangle over the whole image in mouseOverGeometry.
@@ -134,6 +166,14 @@ void FilmNegative::read(const rtengine::procparams::ProcParams* pp, const Params
     greenExp->setValue(pp->filmNegative.greenExp);
     blueRatio->setValue(pp->filmNegative.blueRatio);
 
+    filmBaseValues[0] = pp->filmNegative.redBase;
+    filmBaseValues[1] = pp->filmNegative.greenBase;
+    filmBaseValues[2] = pp->filmNegative.blueBase;
+
+    // If base values are not set in params, estimated values will be passed in later
+    // (after processing) via FilmNegListener
+    filmBaseValuesLabel->set_text(formatBaseValues(filmBaseValues));
+
     enableListener();
 }
 
@@ -142,14 +182,23 @@ void FilmNegative::write(rtengine::procparams::ProcParams* pp, ParamsEdited* ped
     pp->filmNegative.redRatio = redRatio->getValue();
     pp->filmNegative.greenExp = greenExp->getValue();
     pp->filmNegative.blueRatio = blueRatio->getValue();
+
     pp->filmNegative.enabled = getEnabled();
 
     if (pedited) {
         pedited->filmNegative.redRatio = redRatio->getEditedState();
         pedited->filmNegative.greenExp = greenExp->getEditedState();
         pedited->filmNegative.blueRatio = blueRatio->getEditedState();
+        pedited->filmNegative.baseValues = filmBaseValues[0] != pp->filmNegative.redBase
+                                           || filmBaseValues[1] != pp->filmNegative.greenBase
+                                           || filmBaseValues[2] != pp->filmNegative.blueBase;
         pedited->filmNegative.enabled = !get_inconsistent();
     }
+
+    pp->filmNegative.redBase = filmBaseValues[0];
+    pp->filmNegative.greenBase = filmBaseValues[1];
+    pp->filmNegative.blueBase = filmBaseValues[2];
+
 }
 
 void FilmNegative::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
@@ -172,8 +221,8 @@ void FilmNegative::setDefaults(const rtengine::procparams::ProcParams* defParams
 void FilmNegative::setBatchMode(bool batchMode)
 {
     if (batchMode) {
-        spotConn.disconnect();
         removeIfThere(this, spotgrid, false);
+        removeIfThere(this, filmBaseSpotButton, false);
         ToolPanel::setBatchMode(batchMode);
         redRatio->showEditedCB();
         greenExp->showEditedCB();
@@ -205,16 +254,20 @@ void FilmNegative::enabledChanged()
     if (listener) {
         if (get_inconsistent()) {
             listener->panelChanged(evFilmNegativeEnabled, M("GENERAL_UNCHANGED"));
-        }
-        else if (getEnabled()) {
+        } else if (getEnabled()) {
             listener->panelChanged(evFilmNegativeEnabled, M("GENERAL_ENABLED"));
-        }
-        else {
+        } else {
             listener->panelChanged(evFilmNegativeEnabled, M("GENERAL_DISABLED"));
         }
     }
 }
 
+void FilmNegative::filmBaseValuesChanged(std::array<float, 3> rgb)
+{
+    filmBaseValues = rgb;
+    filmBaseValuesLabel->set_text(formatBaseValues(filmBaseValues));
+}
+
 void FilmNegative::setFilmNegProvider(FilmNegProvider* provider)
 {
     fnp = provider;
@@ -227,7 +280,7 @@ void FilmNegative::setEditProvider(EditDataProvider* provider)
 
 CursorShape FilmNegative::getCursor(int objectID) const
 {
-   return CSSpotWB;
+    return CSSpotWB;
 }
 
 bool FilmNegative::mouseOver(int modifierKey)
@@ -246,31 +299,57 @@ bool FilmNegative::button1Pressed(int modifierKey)
     EditSubscriber::action = EditSubscriber::Action::NONE;
 
     if (listener) {
-        refSpotCoords.push_back(provider->posImage);
+        if (spotbutton->get_active()) {
 
-        if (refSpotCoords.size() == 2) {
-            // User has selected 2 reference gray spots. Calculating new exponents
-            // from channel values and updating parameters.
+            refSpotCoords.push_back(provider->posImage);
 
-            std::array<float, 3> newExps;
-            if (fnp->getFilmNegativeExponents(refSpotCoords[0], refSpotCoords[1], newExps)) {
+            if (refSpotCoords.size() == 2) {
+                // User has selected 2 reference gray spots. Calculating new exponents
+                // from channel values and updating parameters.
+
+                std::array<float, 3> newExps;
+
+                if (fnp->getFilmNegativeExponents(refSpotCoords[0], refSpotCoords[1], newExps)) {
+                    disableListener();
+                    // Leaving green exponent unchanged, setting red and blue exponents based on
+                    // the ratios between newly calculated exponents.
+                    redRatio->setValue(newExps[0] / newExps[1]);
+                    blueRatio->setValue(newExps[2] / newExps[1]);
+                    enableListener();
+
+                    if (listener && getEnabled()) {
+                        listener->panelChanged(
+                            evFilmNegativeExponents,
+                            Glib::ustring::compose(
+                                "Ref=%1\nR=%2\nB=%3",
+                                greenExp->getValue(),
+                                redRatio->getValue(),
+                                blueRatio->getValue()
+                            )
+                        );
+                    }
+                }
+
+                switchOffEditMode();
+            }
+
+        } else if (filmBaseSpotButton->get_active()) {
+
+            std::array<float, 3> newBaseLev;
+
+            if (fnp->getRawSpotValues(provider->posImage, 32, newBaseLev)) {
                 disableListener();
-                // Leaving green exponent unchanged, setting red and blue exponents based on
-                // the ratios between newly calculated exponents.
-                redRatio->setValue(newExps[0] / newExps[1]);
-                blueRatio->setValue(newExps[2] / newExps[1]);
+
+                filmBaseValues = newBaseLev;
+
                 enableListener();
 
+                const Glib::ustring vs = formatBaseValues(filmBaseValues);
+
+                filmBaseValuesLabel->set_text(vs);
+
                 if (listener && getEnabled()) {
-                    listener->panelChanged(
-                        evFilmNegativeExponents,
-                        Glib::ustring::compose(
-                            "Ref=%1\nR=%2\nB=%3",
-                            greenExp->getValue(),
-                            redRatio->getValue(),
-                            blueRatio->getValue()
-                        )
-                    );
+                    listener->panelChanged(evFilmBaseValues, vs);
                 }
             }
 
@@ -292,11 +371,38 @@ void FilmNegative::switchOffEditMode()
     refSpotCoords.clear();
     unsubscribe();
     spotbutton->set_active(false);
+    filmBaseSpotButton->set_active(false);
 }
 
 void FilmNegative::editToggled()
 {
     if (spotbutton->get_active()) {
+
+        filmBaseSpotButton->set_active(false);
+        refSpotCoords.clear();
+
+        subscribe();
+
+        int w, h;
+        getEditProvider()->getImageSize(w, h);
+
+        // Stick a dummy rectangle over the whole image in mouseOverGeometry.
+        // This is to make sure the getCursor() call is fired everywhere.
+        Rectangle* const imgRect = static_cast<Rectangle*>(mouseOverGeometry.at(0));
+        imgRect->setXYWH(0, 0, w, h);
+    } else {
+        refSpotCoords.clear();
+        unsubscribe();
+    }
+}
+
+void FilmNegative::baseSpotToggled()
+{
+    if (filmBaseSpotButton->get_active()) {
+
+        spotbutton->set_active(false);
+        refSpotCoords.clear();
+
         subscribe();
 
         int w, h;
diff --git a/rtgui/filmnegative.h b/rtgui/filmnegative.h
index bca155ceb..0810a8c57 100644
--- a/rtgui/filmnegative.h
+++ b/rtgui/filmnegative.h
@@ -33,13 +33,15 @@ public:
     virtual ~FilmNegProvider() = default;
 
     virtual bool getFilmNegativeExponents(rtengine::Coord spotA, rtengine::Coord spotB, std::array<float, 3>& newExps) = 0;
+    virtual bool getRawSpotValues(rtengine::Coord spot, int spotSize, std::array<float, 3>& rawValues) = 0;
 };
 
 class FilmNegative final :
     public ToolParamBlock,
     public AdjusterListener,
     public FoldableToolPanel,
-    public EditSubscriber
+    public EditSubscriber,
+    public rtengine::FilmNegListener
 {
 public:
     FilmNegative();
@@ -53,6 +55,8 @@ public:
     void adjusterChanged(Adjuster* a, double newval) override;
     void enabledChanged() override;
 
+    void filmBaseValuesChanged(std::array<float, 3> rgb) override;
+
     void setFilmNegProvider(FilmNegProvider* provider);
 
     void setEditProvider(EditDataProvider* provider) override;
@@ -66,12 +70,16 @@ public:
 
 private:
     void editToggled();
+    void baseSpotToggled();
 
     const rtengine::ProcEvent evFilmNegativeExponents;
     const rtengine::ProcEvent evFilmNegativeEnabled;
+    const rtengine::ProcEvent evFilmBaseValues;
 
     std::vector<rtengine::Coord> refSpotCoords;
 
+    std::array<float, 3> filmBaseValues;
+
     FilmNegProvider* fnp;
 
     Adjuster* const greenExp;
@@ -80,5 +88,9 @@ private:
 
     Gtk::Grid* const spotgrid;
     Gtk::ToggleButton* const spotbutton;
-    sigc::connection spotConn;
+
+    Gtk::Label* const filmBaseLabel;
+    Gtk::Label* const filmBaseValuesLabel;
+    Gtk::ToggleButton* const filmBaseSpotButton;
+
 };
diff --git a/rtgui/paramsedited.cc b/rtgui/paramsedited.cc
index 0faee0fd3..6a25a9d64 100644
--- a/rtgui/paramsedited.cc
+++ b/rtgui/paramsedited.cc
@@ -623,6 +623,7 @@ void ParamsEdited::set(bool v)
     filmNegative.redRatio = v;
     filmNegative.greenExp = v;
     filmNegative.blueRatio = v;
+    filmNegative.baseValues = v;
 
     exif = v;
     iptc = v;
@@ -1225,6 +1226,9 @@ void ParamsEdited::initFrom(const std::vector<rtengine::procparams::ProcParams>&
         filmNegative.redRatio = filmNegative.redRatio && p.filmNegative.redRatio == other.filmNegative.redRatio;
         filmNegative.greenExp = filmNegative.greenExp && p.filmNegative.greenExp == other.filmNegative.greenExp;
         filmNegative.blueRatio = filmNegative.blueRatio && p.filmNegative.blueRatio == other.filmNegative.blueRatio;
+        filmNegative.baseValues = filmNegative.baseValues && p.filmNegative.redBase == other.filmNegative.redBase
+                                                    && p.filmNegative.greenBase == other.filmNegative.greenBase
+                                                    && p.filmNegative.blueBase == other.filmNegative.blueBase;
 
 //      How the hell can we handle that???
 //      exif = exif && p.exif==other.exif
@@ -3430,6 +3434,12 @@ void ParamsEdited::combine(rtengine::procparams::ProcParams& toEdit, const rteng
         toEdit.filmNegative.blueRatio = mods.filmNegative.blueRatio;
     }
 
+    if (filmNegative.baseValues) {
+        toEdit.filmNegative.redBase = mods.filmNegative.redBase;
+        toEdit.filmNegative.greenBase = mods.filmNegative.greenBase;
+        toEdit.filmNegative.blueBase = mods.filmNegative.blueBase;
+    }
+
     // Exif changes are added to the existing ones
     if (exif) {
         for (procparams::ExifPairs::const_iterator i = mods.exif.begin(); i != mods.exif.end(); ++i) {
@@ -3476,7 +3486,7 @@ bool RetinexParamsEdited::isUnchanged() const
 
 bool FilmNegativeParamsEdited::isUnchanged() const
 {
-    return enabled && redRatio && greenExp && blueRatio;
+    return enabled && redRatio && greenExp && blueRatio && baseValues;
 }
 
 bool CaptureSharpeningParamsEdited::isUnchanged() const
diff --git a/rtgui/paramsedited.h b/rtgui/paramsedited.h
index d1be2c57e..1feedd774 100644
--- a/rtgui/paramsedited.h
+++ b/rtgui/paramsedited.h
@@ -727,6 +727,7 @@ struct FilmNegativeParamsEdited {
     bool redRatio;
     bool greenExp;
     bool blueRatio;
+    bool baseValues;
 
     bool isUnchanged() const;
 };
diff --git a/rtgui/partialpastedlg.cc b/rtgui/partialpastedlg.cc
index 22f608ae4..b31852af2 100644
--- a/rtgui/partialpastedlg.cc
+++ b/rtgui/partialpastedlg.cc
@@ -986,6 +986,7 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
         filterPE.filmNegative.redRatio   = falsePE.filmNegative.redRatio;
         filterPE.filmNegative.greenExp  = falsePE.filmNegative.greenExp;
         filterPE.filmNegative.blueRatio   = falsePE.filmNegative.blueRatio;
+        filterPE.filmNegative.baseValues   = falsePE.filmNegative.baseValues;
     }
 
     if (!captureSharpening->get_active ()) {
diff --git a/rtgui/ppversion.h b/rtgui/ppversion.h
index 89f93ed44..6a670733b 100644
--- a/rtgui/ppversion.h
+++ b/rtgui/ppversion.h
@@ -1,11 +1,13 @@
 #pragma once
 
 // This number has to be incremented whenever the PP3 file format is modified or the behaviour of a tool changes
-#define PPVERSION 346
+#define PPVERSION 347
 #define PPVERSION_AEXP 301 //value of PPVERSION when auto exposure algorithm was modified
 
 /*
   Log of version changes
+   347  2019-11-17
+        added special values in filmNegative for backwards compatibility with previous channel scaling method
    346  2019-01-01
         changed microcontrast uniformity
    345  2018-10-21
diff --git a/rtgui/toolpanelcoord.cc b/rtgui/toolpanelcoord.cc
index 00ad96328..a9c3231d4 100644
--- a/rtgui/toolpanelcoord.cc
+++ b/rtgui/toolpanelcoord.cc
@@ -609,6 +609,7 @@ void ToolPanelCoordinator::initImage (rtengine::StagedImageProcessor* ipc_, bool
         ipc->setSizeListener (crop);
         ipc->setSizeListener (resize);
         ipc->setImageTypeListener (this);
+        ipc->setFilmNegListener (filmNegative);
         flatfield->setShortcutPath (Glib::path_get_dirname (ipc->getInitialImage()->getFileName()));
 
         icm->setRawMeta (raw, (const rtengine::FramesData*)pMetaData);
@@ -1073,3 +1074,8 @@ bool ToolPanelCoordinator::getFilmNegativeExponents(rtengine::Coord spotA, rteng
 {
     return ipc && ipc->getFilmNegativeExponents(spotA.x, spotA.y, spotB.x, spotB.y, newExps);
 }
+
+bool ToolPanelCoordinator::getRawSpotValues(rtengine::Coord spot, int spotSize, std::array<float, 3>& rawValues)
+{
+    return ipc && ipc->getRawSpotValues(spot.x, spot.y, spotSize, rawValues);
+}
\ No newline at end of file
diff --git a/rtgui/toolpanelcoord.h b/rtgui/toolpanelcoord.h
index 0fc1a9070..1b51bca31 100644
--- a/rtgui/toolpanelcoord.h
+++ b/rtgui/toolpanelcoord.h
@@ -297,6 +297,7 @@ public:
 
     // FilmNegProvider interface
     bool getFilmNegativeExponents(rtengine::Coord spotA, rtengine::Coord spotB, std::array<float, 3>& newExps) override;
+    bool getRawSpotValues(rtengine::Coord spot, int spotSize, std::array<float, 3>& rawValues) override;
 
     // rotatelistener interface
     void straightenRequested () override;