From 9e9abfab27b7736399bb934862326cd53a77ec19 Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Thu, 12 Jun 2025 15:25:20 +0100
Subject: [PATCH 01/11] Add five new types of diffusion dither and expose zig
 zag to user

This extends the existing dithering code to add Jarvis-Judice-Ninke,
Stucki, Atkinson, Burkes and Sierra error diffused dithers. It also
exposes the zig zag (serpentine) choice to the user. Diffusion is
tweaked to use fixed point for the error values.
---
 data/pref.xml                                |   1 +
 data/strings/en.ini                          |  13 +-
 src/app/cli/cli_processor.cpp                |  16 +-
 src/app/commands/cmd_change_pixel_format.cpp |  62 ++++--
 src/app/commands/new_params.cpp              |  15 +-
 src/app/ui/context_bar.cpp                   |  22 ++-
 src/app/ui/dithering_selector.cpp            |  17 +-
 src/render/dithering.h                       |   5 +
 src/render/dithering_algorithm.h             |  17 +-
 src/render/error_diffusion.cpp               | 190 ++++++++++++++++---
 src/render/error_diffusion.h                 |  38 +++-
 src/render/ordered_dither.cpp                |   4 +-
 src/render/ordered_dither.h                  |   1 -
 src/render/quantization.cpp                  |  25 ++-
 src/render/quantization.h                    |   2 +-
 15 files changed, 364 insertions(+), 64 deletions(-)

diff --git a/data/pref.xml b/data/pref.xml
index 9c852c067..831728b4c 100644
--- a/data/pref.xml
+++ b/data/pref.xml
@@ -329,6 +329,7 @@
     <section id="quantization">
       <option id="with_alpha" type="bool" default="true" />
       <option id="dithering_algorithm" type="std::string" />
+      <option id="zig_zag" type="bool" default="true" />
       <option id="dithering_factor" type="int" default="100" />
       <option id="to_gray" type="ToGrayAlgorithm" default="ToGrayAlgorithm::DEFAULT" />
       <option id="advanced" type="bool" default="false" />
diff --git a/data/strings/en.ini b/data/strings/en.ini
index a6623d9b7..a606debdc 100644
--- a/data/strings/en.ini
+++ b/data/strings/en.ini
@@ -235,8 +235,14 @@ ChangePixelFormat_Grayscale = Grayscale
 ChangePixelFormat_Indexed = Indexed
 ChangePixelFormat_Indexed_OrderedDithering = Indexed with Ordered Dithering
 ChangePixelFormat_Indexed_OldDithering = Indexed with Old Dithering
-ChangePixelFormat_Indexed_ErrorDiffusion = Indexed with Floyd-Steinberg Error Diffusion Dithering
+ChangePixelFormat_Indexed_FloydSteinberg = Indexed with Floyd-Steinberg Error Diffusion Dithering
+ChangePixelFormat_Indexed_JarvisJudiceNinke = Indexed with Jarvis-Judice-Ninke Error Diffusion Dithering
+ChangePixelFormat_Indexed_Stucki = Indexed with Stucki Error Diffusion Dithering
+ChangePixelFormat_Indexed_Atkinson = Indexed with Atkinson Error Diffusion Dithering
+ChangePixelFormat_Indexed_Burkes = Indexed with Burkes Error Diffusion Dithering
+ChangePixelFormat_Indexed_Sierra = Indexed with Sierra Error Diffusion Dithering
 ChangePixelFormat_MoreOptions = More Options
+ChangePixelFormat_ZigZag = Zig Zag
 Clear = Clear
 ClearCel = Clear Cel
 ClearRecentFiles = Clear Recent Files
@@ -516,6 +522,11 @@ no_dithering = No Dithering
 old_dithering = Old Dithering +\s
 ordered_dithering = Ordered Dithering +\s
 floyd_steinberg = Floyd-Steinberg Error Diffusion Dithering
+jarvis_judice_ninke = Jarvis Judice Ninke Error Diffusion Dithering
+stucki = Stucki Error Diffusion Dithering
+atkinson = Atkinson Error Diffusion Dithering
+burkes = Burkes Error Diffusion Dithering
+sierra = Sierra Error Diffusion Dithering
 
 [canvas_size]
 title = Canvas Size
diff --git a/src/app/cli/cli_processor.cpp b/src/app/cli/cli_processor.cpp
index 62bd2cf7c..4984d6236 100644
--- a/src/app/cli/cli_processor.cpp
+++ b/src/app/cli/cli_processor.cpp
@@ -453,8 +453,18 @@ int CliProcessor::process(Context* ctx)
             ditheringAlgorithm = render::DitheringAlgorithm::Ordered;
           else if (value.value() == "old")
             ditheringAlgorithm = render::DitheringAlgorithm::Old;
-          else if (value.value() == "error-diffusion")
-            ditheringAlgorithm = render::DitheringAlgorithm::ErrorDiffusion;
+          else if (value.value() == "error-diffusion" || value.value() == "floyd-steinberg")
+            ditheringAlgorithm = render::DitheringAlgorithm::FloydSteinberg;
+          else if (value.value() == "jarvis-judice-ninke")
+            ditheringAlgorithm = render::DitheringAlgorithm::JarvisJudiceNinke;
+          else if (value.value() == "stucki")
+            ditheringAlgorithm = render::DitheringAlgorithm::Stucki;
+          else if (value.value() == "atkinson")
+            ditheringAlgorithm = render::DitheringAlgorithm::Atkinson;
+          else if (value.value() == "burkes")
+            ditheringAlgorithm = render::DitheringAlgorithm::Burkes;
+          else if (value.value() == "sierra")
+            ditheringAlgorithm = render::DitheringAlgorithm::Sierra;
           else
             throw std::runtime_error(
               "--dithering-algorithm needs a valid algorithm name\n"
@@ -481,7 +491,7 @@ int CliProcessor::process(Context* ctx)
               case render::DitheringAlgorithm::None:    params.set("dithering", "none"); break;
               case render::DitheringAlgorithm::Ordered: params.set("dithering", "ordered"); break;
               case render::DitheringAlgorithm::Old:     params.set("dithering", "old"); break;
-              case render::DitheringAlgorithm::ErrorDiffusion:
+              case render::DitheringAlgorithm::FloydSteinberg:
                 params.set("dithering", "error-diffusion");
                 break;
             }
diff --git a/src/app/commands/cmd_change_pixel_format.cpp b/src/app/commands/cmd_change_pixel_format.cpp
index 7f44bf6df..3a216deb7 100644
--- a/src/app/commands/cmd_change_pixel_format.cpp
+++ b/src/app/commands/cmd_change_pixel_format.cpp
@@ -41,6 +41,7 @@
 #include "render/quantization.h"
 #include "render/render.h"
 #include "render/task_delegate.h"
+#include "ui/button.h"
 #include "ui/listitem.h"
 #include "ui/paint_event.h"
 #include "ui/size_hint_event.h"
@@ -177,6 +178,7 @@ public:
     , m_imageBuffer(new doc::ImageBuffer)
     , m_selectedItem(nullptr)
     , m_ditheringSelector(nullptr)
+    , m_zigZagCheck(nullptr)
     , m_mapAlgorithmSelector(nullptr)
     , m_bestFitCriteriaSelector(nullptr)
     , m_imageJustCreated(true)
@@ -204,6 +206,8 @@ public:
       m_ditheringSelector = new DitheringSelector(DitheringSelector::SelectBoth);
       m_ditheringSelector->setExpansive(true);
 
+      m_zigZagCheck = new CheckBox(Strings::commands_ChangePixelFormat_ZigZag());
+
       m_mapAlgorithmSelector = new RgbMapAlgorithmSelector;
       m_mapAlgorithmSelector->setExpansive(true);
 
@@ -217,6 +221,9 @@ public:
           m_ditheringSelector->setSelectedItemIndex(index);
       }
 
+      // Select default zig zag
+      m_zigZagCheck->setSelected(pref.quantization.zigZag());
+
       // Select default RgbMap algorithm
       m_mapAlgorithmSelector->algorithm(pref.quantization.rgbmapAlgorithm());
 
@@ -224,6 +231,7 @@ public:
       m_bestFitCriteriaSelector->criteria(pref.quantization.fitCriteria());
 
       ditheringPlaceholder()->addChild(m_ditheringSelector);
+      ditheringPlaceholder()->addChild(m_zigZagCheck);
       rgbmapAlgorithmPlaceholder()->addChild(m_mapAlgorithmSelector);
       bestFitCriteriaPlaceholder()->addChild(m_bestFitCriteriaSelector);
 
@@ -233,6 +241,7 @@ public:
 
       // Signals
       m_ditheringSelector->Change.connect([this] { onIndexParamChange(); });
+      m_zigZagCheck->Click.connect([this] { onIndexParamChange(); });
       m_mapAlgorithmSelector->Change.connect([this] { onIndexParamChange(); });
       m_bestFitCriteriaSelector->Change.connect([this] { onIndexParamChange(); });
       factor()->Change.connect([this] { onIndexParamChange(); });
@@ -281,6 +290,7 @@ public:
     if (m_ditheringSelector) {
       d.algorithm(m_ditheringSelector->ditheringAlgorithm());
       d.matrix(m_ditheringSelector->ditheringMatrix());
+      d.zigzag(m_zigZagCheck->isSelected());
     }
     d.factor(double(factor()->getValue()) / 100.0);
     return d;
