feat(raw): add raw:ForceLoad hint (#4704)

The raw input plugin populates the attributes in the ImageSpec from the
libraw structures in the RawInput::open_raw() method. That is done
before the actual image data being decompressed on demand in
RawInput::read_native_scanline(). Libraw re-calculates some values after
the pixels get available, it is impossible to access those, as the
ImageBuf's spec does not get updated, and the updated ImageSpec is not
available from outside of RawInput when/after the pixels are being
processed.

An example: the initial values for the white balancing weights get
populated from the image file metadata, those get copied into the
ImageSpec. If the libraw was configured to white balance by averaging
the pixels of the whole image or a region, the white balancing weights
would get re-calculated by libraw after processing the pixels, but the
updated numbers are impossible to access from outside of the RawInput
plugin.

This change adds a hint "raw:ForceLoad", which, if set to 1, forces
libraw to decompress and process the image in RawInput::open_raw(), so
the image attributes returned from that method would contain the final
values.

I am not certain if this is the best way to achieve what I needed. I
have also looked into making the ImageBuf retain the ImageInput object
instead of spawning multiple transient objects, but that seemed too
complicated.

I have not added any unit tests, not sure how to approach that. I have
tested that the image does not get decompressed multiple times in a
bunch of scenarios.

Signed-off-by: Anton Dukhovnikov <antond@wetafx.co.nz>

Author: antond-weta

src/doc/builtinplugins.rst

@@ -2228,7 +2228,12 @@ options are supported:
      - Maximum memory allocation for processing of raw images. Stop processing if
        raw buffer size grows larger than that value (in megabytes).
        (Default: 2048)
-
+   * - ``raw:ForceLoad``
+     - int
+     - If 1, forces libraw to decompress and process the image during
+       initialization. This populates the image attributes which depend on the
+       pixel values.
+       (Default: 0)
 
 |
 

src/raw.imageio/rawinput.cpp

@@ -72,7 +72,6 @@ class RawInput final : public ImageInput {
                               void* data) override;
 
 private:
-    bool process();
     bool m_process  = true;
     bool m_unpacked = false;
     std::unique_ptr<LibRaw> m_processor;
@@ -87,9 +86,10 @@ class RawInput final : public ImageInput {
     std::string m_make;
 
     bool do_unpack();
+    bool do_process();
 
     // Do the actual open. It expects m_filename and m_config to be set.
-    bool open_raw(bool unpack, const std::string& name,
+    bool open_raw(bool unpack, bool process, const std::string& name,
                   const ImageSpec& config);
     void get_makernotes();
     void get_makernotes_canon();
@@ -374,12 +374,14 @@ RawInput::open(const std::string& name, ImageSpec& newspec,
     m_filename = name;
     m_config   = config;
 
+    bool force_load = config.get_int_attribute("raw:ForceLoad");
+
     // For a fresh open, we are concerned with just reading all the
     // metadata quickly, because maybe that's all that will be needed. So
     // call open_raw passing unpack=false. This will not read the pixels! We
     // will need to close and re-open with unpack=true if and when we need
     // the actual pixel values.
-    bool ok = open_raw(false, m_filename, m_config);
+    bool ok = open_raw(force_load, force_load, m_filename, m_config);
     if (ok)
         newspec = m_spec;
     return ok;
@@ -388,7 +390,7 @@ RawInput::open(const std::string& name, ImageSpec& newspec,
 
 
 bool
-RawInput::open_raw(bool unpack, const std::string& name,
+RawInput::open_raw(bool unpack, bool process, const std::string& name,
                    const ImageSpec& config)
 {
     // std::cout << "open_raw " << name << " unpack=" << unpack << "\n";
@@ -517,31 +519,31 @@ RawInput::open_raw(bool unpack, const std::string& name,
     } else {
         if (config.get_int_attribute("raw:use_auto_wb", 0) == 1) {
             m_processor->imgdata.params.use_auto_wb = 1;
-        } else {
+            // White balancing to a box requires use_auto_wb = 1
             auto p = config.find_attribute("raw:greybox");
             if (p && p->type() == TypeDesc(TypeDesc::INT, 4)) {
                 // p->get<int>() didn't work for me here
                 m_processor->imgdata.params.greybox[0] = p->get_int_indexed(0);
                 m_processor->imgdata.params.greybox[1] = p->get_int_indexed(1);
                 m_processor->imgdata.params.greybox[2] = p->get_int_indexed(2);
                 m_processor->imgdata.params.greybox[3] = p->get_int_indexed(3);
-            } else {
-                // Set user white balance coefficients.
-                // Only has effect if "raw:use_camera_wb" is equal to 0,
-                // i.e. we are not using the camera white balance
-                auto p = config.find_attribute("raw:user_mul");
-                if (p && p->type() == TypeDesc(TypeDesc::FLOAT, 4)) {
-                    m_processor->imgdata.params.user_mul[0] = p->get<float>(0);
-                    m_processor->imgdata.params.user_mul[1] = p->get<float>(1);
-                    m_processor->imgdata.params.user_mul[2] = p->get<float>(2);
-                    m_processor->imgdata.params.user_mul[3] = p->get<float>(3);
-                }
-                if (p && p->type() == TypeDesc(TypeDesc::DOUBLE, 4)) {
-                    m_processor->imgdata.params.user_mul[0] = p->get<double>(0);
-                    m_processor->imgdata.params.user_mul[1] = p->get<double>(1);
-                    m_processor->imgdata.params.user_mul[2] = p->get<double>(2);
-                    m_processor->imgdata.params.user_mul[3] = p->get<double>(3);
-                }
+            }
+        } else {
+            // Set user white balance coefficients.
+            // Only has effect if "raw:use_camera_wb" is equal to 0,
+            // i.e. we are not using the camera white balance
+            auto p = config.find_attribute("raw:user_mul");
+            if (p && p->type() == TypeDesc(TypeDesc::FLOAT, 4)) {
+                m_processor->imgdata.params.user_mul[0] = p->get<float>(0);
+                m_processor->imgdata.params.user_mul[1] = p->get<float>(1);
+                m_processor->imgdata.params.user_mul[2] = p->get<float>(2);
+                m_processor->imgdata.params.user_mul[3] = p->get<float>(3);
+            }
+            if (p && p->type() == TypeDesc(TypeDesc::DOUBLE, 4)) {
+                m_processor->imgdata.params.user_mul[0] = p->get<double>(0);
+                m_processor->imgdata.params.user_mul[1] = p->get<double>(1);
+                m_processor->imgdata.params.user_mul[2] = p->get<double>(2);
+                m_processor->imgdata.params.user_mul[3] = p->get<double>(3);
             }
         }
     }
@@ -938,6 +940,9 @@ RawInput::open_raw(bool unpack, const std::string& name,
         }
     }
 
+    if (process) {
+        do_process();
+    }
 
     // Metadata
 
@@ -1517,15 +1522,15 @@ RawInput::do_unpack()
     // We need to unpack but we didn't when we opened the file. Close and
     // re-open with unpack.
     close();
-    bool ok    = open_raw(true, m_filename, m_config);
+    bool ok    = open_raw(true, false, m_filename, m_config);
     m_unpacked = true;
     return ok;
 }
 
 
 
 bool
-RawInput::process()
+RawInput::do_process()
 {
     if (!m_image) {
         int ret = m_processor->dcraw_process();
@@ -1624,7 +1629,7 @@ RawInput::read_native_scanline(int subimage, int miplevel, int y, int /*z*/,
     // Check the state of the internal RAW reader.
     // Have to load the entire image at once, so only do this once
     if (!m_image) {
-        if (!process()) {
+        if (!do_process()) {
             return false;
         }
     }