feat(webp): Support reading/writing the ICCProfile attribute (#4878)

Enable ICCProfile attribute support for WEBP for both input and output.
Like other formats this support is passive; pixel data will not be
altered by the mere presence of the ICCProfile attribute (i.e. it
functions like other informational metadata only).

The WebP API is a bit odd when it comes to writing the ICCProfile. We
must use the "mux" API set; the "advanced" API is apparently not
advanced enough to add the metadata to the file. This wouldn't be too
bad except that the mux API is at odds with how we write out the data.
Before: When it comes time to do the file write, we would pass our own
file writer into webp. The writes would go straight to disk. Now: If ICC
profile data is necessary to write, we let webp use its own writer to
write to memory. We then assemble the in-memory file and the ICC profile
data together and pass that entire package to our writer as a final
step.

When no ICC profile data is used, the old write behavior is kept.

Added `oiiotool` test variations which uses ICC profiles with WEBP.

---------

Signed-off-by: Jesse Yurkovich <[email protected]>

Author: jessey-git

src/doc/builtinplugins.rst

@@ -3034,6 +3034,10 @@ open standard for lossy-compressed images for use on the web.
    * - ImageSpec Attribute
      - Type
      - WebP header data or explanation
+   * - ``ICCProfile``
+     - uint8[]
+     - The ICC color profile. A variety of other ``ICCProfile:*`` attributes
+       may also be present, extracted from the main profile.
    * - ``oiio:Movie``
      - int
      - If nonzero, indicates that it's a multi-subimage file intended to

src/webp.imageio/CMakeLists.txt

@@ -4,7 +4,7 @@
 
 if (WebP_FOUND)
     add_oiio_plugin (webpinput.cpp webpoutput.cpp
-                     LINK_LIBRARIES WebP::webp WebP::webpdemux
+                     LINK_LIBRARIES WebP::webp WebP::webpdemux WebP::libwebpmux
                      DEFINITIONS "USE_WEBP=1")
 else ()
     message (STATUS "WebP plugin will not be built")

src/webp.imageio/webpinput.cpp

@@ -195,11 +195,20 @@ WebpInput::open(const std::string& name, ImageSpec& spec,
     }
     if (m_demux_flags & ICCP_FLAG
         && WebPDemuxGetChunk(m_demux, "ICCP", 1, &chunk_iter)) {
-        // FIXME: This is where we would extract an ICC profile. Come back
-        // to this when I have found an example webp containing an ICC
-        // profile that I can use as a test case, otherwise I'm just
-        // guessing.
+        cspan<uint8_t> icc_span(chunk_iter.chunk.bytes, chunk_iter.chunk.size);
+        m_spec.attribute("ICCProfile",
+                         TypeDesc(TypeDesc::UINT8, icc_span.size_bytes()),
+                         icc_span.data());
+
+        std::string errormsg;
+        const bool ok = decode_icc_profile(icc_span, m_spec, errormsg);
         WebPDemuxReleaseChunkIterator(&chunk_iter);
+
+        if (!ok && OIIO::get_int_attribute("imageinput:strict")) {
+            errorfmt("Possible corrupt file, could not decode ICC profile: {}\n",
+                     errormsg);
+            return false;
+        }
     }
 
     // Make space for the decoded image

src/webp.imageio/webpoutput.cpp

@@ -5,6 +5,7 @@
 #include <cstdio>
 
 #include <webp/encode.h>
+#include <webp/mux.h>
 
 #include <OpenImageIO/filesystem.h>
 #include <OpenImageIO/imagebufalgo.h>
@@ -44,6 +45,8 @@ class WebpOutput final : public ImageOutput {
         m_scanline_size = 0;
         ioproxy_clear();
     }
+
+    bool write_complete_data();
 };
 
 
@@ -119,11 +122,9 @@ WebpOutput::open(const std::string& name, const ImageSpec& spec, OpenMode mode)
     // Lossless encoding (0=lossy(default), 1=lossless).
     m_webp_config.lossless = int(is_lossless);
 
-    m_webp_picture.use_argb   = m_webp_config.lossless;
-    m_webp_picture.width      = m_spec.width;
-    m_webp_picture.height     = m_spec.height;
-    m_webp_picture.writer     = WebpImageWriter;
-    m_webp_picture.custom_ptr = (void*)ioproxy();
+    m_webp_picture.use_argb = m_webp_config.lossless;
+    m_webp_picture.width    = m_spec.width;
+    m_webp_picture.height   = m_spec.height;
 
     // forcing UINT8 format
     m_spec.set_format(TypeDesc::UINT8);
@@ -137,6 +138,94 @@ WebpOutput::open(const std::string& name, const ImageSpec& spec, OpenMode mode)
 }
 
 