@@ -317,16 +327,16 @@ public:
   {
     auto& pref = Preferences::instance();
 
-    // Save the dithering method used for the future
+    // Save the dithering method and zig-zag setting used for the future
     if (m_ditheringSelector) {
       if (auto item = m_ditheringSelector->getSelectedItem()) {
         pref.quantization.ditheringAlgorithm(item->text());
 
-        if (m_ditheringSelector->ditheringAlgorithm() ==
-            render::DitheringAlgorithm::ErrorDiffusion) {
+        if (IsDiffusion(m_ditheringSelector->ditheringAlgorithm()))
           pref.quantization.ditheringFactor(factor()->getValue());
-        }
       }
+
+      pref.quantization.zigZag(m_zigZagCheck->isEnabled());
     }
 
     if (m_mapAlgorithmSelector || m_bestFitCriteriaSelector)
@@ -365,8 +375,7 @@ private:
       const bool toIndexed = (dstColorMode == doc::ColorMode::INDEXED);
       m_ditheringSelector->setVisible(toIndexed);
 
-      const bool errorDiff = (m_ditheringSelector->ditheringAlgorithm() ==
-                              render::DitheringAlgorithm::ErrorDiffusion);
+      const bool errorDiff = (render::IsDiffusion(m_ditheringSelector->ditheringAlgorithm()));
       amount()->setVisible(toIndexed && errorDiff);
     }
 
@@ -460,6 +469,7 @@ private:
   std::unique_ptr<ConvertThread> m_bgThread;
   ConversionItem* m_selectedItem;
   DitheringSelector* m_ditheringSelector;
+  CheckBox* m_zigZagCheck;
   RgbMapAlgorithmSelector* m_mapAlgorithmSelector;
   BestFitCriteriaSelector* m_bestFitCriteriaSelector;
   bool m_imageJustCreated;
@@ -487,6 +497,11 @@ struct ChangePixelFormatParams : public NewParams {
     1.0,
     { "ditheringFactor", "dithering-factor" }
   };
+  Param<bool> zigZag{
+    this,
+    true,
+    { "zigZag", "zig-zag" }
+  };
   Param<doc::RgbMapAlgorithm> rgbmap{ this, RgbMapAlgorithm::DEFAULT, "rgbmap" };
   Param<gen::ToGrayAlgorithm> toGray{ this, gen::ToGrayAlgorithm::DEFAULT, "toGray" };
   Param<doc::FitCriteria> fitCriteria{ this, doc::FitCriteria::DEFAULT, "fitCriteria" };
@@ -572,6 +587,7 @@ void ChangePixelFormatCommand::onExecute(Context* ctx)
     params().dithering(window.dithering().algorithm());
     matrix = window.dithering().matrix();
     params().factor(window.dithering().factor());
+    params().zigZag(window.dithering().zigzag());
     params().rgbmap(window.rgbMapAlgorithm());
     params().fitCriteria(window.fitCriteria());
     params().toGray(window.toGray());
@@ -615,13 +631,14 @@ void ChangePixelFormatCommand::onExecute(Context* ctx)
     }
 
     job.startJobWithCallback([this, &job, sprite, &matrix](Tx& tx) {
-      tx(new cmd::SetPixelFormat(sprite,
-                                 (PixelFormat)params().colorMode(),
-                                 render::Dithering(params().dithering(), matrix, params().factor()),
-                                 params().rgbmap(),
-                                 get_gray_func(params().toGray()),
-                                 &job, // SpriteJob is a render::TaskDelegate
-                                 params().fitCriteria()));
+      tx(new cmd::SetPixelFormat(
+        sprite,
+        (PixelFormat)params().colorMode(),
+        render::Dithering(params().dithering(), matrix, params().factor(), params().zigZag()),
+        params().rgbmap(),
+        get_gray_func(params().toGray()),
+        &job, // SpriteJob is a render::TaskDelegate
+        params().fitCriteria()));
     });
     job.waitJob();
   }
@@ -651,8 +668,23 @@ std::string ChangePixelFormatCommand::onGetFriendlyName() const
           case render::DitheringAlgorithm::Old:
             conversion = Strings::commands_ChangePixelFormat_Indexed_OldDithering();
             break;
-          case render::DitheringAlgorithm::ErrorDiffusion:
-            conversion = Strings::commands_ChangePixelFormat_Indexed_ErrorDiffusion();
+          case render::DitheringAlgorithm::FloydSteinberg:
+            conversion = Strings::commands_ChangePixelFormat_Indexed_FloydSteinberg();
+            break;
+          case render::DitheringAlgorithm::JarvisJudiceNinke:
+            conversion = Strings::commands_ChangePixelFormat_Indexed_JarvisJudiceNinke();
+            break;
+          case render::DitheringAlgorithm::Stucki:
+            conversion = Strings::commands_ChangePixelFormat_Indexed_Stucki();
+            break;
+          case render::DitheringAlgorithm::Atkinson:
+            conversion = Strings::commands_ChangePixelFormat_Indexed_Atkinson();
+            break;
+          case render::DitheringAlgorithm::Burkes:
+            conversion = Strings::commands_ChangePixelFormat_Indexed_Burkes();
+            break;
+          case render::DitheringAlgorithm::Sierra:
+            conversion = Strings::commands_ChangePixelFormat_Indexed_Sierra();
             break;
         }
         break;
diff --git a/src/app/commands/new_params.cpp b/src/app/commands/new_params.cpp
index 1af8b5903..26cbadf01 100644
--- a/src/app/commands/new_params.cpp
+++ b/src/app/commands/new_params.cpp
@@ -279,8 +279,19 @@ void Param<render::DitheringAlgorithm>::fromString(const std::string& value)
     setValue(render::DitheringAlgorithm::Ordered);
   else if (base::utf8_icmp(value, "old") == 0)
     setValue(render::DitheringAlgorithm::Old);
-  else if (base::utf8_icmp(value, "error-diffusion") == 0)
-    setValue(render::DitheringAlgorithm::ErrorDiffusion);
+  else if (base::utf8_icmp(value, "error-diffusion") == 0 ||
+           base::utf8_icmp(value, "floyd-steinberg") == 0)
+    setValue(render::DitheringAlgorithm::FloydSteinberg);
+  else if (base::utf8_icmp(value, "jarvis-judice-ninke") == 0)
+    setValue(render::DitheringAlgorithm::JarvisJudiceNinke);
+  else if (base::utf8_icmp(value, "stucki") == 0)
+    setValue(render::DitheringAlgorithm::Stucki);
+  else if (base::utf8_icmp(value, "atkinson") == 0)
+    setValue(render::DitheringAlgorithm::Atkinson);
+  else if (base::utf8_icmp(value, "burkes") == 0)
+    setValue(render::DitheringAlgorithm::Burkes);
+  else if (base::utf8_icmp(value, "sierra") == 0)
+    setValue(render::DitheringAlgorithm::Sierra);
   else
     setValue(render::DitheringAlgorithm::None);
 }
diff --git a/src/app/ui/context_bar.cpp b/src/app/ui/context_bar.cpp
index 334c238d8..6cb05fd39 100644
--- a/src/app/ui/context_bar.cpp
+++ b/src/app/ui/context_bar.cpp
@@ -2572,8 +2572,26 @@ render::DitheringAlgorithmBase* ContextBar::ditheringAlgorithm()
     case render::DitheringAlgorithm::None:    s_dither.reset(nullptr); break;
     case render::DitheringAlgorithm::Ordered: s_dither.reset(new render::OrderedDither2(-1)); break;
     case render::DitheringAlgorithm::Old:     s_dither.reset(new render::OrderedDither(-1)); break;
-    case render::DitheringAlgorithm::ErrorDiffusion:
-      s_dither.reset(new render::ErrorDiffusionDither(-1));
+    case render::DitheringAlgorithm::FloydSteinberg:
+      s_dither.reset(
+        new render::ErrorDiffusionDither(render::ErrorDiffusionType::FloydSteinberg, -1));
+      break;
+    case render::DitheringAlgorithm::JarvisJudiceNinke:
+      s_dither.reset(
+        new render::ErrorDiffusionDither(render::ErrorDiffusionType::JarvisJudiceNinke, -1));
+      break;
+    case render::DitheringAlgorithm::Stucki:
+      s_dither.reset(new render::ErrorDiffusionDither(render::ErrorDiffusionType::Stucki, -1));
+      break;
+    case render::DitheringAlgorithm::Atkinson:
+      s_dither.reset(new render::ErrorDiffusionDither(render::ErrorDiffusionType::Atkinson, -1));
+      break;
+    case render::DitheringAlgorithm::Burkes:
+      s_dither.reset(new render::ErrorDiffusionDither(render::ErrorDiffusionType::Burkes, -1));
+      break;
+    case render::DitheringAlgorithm::Sierra:
+      s_dither.reset(new render::ErrorDiffusionDither(render::ErrorDiffusionType::Sierra, -1));
+      break;
       break;
   }
 
diff --git a/src/app/ui/dithering_selector.cpp b/src/app/ui/dithering_selector.cpp
index be1bd8e8d..f274cf773 100644
--- a/src/app/ui/dithering_selector.cpp
+++ b/src/app/ui/dithering_selector.cpp
@@ -231,9 +231,24 @@ void DitheringSelector::regenerate(int selectedItemIndex)
           Console::showException(e);
         }
       }
