feat(webp): Allow finer grained control over WEBP compression settings (#4772)

WEBP uses the `WebPConfig::factor` setting to also control how hard it
tries to compress when lossless compression is used. It also uses
another `WebPConfig::method` setting to further tune both lossless and
lossy schemes. [1]

Expose both of these settings so client applications using OIIO can
adjust these values as they see fit.

This PR makes 4 changes:
- Adds support for using a `lossless:factor` value for the `compression`
attribute. The 'factor' value controls the effort that WEBP uses during
the compression process.
- Adds support for using a `webp:method` int attribute. The value of
this attribute controls the `WebPConfig::method` setting. Note: this is
different than the compression settings but will also affect speed and
quality in various ways.
- Sets `WebPPicture::use_argb` to `true` when using lossless compression
(per the WEBP documentation[2])
- Changes default lossless "quality" from 100 to 70. This results in
much faster image output at a very minor increase in file size (e.g. a
2048x2048 test image goes from 1300ms/364kb to 800ms/371kb after this
change)

Before - just 2 basic forms were possible:
```
Client uses "compression=lossless"
- OIIO uses lossless=true, method=6, quality=100, use_argb=false
Client uses "compression=webp:90"
- OIIO uses lossless=false, method=6, quality=90, use_argb=false
```

After - several additional variations are possible:
```
Client uses "compression=lossless"
- OIIO uses lossless=true, method=6, quality=70, use_argb=true
Client uses "compression=lossless:100" and "webp:method=4"
- OIIO uses lossless=true, method=4, quality=100, use_argb=true
Client uses "compression=webp:90"
- OIIO uses lossless=false, method=6, quality=90, use_argb=false
Client uses "compression=webp:90" and "webp:method=4"
- OIIO uses lossless=false, method=4, quality=90, use_argb=false
```

[1]
https://developers.google.com/speed/webp/docs/api#advanced_encoding_api
[2] See notes around `use_argb` from the above link and see also the
internal Encode helper function which keeps lossless and use_argb in
sync:
https://github.com/webmproject/libwebp/blob/main/src/enc/picture_enc.c#L241


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

Author: jessey-git

src/doc/builtinplugins.rst

@@ -3099,6 +3099,19 @@ control aspects of the writing itself:
        unassociated form (non-premultiplied colors) and should stay that way
        for output rather than being assumed to be associated and get automatic
        un-association to store in the file.
+   * - ``Compression``
+     - string
+     - If supplied, can be either ``"webp:quality"`` or ``"lossless:quality"``
+       where quality can be an integer between 0 and 100, and where using "webp"
+       indicates a request for lossy compression. For lossy, 0 gives the smallest
+       size and 100 the largest. For lossless, this parameter is the amount of effort
+       put into the compression: 0 is the fastest but gives larger files compared to
+       the slowest, but best, 100. The default, if quality is not specified, is
+       100 for lossy and 70 for lossless.
+   * - ``webp:method``
+     - int
+     - A general quality/speed trade-off (0=fast, 6=slower-better) for both
+       lossy and lossless image encoding. The default is 6.
 
 **Custom I/O Overrides**
 

src/webp.imageio/webpoutput.cpp

@@ -80,37 +80,50 @@ WebpOutput::open(const std::string& name, const ImageSpec& spec, OpenMode mode)
     if (!ioproxy_use_or_open(name))
         return false;
 
-    if (!WebPPictureInit(&m_webp_picture)) {
-        errorfmt("Couldn't initialize WebPPicture\n");
+    constexpr int default_lossy_quality   = 100;
+    constexpr int default_lossless_effort = 70;
+
+    // Support both 'compression=webp:value' and 'compression=lossless:value'
+    // The 'webp' form indicates that lossy compression is requested.
+    bool is_lossless = false;
+    int quality      = default_lossy_quality;
+    auto comp_qual   = m_spec.decode_compression_metadata("webp",
+                                                          default_lossy_quality);
+    if (Strutil::iequals(comp_qual.first, "webp")) {
+        quality = OIIO::clamp(comp_qual.second, 0, 100);
+    } else {
+        comp_qual = m_spec.decode_compression_metadata("lossless",
+                                                       default_lossless_effort);
+        if (Strutil::iequals(comp_qual.first, "lossless")) {
+            is_lossless = true;
+            quality     = OIIO::clamp(comp_qual.second, 0, 100);
+        }
+    }
+
+    if (!WebPConfigPreset(&m_webp_config, WEBP_PRESET_DEFAULT, quality)) {
+        errorfmt("Couldn't initialize WebPConfig\n");
         close();
         return false;
     }
 
-    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();
-
-    if (!WebPConfigInit(&m_webp_config)) {
+    if (!WebPPictureInit(&m_webp_picture)) {
         errorfmt("Couldn't initialize WebPPicture\n");
         close();
         return false;
     }
 
-    auto compqual = m_spec.decode_compression_metadata("webp", 100);
-    if (Strutil::iequals(compqual.first, "webp")) {
-        m_webp_config.method  = 6;
-        m_webp_config.quality = OIIO::clamp(compqual.second, 1, 100);
-    } else {
-        // If compression name wasn't "webp", don't trust the quality
-        // metric, just use the default.
-        m_webp_config.method  = 6;
-        m_webp_config.quality = 100;
-    }
+    // Quality/speed trade-off (0=fast, 6=slower-better)
+    const int method     = m_spec.get_int_attribute("webp:method", 6);
+    m_webp_config.method = OIIO::clamp(method, 0, 6);
 
     // Lossless encoding (0=lossy(default), 1=lossless).
-    m_webp_config.lossless
-        = (m_spec.get_string_attribute("compression", "lossy") == "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();
 
     // forcing UINT8 format
     m_spec.set_format(TypeDesc::UINT8);