+bool
+WebpOutput::write_complete_data()
+{
+    // Check if we have an optional ICC Profile to write.
+    const unsigned char* icc_data           = nullptr;
+    uint32_t icc_data_length                = 0;
+    bool has_icc_data                       = false;
+    const ParamValue* icc_profile_parameter = m_spec.find_attribute(
+        "ICCProfile");
+    if (icc_profile_parameter != nullptr) {
+        icc_data        = (const unsigned char*)icc_profile_parameter->data();
+        icc_data_length = icc_profile_parameter->type().size();
+        has_icc_data    = (icc_data && icc_data_length > 0);
+    }
+
+    // If we have ICC data, encode to memory first. This is required in order
+    // to use the WebPMux assembly API below.
+    WebPMemoryWriter wrt;
+    if (has_icc_data) {
+        WebPMemoryWriterInit(&wrt);
+        m_webp_picture.writer     = WebPMemoryWrite;
+        m_webp_picture.custom_ptr = &wrt;
+    } else {
+        m_webp_picture.writer     = WebpImageWriter;
+        m_webp_picture.custom_ptr = (void*)ioproxy();
+    }
+
+    if (m_spec.nchannels == 4) {
+        if (m_convert_alpha) {
+            // WebP requires unassociated alpha, and it's sRGB.
+            // Handle this all by wrapping an IB around it.
+            ImageSpec specwrap(m_spec.width, m_spec.height, 4, TypeUInt8);
+            ImageBuf bufwrap(specwrap, cspan<uint8_t>(m_uncompressed_image));
+            ROI rgbroi(0, m_spec.width, 0, m_spec.height, 0, 1, 0, 3);
+            ImageBufAlgo::pow(bufwrap, bufwrap, 2.2f, rgbroi);
+            ImageBufAlgo::unpremult(bufwrap, bufwrap);
+            ImageBufAlgo::pow(bufwrap, bufwrap, 1.0f / 2.2f, rgbroi);
+        }
+
+        WebPPictureImportRGBA(&m_webp_picture, m_uncompressed_image.data(),
+                              m_scanline_size);
+    } else {
+        WebPPictureImportRGB(&m_webp_picture, m_uncompressed_image.data(),
+                             m_scanline_size);
+    }
+
+    if (!WebPEncode(&m_webp_config, &m_webp_picture)) {
+        errorfmt("Failed to encode {} as WebP image", m_filename);
+        if (has_icc_data) {
+            WebPMemoryWriterClear(&wrt);
+        }
+        close();
+        return false;
+    }
+
+    // If there's no ICC data to write, we are done at this point.
+    bool ok = true;
+
+    // Otherwise, assemble the final WebP package and write it out.
+    if (has_icc_data) {
+        WebPMux* mux = WebPMuxNew();
+
+        WebPData image_data = { wrt.mem, wrt.size };
+        WebPMuxSetImage(mux, &image_data, false);
+
+        WebPData icc_chunk = { icc_data, size_t(icc_data_length) };
+        WebPMuxSetChunk(mux, "ICCP", &icc_chunk, false);
+
+        WebPData assembly;
+        if (WebPMuxAssemble(mux, &assembly) != WEBP_MUX_OK) {
+            errorfmt("Failed to assemble {} as WebP image", m_filename);
+            WebPMuxDelete(mux);
+            WebPMemoryWriterClear(&wrt);
+            return false;
+        }
+
+        ok = ioproxy()->write(assembly.bytes, assembly.size) == assembly.size;
+
+        WebPDataClear(&assembly);
+        WebPMuxDelete(mux);
+        WebPMemoryWriterClear(&wrt);
+    }
+
+    return ok;
+}
+
+
+
 bool
 WebpOutput::write_scanline(int y, int z, TypeDesc format, const void* data,
                            stride_t xstride)
@@ -150,32 +239,9 @@ WebpOutput::write_scanline(int y, int z, TypeDesc format, const void* data,
     data = to_native_scanline(format, data, xstride, scratch, m_dither, y, z);
     memcpy(&m_uncompressed_image[y * m_scanline_size], data, m_scanline_size);
 
+    /* If this was the final scanline, we are done. */
     if (y == m_spec.height - 1) {
-        if (m_spec.nchannels == 4) {
-            if (m_convert_alpha) {
-                // WebP requires unassociated alpha, and it's sRGB.
-                // Handle this all by wrapping an IB around it.
-                ImageSpec specwrap(m_spec.width, m_spec.height, 4, TypeUInt8);
-                ImageBuf bufwrap(specwrap,
-                                 cspan<uint8_t>(m_uncompressed_image));
-                ROI rgbroi(0, m_spec.width, 0, m_spec.height, 0, 1, 0, 3);
-                ImageBufAlgo::pow(bufwrap, bufwrap, 2.2f, rgbroi);
-                ImageBufAlgo::unpremult(bufwrap, bufwrap);
-                ImageBufAlgo::pow(bufwrap, bufwrap, 1.0f / 2.2f, rgbroi);
-            }
-
-            WebPPictureImportRGBA(&m_webp_picture, m_uncompressed_image.data(),
-                                  m_scanline_size);
-        } else {
-            WebPPictureImportRGB(&m_webp_picture, m_uncompressed_image.data(),
-                                 m_scanline_size);
-        }
-
-        if (!WebPEncode(&m_webp_config, &m_webp_picture)) {
-            errorfmt("Failed to encode {} as WebP image", m_filename);
-            close();
-            return false;
-        }
+        return write_complete_data();
     }
     return true;
 }