-      addItem(new DitherItem(render::DitheringAlgorithm::ErrorDiffusion,
+      addItem(new DitherItem(render::DitheringAlgorithm::FloydSteinberg,
                              render::DitheringMatrix(),
                              Strings::dithering_selector_floyd_steinberg()));
+      addItem(new DitherItem(render::DitheringAlgorithm::JarvisJudiceNinke,
+                             render::DitheringMatrix(),
+                             Strings::dithering_selector_jarvis_judice_ninke()));
+      addItem(new DitherItem(render::DitheringAlgorithm::Stucki,
+                             render::DitheringMatrix(),
+                             Strings::dithering_selector_stucki()));
+      addItem(new DitherItem(render::DitheringAlgorithm::Atkinson,
+                             render::DitheringMatrix(),
+                             Strings::dithering_selector_atkinson()));
+      addItem(new DitherItem(render::DitheringAlgorithm::Burkes,
+                             render::DitheringMatrix(),
+                             Strings::dithering_selector_burkes()));
+      addItem(new DitherItem(render::DitheringAlgorithm::Sierra,
+                             render::DitheringMatrix(),
+                             Strings::dithering_selector_sierra()));
       break;
     case SelectMatrix:
       addItem(
diff --git a/src/render/dithering.h b/src/render/dithering.h
index 1390fb7d7..eb755fcf5 100644
--- a/src/render/dithering.h
+++ b/src/render/dithering.h
@@ -18,24 +18,29 @@ class Dithering {
 public:
   Dithering(DitheringAlgorithm algorithm = DitheringAlgorithm::None,
             const DitheringMatrix& matrix = DitheringMatrix(),
+            bool zigzag = true,
             double factor = 1.0)
     : m_algorithm(algorithm)
     , m_matrix(matrix)
+    , m_zigzag(zigzag)
     , m_factor(factor)
   {
   }
 
   DitheringAlgorithm algorithm() const { return m_algorithm; }
   DitheringMatrix matrix() const { return m_matrix; }
+  bool zigzag() const { return m_zigzag; }
   double factor() const { return m_factor; }
 
   void algorithm(const DitheringAlgorithm algorithm) { m_algorithm = algorithm; }
   void matrix(const DitheringMatrix& matrix) { m_matrix = matrix; }
+  void zigzag(bool zigzag) { m_zigzag = zigzag; }
   void factor(const double factor) { m_factor = factor; }
 
 private:
   DitheringAlgorithm m_algorithm;
   DitheringMatrix m_matrix;
+  bool m_zigzag;
   double m_factor;
 };
 
diff --git a/src/render/dithering_algorithm.h b/src/render/dithering_algorithm.h
index e95566693..34ed5c093 100644
--- a/src/render/dithering_algorithm.h
+++ b/src/render/dithering_algorithm.h
@@ -16,9 +16,24 @@ enum class DitheringAlgorithm {
   None,
   Ordered,
   Old,
-  ErrorDiffusion,
+  FloydSteinberg,
+  JarvisJudiceNinke,
+  Stucki,
+  Atkinson,
+  Burkes,
+  Sierra,
 };
 
+inline bool IsDiffusion(DitheringAlgorithm algo)
+{
+  switch (algo) {
+    case DitheringAlgorithm::None:
+    case DitheringAlgorithm::Ordered:
+    case DitheringAlgorithm::Old:     return false;
+    default:                          return true;
+  }
+}
+
 } // namespace render
 
 #endif
diff --git a/src/render/error_diffusion.cpp b/src/render/error_diffusion.cpp
index c88b77ca2..4419aa0b9 100644
--- a/src/render/error_diffusion.cpp
+++ b/src/render/error_diffusion.cpp
@@ -15,22 +15,136 @@
 #include "gfx/rgb.h"
 
 #include <algorithm>
+#include <vector>
 
 namespace render {
 
-ErrorDiffusionDither::ErrorDiffusionDither(int transparentIndex)
+// Predefined error diffusion algorithms
+class ErrorDiffusionMatrices {
+public:
+  static const ErrorDiffusionMatrix& getFloydSteinberg()
+  {
+    static ErrorDiffusionMatrix matrix(3,
+                                       2,
+                                       1,
+                                       0,
+                                       {
+                                         { 0, 0, 7 },
+                                         { 3, 5, 1 }
+    },
+                                       16);
+    return matrix;
+  }
+
+  static const ErrorDiffusionMatrix& getJarvisJudiceNinke()
+  {
+    static ErrorDiffusionMatrix matrix(5,
+                                       3,
+                                       2,
+                                       0,
+                                       {
+                                         { 0, 0, 0, 7, 5 },
+                                         { 3, 5, 7, 5, 3 },
+                                         { 1, 3, 5, 3, 1 }
+    },
+                                       48);
+    return matrix;
+  }
+
+  static const ErrorDiffusionMatrix& getStucki()
+  {
+    static ErrorDiffusionMatrix matrix(5,
+                                       3,
+                                       2,
+                                       0,
+                                       {
+                                         { 0, 0, 0, 8, 4 },
+                                         { 2, 4, 8, 4, 2 },
+                                         { 1, 2, 4, 2, 1 }
+    },
+                                       42);
+    return matrix;
+  }
+
+  static const ErrorDiffusionMatrix& getAtkinson()
+  {
+    static ErrorDiffusionMatrix matrix(4,
+                                       3,
+                                       1,
+                                       0,
+                                       {
+                                         { 0, 0, 1, 1 },
+                                         { 1, 1, 1, 0 },
+                                         { 0, 1, 0, 0 }
+    },
+                                       8);
+    return matrix;
+  }
+
+  static const ErrorDiffusionMatrix& getBurkes()
+  {
+    static ErrorDiffusionMatrix matrix(5,
+                                       2,
+                                       2,
+                                       0,
+                                       {
+                                         { 0, 0, 0, 8, 4 },
+                                         { 2, 4, 8, 4, 2 }
+    },
+                                       32);
+    return matrix;
+  }
+
+  static const ErrorDiffusionMatrix& getSierra()
+  {
+    static ErrorDiffusionMatrix matrix(5,
+                                       3,
+                                       2,
+                                       0,
+                                       {
+                                         { 0, 0, 0, 5, 3 },
+                                         { 2, 4, 5, 4, 2 },
+                                         { 0, 2, 3, 2, 0 }
+    },
+                                       32);
+    return matrix;
+  }
+};
+
+ErrorDiffusionDither::ErrorDiffusionDither(ErrorDiffusionType type, int transparentIndex)
   : m_transparentIndex(transparentIndex)
+  , m_diffusionType(type)
 {
 }
 
+const ErrorDiffusionMatrix& ErrorDiffusionDither::getCurrentMatrix() const
+{
+  switch (m_diffusionType) {
+    case ErrorDiffusionType::JarvisJudiceNinke:
+      return ErrorDiffusionMatrices::getJarvisJudiceNinke();
+    case ErrorDiffusionType::Stucki:         return ErrorDiffusionMatrices::getStucki();
+    case ErrorDiffusionType::Atkinson:       return ErrorDiffusionMatrices::getAtkinson();
+    case ErrorDiffusionType::Burkes:         return ErrorDiffusionMatrices::getBurkes();
+    case ErrorDiffusionType::Sierra:         return ErrorDiffusionMatrices::getSierra();
+    case ErrorDiffusionType::FloydSteinberg: return ErrorDiffusionMatrices::getFloydSteinberg();
+  }
+}
+
 void ErrorDiffusionDither::start(const doc::Image* srcImage,
                                  doc::Image* dstImage,
                                  const double factor)
 {
   m_srcImage = srcImage;
   m_width = 2 + srcImage->width();
+
+  // Get the current matrix to determine buffer size needed
+  const ErrorDiffusionMatrix& matrix = getCurrentMatrix();
+  int bufferRows = matrix.height;
+
+  // Resize error buffers to accommodate the matrix height
   for (int i = 0; i < kChannels; ++i)
-    m_err[i].resize(m_width * 2, 0);
+    m_err[i].resize(m_width * bufferRows, 0);
+
   m_lastY = -1;
   m_factor = int(factor * 100.0);
 }
@@ -44,28 +158,34 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
                                                       const doc::RgbMap* rgbmap,
                                                       const doc::Palette* palette)
 {
+  const ErrorDiffusionMatrix& matrix = getCurrentMatrix();
+
   if (y != m_lastY) {
     for (int i = 0; i < kChannels; ++i) {
-      int* row0 = &m_err[i][0];
-      int* row1 = row0 + m_width;
-      int* end1 = row1 + m_width;
-      std::copy(row1, end1, row0);
-      std::fill(row1, end1, 0);
+      // Shift error rows up
+      for (int row = 0; row < matrix.height - 1; ++row) {
+        int* srcRow = &m_err[i][m_width * (row + 1)];
+        int* dstRow = &m_err[i][m_width * row];
+        std::copy(srcRow, srcRow + m_width, dstRow);
+      }
+      // Clear the last row
+      int* lastRow = &m_err[i][m_width * (matrix.height - 1)];
+      std::fill(lastRow, lastRow + m_width, 0);
     }
     m_lastY = y;
   }
 
   doc::color_t color = doc::get_pixel_fast<doc::RgbTraits>(m_srcImage, x, y);
 
-  // Get RGB values + quatization error
+  // Get RGB values + quantization error
   int v[kChannels] = { doc::rgba_getr(color),
                        doc::rgba_getg(color),
                        doc::rgba_getb(color),
                        doc::rgba_geta(color) };
-  for (int i = 0; i < kChannels; ++i) {
-    v[i] += m_err[i][x + 1];
-    v[i] = std::clamp(v[i], 0, 255);
-  }
+
+  // Add accumulated error (16-bit fixed point) and convert to 0..255
+  for (int i = 0; i < kChannels; ++i)
+    v[i] = std::clamp(((v[i] << 16) + m_err[i][x + 1] + 32767) >> 16, 0, 255);
 
   const doc::color_t index = (rgbmap ?
                                 rgbmap->mapColor(v[0], v[1], v[2], v[3]) :
@@ -82,26 +202,34 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
                                       v[2] - doc::rgba_getb(palColor),
                                       v[3] - doc::rgba_geta(palColor) };
 
-  // TODO using Floyd-Steinberg matrix here but it should be configurable
-  for (int i = 0; i < kChannels; ++i) {
-    int* err = &m_err[i][x];
-    const int q = quantError[i] * m_factor / 100;
-    const int a = q * 7 / 16;
-    const int b = q * 3 / 16;
-    const int c = q * 5 / 16;
-    const int d = q * 1 / 16;
+  const int srcWidth = m_srcImage->width();
 
-    if (y & 1) {
-      err[0] += a;
-      err[m_width + 2] += b;
-      err[m_width + 1] += c;
-      err[m_width] += d;
-    }
-    else {
-      err[+2] += a;
-      err[m_width] += b;
-      err[m_width + 1] += c;
-      err[m_width + 2] += d;
+  // Distribute error using the configurable matrix
+  for (int i = 0; i < kChannels; ++i) {
+    const int qerr = quantError[i] * m_factor / 100;
+
+    for (int my = 0; my < matrix.height; ++my) {
+      for (int mx = 0; mx < matrix.width; ++mx) {
+        int coeff = matrix.coefficients[my][mx];
+        if (coeff == 0)
+          continue;
+
+        int errorPixelX = x + mx - matrix.centerX;
+        int errorPixelY = y + my - matrix.centerY;
+
+        // Check bounds
+        if (errorPixelX < 0 || errorPixelX >= srcWidth)
+          continue;
+        if (errorPixelY < y)
+          continue; // Don't go backwards
+
+        // Calculate error as 16-bit fixed point
+        int errorValue = ((qerr * coeff) << 16) / matrix.divisor;
+        int bufferRow = my;
+        int bufferIndex = bufferRow * m_width + errorPixelX + 1;
+
+        m_err[i][bufferIndex] += errorValue;
+      }
     }
   }
 
diff --git a/src/render/error_diffusion.h b/src/render/error_diffusion.h
index 14e677b16..b34557bae 100644
--- a/src/render/error_diffusion.h
+++ b/src/render/error_diffusion.h
@@ -16,11 +16,42 @@
 
 namespace render {
 
+enum class ErrorDiffusionType {
+  FloydSteinberg,
+  JarvisJudiceNinke,
+  Stucki,
+  Atkinson,
+  Burkes,
+  Sierra
+};
+
+// Error diffusion matrix structure
+struct ErrorDiffusionMatrix {
+  int width, height;
+  int centerX, centerY;
+  std::vector<std::vector<int>> coefficients;
+  int divisor;
+
+  ErrorDiffusionMatrix(int w,
+                       int h,
+                       int cx,
+                       int cy,
+                       const std::vector<std::vector<int>>& coeff,
+                       int div)
+    : width(w)
+    , height(h)
+    , centerX(cx)
+    , centerY(cy)
+    , coefficients(coeff)
+    , divisor(div)
+  {
+  }
+};
+
 class ErrorDiffusionDither : public DitheringAlgorithmBase {
 public:
-  ErrorDiffusionDither(int transparentIndex = -1);
+  ErrorDiffusionDither(ErrorDiffusionType type, int transparentIndex);
   int dimensions() const override { return 2; }
-  bool zigZag() const override { return true; }
   void start(const doc::Image* srcImage, doc::Image* dstImage, const double factor) override;
   void finish() override;
   doc::color_t ditherRgbToIndex2D(const int x,
@@ -29,7 +60,10 @@ public:
                                   const doc::Palette* palette) override;
 
 private:
+  const ErrorDiffusionMatrix& getCurrentMatrix() const;
+
   int m_transparentIndex;
+  ErrorDiffusionType m_diffusionType;
   const doc::Image* m_srcImage;
   int m_width, m_lastY;
   static const int kChannels = 4;
diff --git a/src/render/ordered_dither.cpp b/src/render/ordered_dither.cpp
index 798c1d5dc..b27b41492 100644
--- a/src/render/ordered_dither.cpp
+++ b/src/render/ordered_dither.cpp
@@ -254,7 +254,7 @@ void dither_rgb_image_to_indexed(DitheringAlgorithmBase& algorithm,
   }
   else {
     auto dstIt = doc::get_pixel_address_fast<doc::IndexedTraits>(dstImage, 0, 0);
-    const bool zigZag = algorithm.zigZag();
+    auto zigZag = dithering.zigzag();
 
     for (int y = 0; y < h; ++y) {
       if (zigZag && (y & 1)) { // Odd row: go from right-to-left
@@ -269,7 +269,7 @@ void dither_rgb_image_to_indexed(DitheringAlgorithmBase& algorithm,
         }
         dstIt += w + 1;
       }
-      else { // Even row: go fromo left-to-right
+      else { // Even row: go from left-to-right
         for (int x = 0; x < w; ++x, ++dstIt) {
           ASSERT(dstIt == doc::get_pixel_address_fast<doc::IndexedTraits>(dstImage, x, y));
           *dstIt = algorithm.ditherRgbToIndex2D(x, y, rgbmap, palette);
diff --git a/src/render/ordered_dither.h b/src/render/ordered_dither.h
index 61f961d7c..849155528 100644
--- a/src/render/ordered_dither.h
+++ b/src/render/ordered_dither.h
@@ -27,7 +27,6 @@ public:
   virtual ~DitheringAlgorithmBase() {}
 
   virtual int dimensions() const { return 1; }
-  virtual bool zigZag() const { return false; }
 
   virtual void start(const doc::Image* srcImage, doc::Image* dstImage, const double factor) {}
 
diff --git a/src/render/quantization.cpp b/src/render/quantization.cpp
index 072f9f749..48b4fa5dd 100644
--- a/src/render/quantization.cpp
+++ b/src/render/quantization.cpp
@@ -159,8 +159,29 @@ Image* convert_pixel_format(const Image* image,
       case DitheringAlgorithm::Old:
         dither.reset(new OrderedDither(is_background ? -1 : new_mask_color));
         break;
-      case DitheringAlgorithm::ErrorDiffusion:
-        dither.reset(new ErrorDiffusionDither(is_background ? -1 : new_mask_color));
+      case DitheringAlgorithm::FloydSteinberg:
+        dither.reset(new ErrorDiffusionDither(ErrorDiffusionType::FloydSteinberg,
+                                              is_background ? -1 : new_mask_color));
+        break;
+      case DitheringAlgorithm::JarvisJudiceNinke:
+        dither.reset(new ErrorDiffusionDither(ErrorDiffusionType::JarvisJudiceNinke,
+                                              is_background ? -1 : new_mask_color));
+        break;
+      case DitheringAlgorithm::Stucki:
+        dither.reset(new ErrorDiffusionDither(ErrorDiffusionType::Stucki,
+                                              is_background ? -1 : new_mask_color));
+        break;
+      case DitheringAlgorithm::Atkinson:
+        dither.reset(new ErrorDiffusionDither(ErrorDiffusionType::Atkinson,
+                                              is_background ? -1 : new_mask_color));
+        break;
+      case DitheringAlgorithm::Burkes:
+        dither.reset(new ErrorDiffusionDither(ErrorDiffusionType::Burkes,
+                                              is_background ? -1 : new_mask_color));
+        break;
+      case DitheringAlgorithm::Sierra:
+        dither.reset(new ErrorDiffusionDither(ErrorDiffusionType::Sierra,
+                                              is_background ? -1 : new_mask_color));
         break;
     }
     if (dither)
diff --git a/src/render/quantization.h b/src/render/quantization.h
index 7b154b7cd..380a6f51b 100644
--- a/src/render/quantization.h
+++ b/src/render/quantization.h
@@ -1,4 +1,4 @@
-// Aseprite Rener Library
+// Aseprite Render Library
 // Copyright (c) 2019-2021  Igara Studio S.A.
 // Copyright (c) 2001-2017  David Capello
 //

From d6129359c4f914dd6a45287d490bab90940c512e Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Fri, 13 Jun 2025 17:45:32 +0100
Subject: [PATCH 02/11] Adopt clang-tidy suggestions

---
 src/render/error_diffusion.cpp | 121 +++++++++++++++++----------------
 src/render/error_diffusion.h   |   2 +-
 2 files changed, 62 insertions(+), 61 deletions(-)

diff --git a/src/render/error_diffusion.cpp b/src/render/error_diffusion.cpp
index 4419aa0b9..094c121c9 100644
--- a/src/render/error_diffusion.cpp
+++ b/src/render/error_diffusion.cpp
@@ -24,89 +24,89 @@ class ErrorDiffusionMatrices {
 public:
   static const ErrorDiffusionMatrix& getFloydSteinberg()
   {
-    static ErrorDiffusionMatrix matrix(3,
-                                       2,
-                                       1,
-                                       0,
-                                       {
-                                         { 0, 0, 7 },
-                                         { 3, 5, 1 }
+    static const ErrorDiffusionMatrix matrix(3,
+                                             2,
+                                             1,
+                                             0,
+                                             {
+                                               { 0, 0, 7 },
+                                               { 3, 5, 1 }
     },
-                                       16);
+                                             16);
     return matrix;
   }
 
   static const ErrorDiffusionMatrix& getJarvisJudiceNinke()
   {
-    static ErrorDiffusionMatrix matrix(5,
-                                       3,
-                                       2,
-                                       0,
-                                       {
-                                         { 0, 0, 0, 7, 5 },
-                                         { 3, 5, 7, 5, 3 },
-                                         { 1, 3, 5, 3, 1 }
+    static const ErrorDiffusionMatrix matrix(5,
+                                             3,
+                                             2,
+                                             0,
+                                             {
+                                               { 0, 0, 0, 7, 5 },
+                                               { 3, 5, 7, 5, 3 },
+                                               { 1, 3, 5, 3, 1 }
     },
-                                       48);
+                                             48);
     return matrix;
   }
 
   static const ErrorDiffusionMatrix& getStucki()
   {
-    static ErrorDiffusionMatrix matrix(5,
-                                       3,
-                                       2,
-                                       0,
-                                       {
-                                         { 0, 0, 0, 8, 4 },
-                                         { 2, 4, 8, 4, 2 },
-                                         { 1, 2, 4, 2, 1 }
+    static const ErrorDiffusionMatrix matrix(5,
+                                             3,
+                                             2,
+                                             0,
+                                             {
+                                               { 0, 0, 0, 8, 4 },
+                                               { 2, 4, 8, 4, 2 },
+                                               { 1, 2, 4, 2, 1 }
     },
-                                       42);
+                                             42);
     return matrix;
   }
 
   static const ErrorDiffusionMatrix& getAtkinson()
   {
-    static ErrorDiffusionMatrix matrix(4,
-                                       3,
-                                       1,
-                                       0,
-                                       {
-                                         { 0, 0, 1, 1 },
-                                         { 1, 1, 1, 0 },
-                                         { 0, 1, 0, 0 }
+    static const ErrorDiffusionMatrix matrix(4,
+                                             3,
+                                             1,
+                                             0,
+                                             {
+                                               { 0, 0, 1, 1 },
+                                               { 1, 1, 1, 0 },
+                                               { 0, 1, 0, 0 }
     },
-                                       8);
+                                             8);
     return matrix;
   }
 
   static const ErrorDiffusionMatrix& getBurkes()
   {
-    static ErrorDiffusionMatrix matrix(5,
-                                       2,
-                                       2,
-                                       0,
-                                       {
-                                         { 0, 0, 0, 8, 4 },
-                                         { 2, 4, 8, 4, 2 }
+    static const ErrorDiffusionMatrix matrix(5,
+                                             2,
+                                             2,
+                                             0,
+                                             {
+                                               { 0, 0, 0, 8, 4 },
+                                               { 2, 4, 8, 4, 2 }
     },
-                                       32);
+                                             32);
     return matrix;
   }
 
   static const ErrorDiffusionMatrix& getSierra()
   {
-    static ErrorDiffusionMatrix matrix(5,
-                                       3,
-                                       2,
-                                       0,
-                                       {
-                                         { 0, 0, 0, 5, 3 },
-                                         { 2, 4, 5, 4, 2 },
-                                         { 0, 2, 3, 2, 0 }
+    static const ErrorDiffusionMatrix matrix(5,
+                                             3,
+                                             2,
+                                             0,
+                                             {
+                                               { 0, 0, 0, 5, 3 },
+                                               { 2, 4, 5, 4, 2 },
+                                               { 0, 2, 3, 2, 0 }
     },
-                                       32);
+                                             32);
     return matrix;
   }
 };
@@ -139,11 +139,12 @@ void ErrorDiffusionDither::start(const doc::Image* srcImage,
 
   // Get the current matrix to determine buffer size needed
   const ErrorDiffusionMatrix& matrix = getCurrentMatrix();
-  int bufferRows = matrix.height;
+  const int bufferRows = matrix.height;
 
   // Resize error buffers to accommodate the matrix height
+  std::vector<int>::size_type bufferSize = m_width * bufferRows;
   for (int i = 0; i < kChannels; ++i)
-    m_err[i].resize(m_width * bufferRows, 0);
+    m_err[i].resize(bufferSize, 0);
 
   m_lastY = -1;
   m_factor = int(factor * 100.0);
@@ -210,12 +211,12 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
 
     for (int my = 0; my < matrix.height; ++my) {
       for (int mx = 0; mx < matrix.width; ++mx) {
-        int coeff = matrix.coefficients[my][mx];
+        const int coeff = matrix.coefficients[my][mx];
         if (coeff == 0)
           continue;
 
-        int errorPixelX = x + mx - matrix.centerX;
-        int errorPixelY = y + my - matrix.centerY;
+        const int errorPixelX = x + mx - matrix.centerX;
+        const int errorPixelY = y + my - matrix.centerY;
 
         // Check bounds
         if (errorPixelX < 0 || errorPixelX >= srcWidth)
@@ -224,9 +225,9 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
           continue; // Don't go backwards
 
         // Calculate error as 16-bit fixed point
-        int errorValue = ((qerr * coeff) << 16) / matrix.divisor;
-        int bufferRow = my;
-        int bufferIndex = bufferRow * m_width + errorPixelX + 1;
+        const int errorValue = ((qerr * coeff) << 16) / matrix.divisor;
+        const int bufferRow = my;
+        const int bufferIndex = bufferRow * m_width + errorPixelX + 1;
 
         m_err[i][bufferIndex] += errorValue;
       }
diff --git a/src/render/error_diffusion.h b/src/render/error_diffusion.h
index b34557bae..f30e3c104 100644
--- a/src/render/error_diffusion.h
+++ b/src/render/error_diffusion.h
@@ -16,7 +16,7 @@
 
 namespace render {
 
-enum class ErrorDiffusionType {
+enum class ErrorDiffusionType : uint8_t {
   FloydSteinberg,
   JarvisJudiceNinke,
   Stucki,

From b43e3e6ac17a00abc2060a2b64e3730e1764d6de Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Fri, 13 Jun 2025 14:27:28 +0100
Subject: [PATCH 03/11] Avoid copying error buffers around

# Conflicts:
#	src/render/error_diffusion.cpp
---
 src/render/error_diffusion.cpp | 37 ++++++++++++++++++++--------------
 src/render/error_diffusion.h   |  1 +
 2 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/src/render/error_diffusion.cpp b/src/render/error_diffusion.cpp
index 094c121c9..f4fe13018 100644
--- a/src/render/error_diffusion.cpp
+++ b/src/render/error_diffusion.cpp
@@ -147,6 +147,7 @@ void ErrorDiffusionDither::start(const doc::Image* srcImage,
     m_err[i].resize(bufferSize, 0);
 
   m_lastY = -1;
+  m_currentRowOffset = 0;
   m_factor = int(factor * 100.0);
 }
 
@@ -162,17 +163,17 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
   const ErrorDiffusionMatrix& matrix = getCurrentMatrix();
 
   if (y != m_lastY) {
-    for (int i = 0; i < kChannels; ++i) {
-      // Shift error rows up
-      for (int row = 0; row < matrix.height - 1; ++row) {
-        int* srcRow = &m_err[i][m_width * (row + 1)];
-        int* dstRow = &m_err[i][m_width * row];
-        std::copy(srcRow, srcRow + m_width, dstRow);
-      }
-      // Clear the last row
-      int* lastRow = &m_err[i][m_width * (matrix.height - 1)];
-      std::fill(lastRow, lastRow + m_width, 0);
+    // Instead of shifting all rows, just advance the circular buffer
+    // and clear the row that will be reused
+    m_currentRowOffset = (m_currentRowOffset + 1) % matrix.height;
+
+    // Clear only the row that will be used as the "last" row
+    int clearRowIndex = (m_currentRowOffset + matrix.height - 1) % matrix.height;
+    for (int c = 0; c < kChannels; ++c) {
+      int* rowToClear = &m_err[c][m_width * clearRowIndex];
+      std::fill(rowToClear, rowToClear + m_width, 0);
     }
+
     m_lastY = y;
   }
 
@@ -185,8 +186,10 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
                        doc::rgba_geta(color) };
 
   // Add accumulated error (16-bit fixed point) and convert to 0..255
-  for (int i = 0; i < kChannels; ++i)
-    v[i] = std::clamp(((v[i] << 16) + m_err[i][x + 1] + 32767) >> 16, 0, 255);
+  for (int c = 0; c < kChannels; ++c)
+    v[c] = std::clamp(((v[c] << 16) + m_err[c][m_width * m_currentRowOffset + x + 1] + 32767) >> 16,
+                      0,
+                      255);
 
   const doc::color_t index = (rgbmap ?
                                 rgbmap->mapColor(v[0], v[1], v[2], v[3]) :
@@ -206,10 +209,14 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
   const int srcWidth = m_srcImage->width();
 
   // Distribute error using the configurable matrix
-  for (int i = 0; i < kChannels; ++i) {
-    const int qerr = quantError[i] * m_factor / 100;
+  for (int c = 0; c < kChannels; ++c) {
+    const int qerr = quantError[c] * m_factor / 100;
 
     for (int my = 0; my < matrix.height; ++my) {
+      // Use circular buffer indexing
+      int bufferRow = (m_currentRowOffset + my) % matrix.height; // hoist
+      int bufferRowIndex = bufferRow * m_width;
+
       for (int mx = 0; mx < matrix.width; ++mx) {
         const int coeff = matrix.coefficients[my][mx];
         if (coeff == 0)
@@ -229,7 +236,7 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
         const int bufferRow = my;
         const int bufferIndex = bufferRow * m_width + errorPixelX + 1;
 
-        m_err[i][bufferIndex] += errorValue;
+        m_err[c][bufferRowIndex + errorPixelX + 1] += errorValue;
       }
     }
   }
diff --git a/src/render/error_diffusion.h b/src/render/error_diffusion.h
index f30e3c104..bbe5b1369 100644
--- a/src/render/error_diffusion.h
+++ b/src/render/error_diffusion.h
@@ -66,6 +66,7 @@ private:
   ErrorDiffusionType m_diffusionType;
   const doc::Image* m_srcImage;
   int m_width, m_lastY;
+  int m_currentRowOffset;
   static const int kChannels = 4;
   std::vector<int> m_err[kChannels];
   int m_factor;

From 87fc82a978cee6ad999b8cd9a5126889f2ba4fd8 Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Fri, 13 Jun 2025 16:53:42 +0100
Subject: [PATCH 04/11] Flip dither matrix when zig-zagging

---
 src/render/error_diffusion.cpp | 7 ++++---
 src/render/error_diffusion.h   | 3 ++-
 src/render/ordered_dither.cpp  | 4 ++--
 src/render/ordered_dither.h    | 3 ++-
 4 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/render/error_diffusion.cpp b/src/render/error_diffusion.cpp
index f4fe13018..c3fe905ba 100644
--- a/src/render/error_diffusion.cpp
+++ b/src/render/error_diffusion.cpp
@@ -158,7 +158,8 @@ void ErrorDiffusionDither::finish()
 doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
                                                       const int y,
                                                       const doc::RgbMap* rgbmap,
-                                                      const doc::Palette* palette)
+                                                      const doc::Palette* palette,
+                                                      const int direction)
 {
   const ErrorDiffusionMatrix& matrix = getCurrentMatrix();
 
@@ -214,11 +215,11 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
 
     for (int my = 0; my < matrix.height; ++my) {
       // Use circular buffer indexing
-      int bufferRow = (m_currentRowOffset + my) % matrix.height; // hoist
+      int bufferRow = (m_currentRowOffset + my) % matrix.height;
       int bufferRowIndex = bufferRow * m_width;
 
       for (int mx = 0; mx < matrix.width; ++mx) {
-        const int coeff = matrix.coefficients[my][mx];
+        const int coeff = direction > 0 ? matrix.coefficients[my][mx] : matrix.coefficients[my][matrix.width - 1 - mx];
         if (coeff == 0)
           continue;
 
diff --git a/src/render/error_diffusion.h b/src/render/error_diffusion.h
index bbe5b1369..1d4d8db79 100644
--- a/src/render/error_diffusion.h
+++ b/src/render/error_diffusion.h
@@ -57,7 +57,8 @@ public:
   doc::color_t ditherRgbToIndex2D(const int x,
                                   const int y,
                                   const doc::RgbMap* rgbmap,
-                                  const doc::Palette* palette) override;
+                                  const doc::Palette* palette,
+                                  const int direction) override;
 
 private:
   const ErrorDiffusionMatrix& getCurrentMatrix() const;
diff --git a/src/render/ordered_dither.cpp b/src/render/ordered_dither.cpp
index b27b41492..400200147 100644
--- a/src/render/ordered_dither.cpp
+++ b/src/render/ordered_dither.cpp
@@ -261,7 +261,7 @@ void dither_rgb_image_to_indexed(DitheringAlgorithmBase& algorithm,
         dstIt += w - 1;
         for (int x = w - 1; x >= 0; --x, --dstIt) {
           ASSERT(dstIt == doc::get_pixel_address_fast<doc::IndexedTraits>(dstImage, x, y));
-          *dstIt = algorithm.ditherRgbToIndex2D(x, y, rgbmap, palette);
+          *dstIt = algorithm.ditherRgbToIndex2D(x, y, rgbmap, palette, -1);
           if (delegate) {
             if (!delegate->continueTask())
               return;
@@ -272,7 +272,7 @@ void dither_rgb_image_to_indexed(DitheringAlgorithmBase& algorithm,
       else { // Even row: go from left-to-right
         for (int x = 0; x < w; ++x, ++dstIt) {
           ASSERT(dstIt == doc::get_pixel_address_fast<doc::IndexedTraits>(dstImage, x, y));
-          *dstIt = algorithm.ditherRgbToIndex2D(x, y, rgbmap, palette);
+          *dstIt = algorithm.ditherRgbToIndex2D(x, y, rgbmap, palette, +1);
 
           if (delegate) {
             if (!delegate->continueTask())
diff --git a/src/render/ordered_dither.h b/src/render/ordered_dither.h
index 849155528..7cb8dba3a 100644
--- a/src/render/ordered_dither.h
+++ b/src/render/ordered_dither.h
@@ -45,7 +45,8 @@ public:
   virtual doc::color_t ditherRgbToIndex2D(const int x,
                                           const int y,
                                           const doc::RgbMap* rgbmap,
-                                          const doc::Palette* palette)
+                                          const doc::Palette* palette,
+                                          const int direction)
   {
     return 0;
   }

From 484f8d69bf1a294f7bf750b8180643d039c04e11 Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Fri, 13 Jun 2025 15:36:18 +0100
Subject: [PATCH 05/11] Check continueTask per-line, not per-pixel

---
 src/render/ordered_dither.cpp | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/src/render/ordered_dither.cpp b/src/render/ordered_dither.cpp
index 400200147..c41d6053f 100644
--- a/src/render/ordered_dither.cpp
+++ b/src/render/ordered_dither.cpp
@@ -240,14 +240,11 @@ void dither_rgb_image_to_indexed(DitheringAlgorithmBase& algorithm,
         ASSERT(srcIt != srcBits.end());
         ASSERT(dstIt != dstBits.end());
         *dstIt = algorithm.ditherRgbPixelToIndex(dithering.matrix(), *srcIt, x, y, rgbmap, palette);
-
-        if (delegate) {
-          if (!delegate->continueTask())
-            return;
-        }
       }
 
       if (delegate) {
+        if (!delegate->continueTask())
+          return;
         delegate->notifyTaskProgress(double(y + 1) / double(h));
       }
     }
@@ -262,10 +259,6 @@ void dither_rgb_image_to_indexed(DitheringAlgorithmBase& algorithm,
         for (int x = w - 1; x >= 0; --x, --dstIt) {
           ASSERT(dstIt == doc::get_pixel_address_fast<doc::IndexedTraits>(dstImage, x, y));
           *dstIt = algorithm.ditherRgbToIndex2D(x, y, rgbmap, palette, -1);
-          if (delegate) {
-            if (!delegate->continueTask())
-              return;
-          }
         }
         dstIt += w + 1;
       }
@@ -273,14 +266,12 @@ void dither_rgb_image_to_indexed(DitheringAlgorithmBase& algorithm,
         for (int x = 0; x < w; ++x, ++dstIt) {
           ASSERT(dstIt == doc::get_pixel_address_fast<doc::IndexedTraits>(dstImage, x, y));
           *dstIt = algorithm.ditherRgbToIndex2D(x, y, rgbmap, palette, +1);
-
-          if (delegate) {
-            if (!delegate->continueTask())
-              return;
-          }
         }
       }
+
       if (delegate) {
+        if (!delegate->continueTask())
+          return;
         delegate->notifyTaskProgress(double(y + 1) / double(h));
       }
     }

From 4c5f5249d8375a5c7b1aab6a2aae4c2b802e84d1 Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Sat, 14 Jun 2025 14:37:36 +0100
Subject: [PATCH 06/11] Fix transposed arg, add consts

---
 src/app/commands/cmd_change_pixel_format.cpp | 12 +++++++-----
 src/render/error_diffusion.cpp               | 11 ++++-------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/src/app/commands/cmd_change_pixel_format.cpp b/src/app/commands/cmd_change_pixel_format.cpp
index 3a216deb7..c902cb131 100644
--- a/src/app/commands/cmd_change_pixel_format.cpp
+++ b/src/app/commands/cmd_change_pixel_format.cpp
@@ -583,11 +583,13 @@ void ChangePixelFormatCommand::onExecute(Context* ctx)
     if (window.closer() != window.ok())
       return;
 
+    const auto d = window.dithering();
+
     params().colorMode(window.selectedColorMode());
-    params().dithering(window.dithering().algorithm());
-    matrix = window.dithering().matrix();
-    params().factor(window.dithering().factor());
-    params().zigZag(window.dithering().zigzag());
+    params().dithering(d.algorithm());
+    matrix = d.matrix();
+    params().factor(d.factor());
+    params().zigZag(d.zigzag());
     params().rgbmap(window.rgbMapAlgorithm());
     params().fitCriteria(window.fitCriteria());
     params().toGray(window.toGray());
@@ -634,7 +636,7 @@ void ChangePixelFormatCommand::onExecute(Context* ctx)
       tx(new cmd::SetPixelFormat(
         sprite,
         (PixelFormat)params().colorMode(),
-        render::Dithering(params().dithering(), matrix, params().factor(), params().zigZag()),
+        render::Dithering(params().dithering(), matrix, params().zigZag(), params().factor()),
         params().rgbmap(),
         get_gray_func(params().toGray()),
         &job, // SpriteJob is a render::TaskDelegate
diff --git a/src/render/error_diffusion.cpp b/src/render/error_diffusion.cpp
index c3fe905ba..a5aced534 100644
--- a/src/render/error_diffusion.cpp
+++ b/src/render/error_diffusion.cpp
@@ -142,7 +142,7 @@ void ErrorDiffusionDither::start(const doc::Image* srcImage,
   const int bufferRows = matrix.height;
 
   // Resize error buffers to accommodate the matrix height
-  std::vector<int>::size_type bufferSize = m_width * bufferRows;
+  const std::vector<int>::size_type bufferSize = m_width * bufferRows;
   for (int i = 0; i < kChannels; ++i)
     m_err[i].resize(bufferSize, 0);
 
@@ -169,7 +169,7 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
     m_currentRowOffset = (m_currentRowOffset + 1) % matrix.height;
 
     // Clear only the row that will be used as the "last" row
-    int clearRowIndex = (m_currentRowOffset + matrix.height - 1) % matrix.height;
+    const int clearRowIndex = (m_currentRowOffset + matrix.height - 1) % matrix.height;
     for (int c = 0; c < kChannels; ++c) {
       int* rowToClear = &m_err[c][m_width * clearRowIndex];
       std::fill(rowToClear, rowToClear + m_width, 0);
@@ -215,8 +215,8 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
 
     for (int my = 0; my < matrix.height; ++my) {
       // Use circular buffer indexing
-      int bufferRow = (m_currentRowOffset + my) % matrix.height;
-      int bufferRowIndex = bufferRow * m_width;
+      const int bufferRow = (m_currentRowOffset + my) % matrix.height;
+      const int bufferRowIndex = bufferRow * m_width;
 
       for (int mx = 0; mx < matrix.width; ++mx) {
         const int coeff = direction > 0 ? matrix.coefficients[my][mx] : matrix.coefficients[my][matrix.width - 1 - mx];
@@ -234,9 +234,6 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
 
         // Calculate error as 16-bit fixed point
         const int errorValue = ((qerr * coeff) << 16) / matrix.divisor;
-        const int bufferRow = my;
-        const int bufferIndex = bufferRow * m_width + errorPixelX + 1;
-
         m_err[c][bufferRowIndex + errorPixelX + 1] += errorValue;
       }
     }

From 4e5ae492e598e4435ef375231ccbb2949ec93c62 Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Fri, 20 Jun 2025 13:21:14 +0100
Subject: [PATCH 07/11] Factor out dither algorithm-to-name mappings

---
 src/app/cli/cli_processor.cpp                | 34 ++-----------
 src/app/commands/cmd_change_pixel_format.cpp |  5 +-
 src/app/commands/new_params.cpp              | 23 ++-------
 src/render/CMakeLists.txt                    |  1 +
 src/render/dithering_algorithm.cpp           | 52 ++++++++++++++++++++
 src/render/dithering_algorithm.h             | 15 +++---
 6 files changed, 71 insertions(+), 59 deletions(-)
 create mode 100644 src/render/dithering_algorithm.cpp

diff --git a/src/app/cli/cli_processor.cpp b/src/app/cli/cli_processor.cpp
index 4984d6236..70a9116a7 100644
--- a/src/app/cli/cli_processor.cpp
+++ b/src/app/cli/cli_processor.cpp
@@ -447,29 +447,13 @@ int CliProcessor::process(Context* ctx)
         }
         // --dithering-algorithm <algorithm>
         else if (opt == &m_options.ditheringAlgorithm()) {
-          if (value.value() == "none")
-            ditheringAlgorithm = render::DitheringAlgorithm::None;
-          else if (value.value() == "ordered")
-            ditheringAlgorithm = render::DitheringAlgorithm::Ordered;
-          else if (value.value() == "old")
-            ditheringAlgorithm = render::DitheringAlgorithm::Old;
-          else if (value.value() == "error-diffusion" || value.value() == "floyd-steinberg")
-            ditheringAlgorithm = render::DitheringAlgorithm::FloydSteinberg;
-          else if (value.value() == "jarvis-judice-ninke")
-            ditheringAlgorithm = render::DitheringAlgorithm::JarvisJudiceNinke;
-          else if (value.value() == "stucki")
-            ditheringAlgorithm = render::DitheringAlgorithm::Stucki;
-          else if (value.value() == "atkinson")
-            ditheringAlgorithm = render::DitheringAlgorithm::Atkinson;
-          else if (value.value() == "burkes")
-            ditheringAlgorithm = render::DitheringAlgorithm::Burkes;
-          else if (value.value() == "sierra")
-            ditheringAlgorithm = render::DitheringAlgorithm::Sierra;
-          else
+          ditheringAlgorithm = render::DitheringAlgorithmFromString(value.value());
+          if (ditheringAlgorithm == render::DitheringAlgorithm::Unknown) {
             throw std::runtime_error(
               "--dithering-algorithm needs a valid algorithm name\n"
               "Usage: --dithering-algorithm <algorithm>\n"
-              "Where <algorithm> can be none, ordered, old, or error-diffusion");
+              "Where <algorithm> can be: none, ordered, old, floyd-steinberg, jarvis-judice-ninke, stucki, atkinson, burkes or sierra.");
+          }
         }
         // --dithering-matrix <id>
         else if (opt == &m_options.ditheringMatrix()) {
@@ -487,15 +471,7 @@ int CliProcessor::process(Context* ctx)
           }
           else if (value.value() == "indexed") {
             params.set("format", "indexed");
-            switch (ditheringAlgorithm) {
-              case render::DitheringAlgorithm::None:    params.set("dithering", "none"); break;
-              case render::DitheringAlgorithm::Ordered: params.set("dithering", "ordered"); break;
-              case render::DitheringAlgorithm::Old:     params.set("dithering", "old"); break;
-              case render::DitheringAlgorithm::FloydSteinberg:
-                params.set("dithering", "error-diffusion");
-                break;
-            }
-
+            params.set("dithering", DitheringAlgorithmToString(ditheringAlgorithm).c_str());
             if (ditheringAlgorithm != render::DitheringAlgorithm::None &&
                 !ditheringMatrix.empty()) {
               params.set("dithering-matrix", ditheringMatrix.c_str());
diff --git a/src/app/commands/cmd_change_pixel_format.cpp b/src/app/commands/cmd_change_pixel_format.cpp
index c902cb131..3e6c5121f 100644
--- a/src/app/commands/cmd_change_pixel_format.cpp
+++ b/src/app/commands/cmd_change_pixel_format.cpp
@@ -332,7 +332,7 @@ public:
       if (auto item = m_ditheringSelector->getSelectedItem()) {
         pref.quantization.ditheringAlgorithm(item->text());
 
-        if (IsDiffusion(m_ditheringSelector->ditheringAlgorithm()))
+        if (DitheringAlgorithmIsDiffusion(m_ditheringSelector->ditheringAlgorithm()))
           pref.quantization.ditheringFactor(factor()->getValue());
       }
 
@@ -375,7 +375,8 @@ private:
       const bool toIndexed = (dstColorMode == doc::ColorMode::INDEXED);
       m_ditheringSelector->setVisible(toIndexed);
 
-      const bool errorDiff = (render::IsDiffusion(m_ditheringSelector->ditheringAlgorithm()));
+      const bool errorDiff =
+        (render::DitheringAlgorithmIsDiffusion(m_ditheringSelector->ditheringAlgorithm()));
       amount()->setVisible(toIndexed && errorDiff);
     }
 
diff --git a/src/app/commands/new_params.cpp b/src/app/commands/new_params.cpp
index 26cbadf01..f2505be8a 100644
--- a/src/app/commands/new_params.cpp
+++ b/src/app/commands/new_params.cpp
@@ -275,25 +275,10 @@ void Param<doc::FitCriteria>::fromString(const std::string& value)
 template<>
 void Param<render::DitheringAlgorithm>::fromString(const std::string& value)
 {
-  if (base::utf8_icmp(value, "ordered") == 0)
-    setValue(render::DitheringAlgorithm::Ordered);
-  else if (base::utf8_icmp(value, "old") == 0)
-    setValue(render::DitheringAlgorithm::Old);
-  else if (base::utf8_icmp(value, "error-diffusion") == 0 ||
-           base::utf8_icmp(value, "floyd-steinberg") == 0)
-    setValue(render::DitheringAlgorithm::FloydSteinberg);
-  else if (base::utf8_icmp(value, "jarvis-judice-ninke") == 0)
-    setValue(render::DitheringAlgorithm::JarvisJudiceNinke);
-  else if (base::utf8_icmp(value, "stucki") == 0)
-    setValue(render::DitheringAlgorithm::Stucki);
-  else if (base::utf8_icmp(value, "atkinson") == 0)
-    setValue(render::DitheringAlgorithm::Atkinson);
-  else if (base::utf8_icmp(value, "burkes") == 0)
-    setValue(render::DitheringAlgorithm::Burkes);
-  else if (base::utf8_icmp(value, "sierra") == 0)
-    setValue(render::DitheringAlgorithm::Sierra);
-  else
-    setValue(render::DitheringAlgorithm::None);
+  auto algo = render::DitheringAlgorithmFromString(value);
+  if (algo == render::DitheringAlgorithm::Unknown)
+    algo = render::DitheringAlgorithm::None;
+  setValue(algo);
 }
 
 template<>
diff --git a/src/render/CMakeLists.txt b/src/render/CMakeLists.txt
index 9e06f22ab..93ca8c176 100644
--- a/src/render/CMakeLists.txt
+++ b/src/render/CMakeLists.txt
@@ -3,6 +3,7 @@
 # Copyright (C) 2001-2018 David Capello
 
 add_library(render-lib
+  dithering_algorithm.cpp
   error_diffusion.cpp
   get_sprite_pixel.cpp
   gradient.cpp
diff --git a/src/render/dithering_algorithm.cpp b/src/render/dithering_algorithm.cpp
new file mode 100644
index 000000000..62be2d6d0
--- /dev/null
+++ b/src/render/dithering_algorithm.cpp
@@ -0,0 +1,52 @@
+// Aseprite
+// Copyright (C) 2025 Igara Studio S.A.
+//
+// This program is distributed under the terms of
+// the End-User License Agreement for Aseprite.
+
+#include <string>
+#include <unordered_map>
+
+#include "base/string.h"
+#include "render/dithering_algorithm.h"
+
+namespace render {
+
+static const std::unordered_map<DitheringAlgorithm, std::string> names = {
+  { DitheringAlgorithm::None,              "none"                },
+  { DitheringAlgorithm::Ordered,           "ordered"             },
+  { DitheringAlgorithm::Old,               "old"                 },
+  { DitheringAlgorithm::FloydSteinberg,    "floyd-steinberg"     },
+  { DitheringAlgorithm::FloydSteinberg,    "error-diffusion"     }, // alias
+  { DitheringAlgorithm::JarvisJudiceNinke, "jarvis-judice-ninke" },
+  { DitheringAlgorithm::Stucki,            "stucki"              },
+  { DitheringAlgorithm::Atkinson,          "atkinson"            },
+  { DitheringAlgorithm::Burkes,            "burkes"              },
+  { DitheringAlgorithm::Sierra,            "sierra"              },
+};
+
+bool DitheringAlgorithmIsDiffusion(DitheringAlgorithm algo)
+{
+  switch (algo) {
+    case DitheringAlgorithm::None:
+    case DitheringAlgorithm::Ordered:
+    case DitheringAlgorithm::Old:     return false;
+    default:                          return true;
+  }
+}
+
+const std::string DitheringAlgorithmToString(DitheringAlgorithm algo)
+{
+  auto it = names.find(algo);
+  return (it != names.end()) ? it->second : "unknown";
+}
+
+const DitheringAlgorithm DitheringAlgorithmFromString(std::string name)
+{
+  auto it = std::find_if(names.begin(), names.end(), [name](const auto& pair) {
+    return base::utf8_icmp(pair.second, name) == 0;
+  });
+  return (it != names.end()) ? it->first : DitheringAlgorithm::Unknown;
+}
+
+} // namespace render
diff --git a/src/render/dithering_algorithm.h b/src/render/dithering_algorithm.h
index 34ed5c093..597384786 100644
--- a/src/render/dithering_algorithm.h
+++ b/src/render/dithering_algorithm.h
@@ -9,6 +9,8 @@
 #define RENDER_DITHERING_METHOD_H_INCLUDED
 #pragma once
 
+#include <string>
+
 namespace render {
 
 // Dithering algorithms
@@ -22,17 +24,12 @@ enum class DitheringAlgorithm {
   Atkinson,
   Burkes,
   Sierra,
+  Unknown
 };
 
-inline bool IsDiffusion(DitheringAlgorithm algo)
-{
-  switch (algo) {
-    case DitheringAlgorithm::None:
-    case DitheringAlgorithm::Ordered:
-    case DitheringAlgorithm::Old:     return false;
-    default:                          return true;
-  }
-}
+bool DitheringAlgorithmIsDiffusion(DitheringAlgorithm algo);
+const std::string DitheringAlgorithmToString(DitheringAlgorithm algo);
+const DitheringAlgorithm DitheringAlgorithmFromString(std::string name);
 
 } // namespace render
 

From 2ba52d6d6c6f58ac14f0edffc67d3446511833b3 Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Sat, 21 Jun 2025 18:25:05 +0100
Subject: [PATCH 08/11] Appease the gods of const

---
 src/render/dithering_algorithm.cpp | 4 ++--
 src/render/dithering_algorithm.h   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/render/dithering_algorithm.cpp b/src/render/dithering_algorithm.cpp
index 62be2d6d0..dbbd1c641 100644
--- a/src/render/dithering_algorithm.cpp
+++ b/src/render/dithering_algorithm.cpp
@@ -35,13 +35,13 @@ bool DitheringAlgorithmIsDiffusion(DitheringAlgorithm algo)
   }
 }
 
-const std::string DitheringAlgorithmToString(DitheringAlgorithm algo)
+std::string DitheringAlgorithmToString(DitheringAlgorithm algo)
 {
   auto it = names.find(algo);
   return (it != names.end()) ? it->second : "unknown";
 }
 
-const DitheringAlgorithm DitheringAlgorithmFromString(std::string name)
+const DitheringAlgorithm DitheringAlgorithmFromString(const std::string name)
 {
   auto it = std::find_if(names.begin(), names.end(), [name](const auto& pair) {
     return base::utf8_icmp(pair.second, name) == 0;
diff --git a/src/render/dithering_algorithm.h b/src/render/dithering_algorithm.h
index 597384786..ba41ebd51 100644
--- a/src/render/dithering_algorithm.h
+++ b/src/render/dithering_algorithm.h
@@ -28,8 +28,8 @@ enum class DitheringAlgorithm {
 };
 
 bool DitheringAlgorithmIsDiffusion(DitheringAlgorithm algo);
-const std::string DitheringAlgorithmToString(DitheringAlgorithm algo);
-const DitheringAlgorithm DitheringAlgorithmFromString(std::string name);
+std::string DitheringAlgorithmToString(DitheringAlgorithm algo);
+const DitheringAlgorithm DitheringAlgorithmFromString(const std::string name);
 
 } // namespace render
 

From 8d0fa49044646ed0891c2e5a710b708546942de8 Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Mon, 23 Jun 2025 09:26:36 +0100
Subject: [PATCH 09/11] Fix missing #include <algorithm>

---
 src/render/dithering_algorithm.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/render/dithering_algorithm.cpp b/src/render/dithering_algorithm.cpp
index dbbd1c641..9b8dcfd17 100644
--- a/src/render/dithering_algorithm.cpp
+++ b/src/render/dithering_algorithm.cpp
@@ -4,6 +4,7 @@
 // This program is distributed under the terms of
 // the End-User License Agreement for Aseprite.
 
+#include <algorithm>
 #include <string>
 #include <unordered_map>
 

From f5ecead66f0080355d14a060fefe874c845054ea Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Mon, 23 Jun 2025 14:08:52 +0100
Subject: [PATCH 10/11] Hide zig zag checkbox when not dithering

---
 src/app/commands/cmd_change_pixel_format.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/app/commands/cmd_change_pixel_format.cpp b/src/app/commands/cmd_change_pixel_format.cpp
index 3e6c5121f..ccbf7ea8c 100644
--- a/src/app/commands/cmd_change_pixel_format.cpp
+++ b/src/app/commands/cmd_change_pixel_format.cpp
@@ -374,6 +374,7 @@ private:
     if (m_ditheringSelector) {
       const bool toIndexed = (dstColorMode == doc::ColorMode::INDEXED);
       m_ditheringSelector->setVisible(toIndexed);
+      m_zigZagCheck->setVisible(toIndexed);
 
       const bool errorDiff =
         (render::DitheringAlgorithmIsDiffusion(m_ditheringSelector->ditheringAlgorithm()));

From bd2ae1eb6103d5cc4cd7853e9e9d282b670b892d Mon Sep 17 00:00:00 2001
From: David Thomas <dave@davespace.co.uk>
Date: Tue, 24 Jun 2025 17:43:35 +0100
Subject: [PATCH 11/11] Appease the automatons

---
 src/render/dithering_algorithm.cpp | 2 +-
 src/render/dithering_algorithm.h   | 2 +-
 src/render/error_diffusion.cpp     | 3 ++-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/render/dithering_algorithm.cpp b/src/render/dithering_algorithm.cpp
index 9b8dcfd17..236250e14 100644
--- a/src/render/dithering_algorithm.cpp
+++ b/src/render/dithering_algorithm.cpp
@@ -42,7 +42,7 @@ std::string DitheringAlgorithmToString(DitheringAlgorithm algo)
   return (it != names.end()) ? it->second : "unknown";
 }
 
-const DitheringAlgorithm DitheringAlgorithmFromString(const std::string name)
+DitheringAlgorithm DitheringAlgorithmFromString(const std::string& name)
 {
   auto it = std::find_if(names.begin(), names.end(), [name](const auto& pair) {
     return base::utf8_icmp(pair.second, name) == 0;
diff --git a/src/render/dithering_algorithm.h b/src/render/dithering_algorithm.h
index ba41ebd51..5827975f7 100644
--- a/src/render/dithering_algorithm.h
+++ b/src/render/dithering_algorithm.h
@@ -29,7 +29,7 @@ enum class DitheringAlgorithm {
 
 bool DitheringAlgorithmIsDiffusion(DitheringAlgorithm algo);
 std::string DitheringAlgorithmToString(DitheringAlgorithm algo);
-const DitheringAlgorithm DitheringAlgorithmFromString(const std::string name);
+DitheringAlgorithm DitheringAlgorithmFromString(const std::string& name);
 
 } // namespace render
 
diff --git a/src/render/error_diffusion.cpp b/src/render/error_diffusion.cpp
index a5aced534..1d2d04add 100644
--- a/src/render/error_diffusion.cpp
+++ b/src/render/error_diffusion.cpp
@@ -219,7 +219,8 @@ doc::color_t ErrorDiffusionDither::ditherRgbToIndex2D(const int x,
       const int bufferRowIndex = bufferRow * m_width;
 
       for (int mx = 0; mx < matrix.width; ++mx) {
-        const int coeff = direction > 0 ? matrix.coefficients[my][mx] : matrix.coefficients[my][matrix.width - 1 - mx];
+        const int coeff = direction > 0 ? matrix.coefficients[my][mx] :
+                                          matrix.coefficients[my][matrix.width - 1 - mx];
         if (coeff == 0)
           continue;