testsuite/oiiotool-attribs/ref/out-jpeg9d.txt

@@ -161,3 +161,25 @@ tahoe-icc.jpg        :  128 x   96, 3 channel, uint8 jpeg
     ICCProfile:rendering_intent: "Perceptual"
     jpeg:subsampling: "4:2:0"
     oiio:ColorSpace: "sRGB"
+Reading tahoe-icc.webp
+tahoe-icc.webp       :  128 x   96, 3 channel, uint8 webp
+    SHA-1: 407D97F3D62F90C7F9A78AF85989ED3C06C59523
+    channel list: R, G, B
+    ICCProfile: 0, 0, 2, 48, 65, 68, 66, 69, 2, 16, 0, 0, 109, 110, 116, 114, ... [560 x uint8]
+    ICCProfile:attributes: "Reflective, Glossy, Positive, Color"
+    ICCProfile:cmm_type: 1094992453
+    ICCProfile:color_space: "RGB"
+    ICCProfile:copyright: "Copyright 1999 Adobe Systems Incorporated"
+    ICCProfile:creation_date: "1999:06:03 00:00:00"
+    ICCProfile:creator_signature: "41444245"
+    ICCProfile:device_class: "Display device profile"
+    ICCProfile:flags: "Not Embedded, Independent"
+    ICCProfile:manufacturer: "6e6f6e65"
+    ICCProfile:model: "0"
+    ICCProfile:platform_signature: "Apple Computer, Inc."
+    ICCProfile:profile_connection_space: "XYZ"
+    ICCProfile:profile_description: "Adobe RGB (1998)"
+    ICCProfile:profile_size: 560
+    ICCProfile:profile_version: "2.1.0"
+    ICCProfile:rendering_intent: "Perceptual"
+    oiio:ColorSpace: "sRGB"

testsuite/oiiotool-attribs/ref/out.txt

@@ -161,3 +161,25 @@ tahoe-icc.jpg        :  128 x   96, 3 channel, uint8 jpeg
     ICCProfile:rendering_intent: "Perceptual"
     jpeg:subsampling: "4:2:0"
     oiio:ColorSpace: "sRGB"
+Reading tahoe-icc.webp
+tahoe-icc.webp       :  128 x   96, 3 channel, uint8 webp
+    SHA-1: 407D97F3D62F90C7F9A78AF85989ED3C06C59523
+    channel list: R, G, B
+    ICCProfile: 0, 0, 2, 48, 65, 68, 66, 69, 2, 16, 0, 0, 109, 110, 116, 114, ... [560 x uint8]
+    ICCProfile:attributes: "Reflective, Glossy, Positive, Color"
+    ICCProfile:cmm_type: 1094992453
+    ICCProfile:color_space: "RGB"
+    ICCProfile:copyright: "Copyright 1999 Adobe Systems Incorporated"
+    ICCProfile:creation_date: "1999:06:03 00:00:00"
+    ICCProfile:creator_signature: "41444245"
+    ICCProfile:device_class: "Display device profile"
+    ICCProfile:flags: "Not Embedded, Independent"
+    ICCProfile:manufacturer: "6e6f6e65"
+    ICCProfile:model: "0"
+    ICCProfile:platform_signature: "Apple Computer, Inc."
+    ICCProfile:profile_connection_space: "XYZ"
+    ICCProfile:profile_description: "Adobe RGB (1998)"
+    ICCProfile:profile_size: 560
+    ICCProfile:profile_version: "2.1.0"
+    ICCProfile:rendering_intent: "Perceptual"
+    oiio:ColorSpace: "sRGB"

testsuite/oiiotool-attribs/ref/test-webp.icc

@@ -51,10 +51,14 @@
 
 # Test adding and extracting ICC profiles
 command += oiiotool ("../common/tahoe-tiny.tif --iccread ref/test.icc -o tahoe-icc.jpg")
+command += oiiotool ("../common/tahoe-tiny.tif --iccread ref/test-webp.icc -o tahoe-icc.webp")
 command += info_command ("tahoe-icc.jpg", safematch=True)
+command += info_command ("tahoe-icc.webp", safematch=True)
 command += oiiotool ("tahoe-icc.jpg --iccwrite test.icc")
+command += oiiotool ("tahoe-icc.webp --iccwrite test-webp.icc")
 
 outputs = [
             "test.icc",
+            "test-webp.icc",
             "out.txt"
 ]