From bbb6b83905e769fd283a150c7ca7aba550a1f019 Mon Sep 17 00:00:00 2001
From: David Capello <david@igarastudio.com>
Date: Fri, 10 Apr 2020 08:58:59 -0300
Subject: [PATCH 1/9] Make doc::RgbMap a regular object (don't need to be an
 doc::Object)

---
 src/doc/object_type.h | 35 ++++++++++++++++++++---------------
 src/doc/rgbmap.cpp    |  4 ++--
 src/doc/rgbmap.h      |  3 ++-
 3 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/src/doc/object_type.h b/src/doc/object_type.h
index 31f897375..d09084500 100644
--- a/src/doc/object_type.h
+++ b/src/doc/object_type.h
@@ -1,5 +1,5 @@
 // Aseprite Document Library
-// Copyright (C) 2019  Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 // Copyright (C) 2001-2017  David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -12,20 +12,25 @@
 namespace doc {
 
   enum class ObjectType {
-    Unknown,
-    Image,
-    Palette,
-    RgbMap,
-    Path,
-    Mask,
-    Cel,
-    CelData,
-    LayerImage,
-    LayerGroup,
-    Sprite,
-    Document,
-    Tag,
-    Slice,
+    Unknown = 0,
+    Image = 1,
+    Palette = 2,
+
+    // Deprecated values, we cannot re-use these indexes because
+    // backup sessions use them (check readLayer() function in
+    // src/app/crash/read_document.cpp).
+    //RgbMap = 3,
+    //Path = 4,
+
+    Mask = 5,
+    Cel = 6,
+    CelData = 7,
+    LayerImage = 8,
+    LayerGroup = 9,
+    Sprite = 10,
+    Document = 11,
+    Tag = 12,
+    Slice = 13,
   };
 
 } // namespace doc
diff --git a/src/doc/rgbmap.cpp b/src/doc/rgbmap.cpp
index 4a39dffb7..1d56fba18 100644
--- a/src/doc/rgbmap.cpp
+++ b/src/doc/rgbmap.cpp
@@ -1,4 +1,5 @@
 // Aseprite Document Library
+// Copyright (c) 2020 Igara Studio S.A.
 // Copyright (c) 2001-2015 David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -22,8 +23,7 @@ namespace doc {
 #define MAPSIZE (RSIZE*GSIZE*BSIZE*ASIZE)
 
 RgbMap::RgbMap()
-  : Object(ObjectType::RgbMap)
-  , m_map(MAPSIZE)
+  : m_map(MAPSIZE)
   , m_palette(NULL)
   , m_modifications(0)
   , m_maskIndex(0)
diff --git a/src/doc/rgbmap.h b/src/doc/rgbmap.h
index 6fa7bcd79..30ab666a3 100644
--- a/src/doc/rgbmap.h
+++ b/src/doc/rgbmap.h
@@ -1,4 +1,5 @@
 // Aseprite Document Library
+// Copyright (c) 2020 Igara Studio S.A.
 // Copyright (c) 2001-2016 David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -19,7 +20,7 @@ namespace doc {
   class Palette;
 
   // It acts like a cache for Palette:findBestfit() calls.
-  class RgbMap : public Object {
+  class RgbMap {
     // Bit activated on m_map entries that aren't yet calculated.
     const int INVALID = 256;
 

From ad31c9b7a85b42bb9221bae2e4a8f0e8ce55bab1 Mon Sep 17 00:00:00 2001
From: David Capello <david@igarastudio.com>
Date: Fri, 10 Apr 2020 10:15:04 -0300
Subject: [PATCH 2/9] Convert RgbMap into an interface and rename the old class
 to RgbMapRGB53A

---
 src/app/file/gif_format.cpp                | 13 +++--
 src/app/tools/ink_processing.h             | 31 +++--------
 src/doc/CMakeLists.txt                     |  3 +-
 src/doc/LICENSE.txt                        |  2 +-
 src/doc/doc.h                              |  3 +-
 src/doc/rgbmap.h                           | 40 ++++----------
 src/doc/{rgbmap.cpp => rgbmap_rgb5a3.cpp}  | 10 ++--
 src/doc/rgbmap_rgb5a3.h                    | 61 ++++++++++++++++++++++
 src/doc/sprite.cpp                         |  4 +-
 src/doc/sprite.h                           |  5 +-
 src/filters/brightness_contrast_filter.cpp |  5 +-
 src/filters/hue_saturation_filter.cpp      |  5 +-
 src/render/quantization.cpp                |  2 +-
 13 files changed, 102 insertions(+), 82 deletions(-)
 rename src/doc/{rgbmap.cpp => rgbmap_rgb5a3.cpp} (80%)
 create mode 100644 src/doc/rgbmap_rgb5a3.h

diff --git a/src/app/file/gif_format.cpp b/src/app/file/gif_format.cpp
index c89a64b3e..f398187d6 100644
--- a/src/app/file/gif_format.cpp
+++ b/src/app/file/gif_format.cpp
@@ -1171,7 +1171,7 @@ private:
                   const DisposalMethod disposal,
                   const bool fixDuration) {
     std::unique_ptr<Palette> framePaletteRef;
-    std::unique_ptr<RgbMap> rgbmapRef;
+    std::unique_ptr<RgbMapRGB5A3> rgbmapRef;
     Palette* framePalette = m_sprite->palette(frame);
     RgbMap* rgbmap = m_sprite->rgbMap(frame);
 
@@ -1180,9 +1180,9 @@ private:
       framePaletteRef.reset(createOptimizedPalette(frameBounds));
       framePalette = framePaletteRef.get();
 
-      rgbmapRef.reset(new RgbMap);
+      rgbmapRef.reset(new RgbMapRGB5A3);
+      rgbmapRef->regenerate(framePalette, m_transparentIndex);
       rgbmap = rgbmapRef.get();
-      rgbmap->regenerate(framePalette, m_transparentIndex);
     }
 
     // We will store the frameBounds pixels in frameImage, with the
@@ -1228,6 +1228,8 @@ private:
           int i;
 
           if (rgba_geta(color) >= 128) {
+            color |= rgba_a_mask; // Set alpha=255
+
             i = framePalette->findExactMatch(
               rgba_getr(color),
               rgba_getg(color),
@@ -1235,10 +1237,7 @@ private:
               255,
               m_transparentIndex);
             if (i < 0)
-              i = rgbmap->mapColor(rgba_getr(color),
-                                   rgba_getg(color),
-                                   rgba_getb(color),
-                                   255);
+              i = rgbmap->mapColor(color);
           }
           else {
             ASSERT(m_transparentIndex >= 0);
diff --git a/src/app/tools/ink_processing.h b/src/app/tools/ink_processing.h
index 2e73d84f0..5bd5c6c26 100644
--- a/src/app/tools/ink_processing.h
+++ b/src/app/tools/ink_processing.h
@@ -272,10 +272,7 @@ public:
       c = m_palette->getEntry(c);
 
     c = rgba_blender_normal(c, m_color, m_opacity);
-    *m_dstAddress = m_rgbmap->mapColor(rgba_getr(c),
-                                       rgba_getg(c),
-                                       rgba_getb(c),
-                                       rgba_geta(c));
+    *m_dstAddress = m_rgbmap->mapColor(c);
   }
 
 private:
@@ -338,10 +335,7 @@ public:
       c = m_palette->getEntry(c);
 
     c = rgba_blender_merge(c, m_color, m_opacity);
-    *m_dstAddress = m_rgbmap->mapColor(rgba_getr(c),
-                                       rgba_getg(c),
-                                       rgba_getb(c),
-                                       rgba_geta(c));
+    *m_dstAddress = m_rgbmap->mapColor(c);
   }
 
 private:
@@ -493,8 +487,7 @@ public:
                            doc::rgba(m_area.r, m_area.g, m_area.b, m_area.a),
                            m_opacity);
 
-      *m_dstAddress = m_rgbmap->mapColor(
-        rgba_getr(c), rgba_getg(c), rgba_getb(c), rgba_geta(c));
+      *m_dstAddress = m_rgbmap->mapColor(c);
     }
     else {
       *m_dstAddress = *m_srcAddress;
@@ -606,8 +599,7 @@ public:
         color_t c = rgba_blender_normal(
           m_palette->getEntry(*m_srcAddress), m_color2, m_opacity);
 
-        *m_dstAddress = m_rgbmap->mapColor(
-          rgba_getr(c), rgba_getg(c), rgba_getb(c), rgba_geta(c));
+        *m_dstAddress = m_rgbmap->mapColor(c);
       }
     }
   }
@@ -694,10 +686,7 @@ void JumbleInkProcessing<IndexedTraits>::processPixel(int x, int y)
                                  tc, m_opacity);
 
   if (rgba_geta(c) >= 128)
-    *m_dstAddress = m_rgbmap->mapColor(rgba_getr(c),
-                                       rgba_getg(c),
-                                       rgba_getb(c),
-                                       rgba_geta(c));
+    *m_dstAddress = m_rgbmap->mapColor(c);
   else
     *m_dstAddress = 0;
 }
@@ -1043,10 +1032,7 @@ void GradientInkProcessing<IndexedTraits>::processPixel(int x, int y)
     c0 = m_palette->getEntry(c0);
   c = rgba_blender_normal(c0, c, m_opacity);
 
-  *m_dstAddress = m_rgbmap->mapColor(rgba_getr(c),
-                                     rgba_getg(c),
-                                     rgba_getb(c),
-                                     rgba_geta(c));
+  *m_dstAddress = m_rgbmap->mapColor(c);
 
   ++m_tmpAddress;
 }
@@ -1091,10 +1077,7 @@ public:
 
   void processPixel(int x, int y) {
     color_t c = rgba_blender_neg_bw(m_palette->getEntry(*m_srcAddress), m_color, 255);
-    *m_dstAddress = m_rgbmap->mapColor(rgba_getr(c),
-                                       rgba_getg(c),
-                                       rgba_getb(c),
-                                       rgba_geta(c));
+    *m_dstAddress = m_rgbmap->mapColor(c);
   }
 
 private:
diff --git a/src/doc/CMakeLists.txt b/src/doc/CMakeLists.txt
index d1c5973d1..d78b5922d 100644
--- a/src/doc/CMakeLists.txt
+++ b/src/doc/CMakeLists.txt
@@ -1,4 +1,5 @@
 # Aseprite Document Library
+# Copyright (C) 2020 Igara Studio S.A.
 # Copyright (C) 2001-2018 David Capello
 
 if(WIN32)
@@ -52,7 +53,7 @@ add_library(doc-lib
   palette_io.cpp
   primitives.cpp
   remap.cpp
-  rgbmap.cpp
+  rgbmap_rgb5a3.cpp
   selected_frames.cpp
   selected_layers.cpp
   slice.cpp
diff --git a/src/doc/LICENSE.txt b/src/doc/LICENSE.txt
index 8ddfb5031..da9a44fa3 100644
--- a/src/doc/LICENSE.txt
+++ b/src/doc/LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (c) 2018-2019 Igara Studio S.A.
+Copyright (c) 2018-2020 Igara Studio S.A.
 Copyright (c) 2001-2018 David Capello
 
 Permission is hereby granted, free of charge, to any person obtaining
diff --git a/src/doc/doc.h b/src/doc/doc.h
index 17203c193..a58c20674 100644
--- a/src/doc/doc.h
+++ b/src/doc/doc.h
@@ -1,5 +1,5 @@
 // Aseprite Document Library
-// Copyright (C) 2019  Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 // Copyright (C) 2001-2018  David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -33,6 +33,7 @@
 #include "doc/primitives_fast.h"
 #include "doc/remap.h"
 #include "doc/rgbmap.h"
+#include "doc/rgbmap_rgb5a3.h"
 #include "doc/slice.h"
 #include "doc/slices.h"
 #include "doc/sprite.h"
diff --git a/src/doc/rgbmap.h b/src/doc/rgbmap.h
index 30ab666a3..54c40a644 100644
--- a/src/doc/rgbmap.h
+++ b/src/doc/rgbmap.h
@@ -1,6 +1,5 @@
 // Aseprite Document Library
 // Copyright (c) 2020 Igara Studio S.A.
-// Copyright (c) 2001-2016 David Capello
 //
 // This file is released under the terms of the MIT license.
 // Read LICENSE.txt for more information.
@@ -10,48 +9,29 @@
 #pragma once
 
 #include "base/debug.h"
-#include "base/disable_copying.h"
-#include "doc/object.h"
-
-#include <vector>
+#include "doc/color.h"
 
 namespace doc {
 
-  class Palette;
-
-  // It acts like a cache for Palette:findBestfit() calls.
+  // Matches a RGBA value with an index in a color palette (doc::Palette).
   class RgbMap {
-    // Bit activated on m_map entries that aren't yet calculated.
-    const int INVALID = 256;
-
   public:
-    RgbMap();
+    virtual ~RgbMap() { }
 
-    bool match(const Palette* palette) const;
-    void regenerate(const Palette* palette, int mask_index);
+    // Should return the best index in a palette that matches the given RGBA values.
+    virtual int mapColor(const color_t rgba) const = 0;
 
-    int mapColor(int r, int g, int b, int a) const {
+    int mapColor(const int r,
+                 const int g,
+                 const int b,
+                 const int a) const {
       ASSERT(r >= 0 && r < 256);
       ASSERT(g >= 0 && g < 256);
       ASSERT(b >= 0 && b < 256);
       ASSERT(a >= 0 && a < 256);
-      // bits -> bbbbbgggggrrrrraaa
-      int i = (a>>5) | ((b>>3) << 3) | ((g>>3) << 8) | ((r>>3) << 13);
-      int v = m_map[i];
-      return (v & INVALID) ? generateEntry(i, r, g, b, a): v;
+      return mapColor(rgba(r, g, b, a));
     }
 
-    int maskIndex() const { return m_maskIndex; }
-
-  private:
-    int generateEntry(int i, int r, int g, int b, int a) const;
-
-    mutable std::vector<uint16_t> m_map;
-    const Palette* m_palette;
-    int m_modifications;
-    int m_maskIndex;
-
-    DISABLE_COPYING(RgbMap);
   };
 
 } // namespace doc
diff --git a/src/doc/rgbmap.cpp b/src/doc/rgbmap_rgb5a3.cpp
similarity index 80%
rename from src/doc/rgbmap.cpp
rename to src/doc/rgbmap_rgb5a3.cpp
index 1d56fba18..677779c4a 100644
--- a/src/doc/rgbmap.cpp
+++ b/src/doc/rgbmap_rgb5a3.cpp
@@ -9,7 +9,7 @@
 #include "config.h"
 #endif
 
-#include "doc/rgbmap.h"
+#include "doc/rgbmap_rgb5a3.h"
 
 #include "doc/color_scales.h"
 #include "doc/palette.h"
@@ -22,7 +22,7 @@ namespace doc {
 #define ASIZE   8
 #define MAPSIZE (RSIZE*GSIZE*BSIZE*ASIZE)
 
-RgbMap::RgbMap()
+RgbMapRGB5A3::RgbMapRGB5A3()
   : m_map(MAPSIZE)
   , m_palette(NULL)
   , m_modifications(0)
@@ -30,13 +30,13 @@ RgbMap::RgbMap()
 {
 }
 
-bool RgbMap::match(const Palette* palette) const
+bool RgbMapRGB5A3::match(const Palette* palette) const
 {
   return (m_palette == palette &&
     m_modifications == palette->getModifications());
 }
 
-void RgbMap::regenerate(const Palette* palette, int mask_index)
+void RgbMapRGB5A3::regenerate(const Palette* palette, int mask_index)
 {
   m_palette = palette;
   m_modifications = palette->getModifications();
@@ -47,7 +47,7 @@ void RgbMap::regenerate(const Palette* palette, int mask_index)
     entry |= INVALID;
 }
 
-int RgbMap::generateEntry(int i, int r, int g, int b, int a) const
+int RgbMapRGB5A3::generateEntry(int i, int r, int g, int b, int a) const
 {
   return m_map[i] =
     m_palette->findBestfit(
diff --git a/src/doc/rgbmap_rgb5a3.h b/src/doc/rgbmap_rgb5a3.h
new file mode 100644
index 000000000..e4a108361
--- /dev/null
+++ b/src/doc/rgbmap_rgb5a3.h
@@ -0,0 +1,61 @@
+// Aseprite Document Library
+// Copyright (c) 2020 Igara Studio S.A.
+// Copyright (c) 2001-2016 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef DOC_RGBMAP_RGB5A3_H_INCLUDED
+#define DOC_RGBMAP_RGB5A3_H_INCLUDED
+#pragma once
+
+#include "base/debug.h"
+#include "base/disable_copying.h"
+#include "doc/object.h"
+#include "doc/rgbmap.h"
+
+#include <vector>
+
+namespace doc {
+
+  class Palette;
+
+  // It acts like a cache for Palette:findBestfit() calls.
+  class RgbMapRGB5A3 : public RgbMap {
+    // Bit activated on m_map entries that aren't yet calculated.
+    const int INVALID = 256;
+
+  public:
+    RgbMapRGB5A3();
+
+    bool match(const Palette* palette) const;
+    void regenerate(const Palette* palette, int mask_index);
+
+    // RgbMap impl
+    int mapColor(const color_t rgba) const override {
+      const int r = rgba_getr(rgba);
+      const int g = rgba_getg(rgba);
+      const int b = rgba_getb(rgba);
+      const int a = rgba_geta(rgba);
+      // bits -> bbbbbgggggrrrrraaa
+      const int i = (a>>5) | ((b>>3) << 3) | ((g>>3) << 8) | ((r>>3) << 13);
+      const int v = m_map[i];
+      return (v & INVALID) ? generateEntry(i, r, g, b, a): v;
+    }
+
+    int maskIndex() const { return m_maskIndex; }
+
+  private:
+    int generateEntry(int i, int r, int g, int b, int a) const;
+
+    mutable std::vector<uint16_t> m_map;
+    const Palette* m_palette;
+    int m_modifications;
+    int m_maskIndex;
+
+    DISABLE_COPYING(RgbMapRGB5A3);
+  };
+
+} // namespace doc
+
+#endif
diff --git a/src/doc/sprite.cpp b/src/doc/sprite.cpp
index 05c5936e2..f066284e6 100644
--- a/src/doc/sprite.cpp
+++ b/src/doc/sprite.cpp
@@ -21,7 +21,7 @@
 #include "doc/palette.h"
 #include "doc/primitives.h"
 #include "doc/remap.h"
-#include "doc/rgbmap.h"
+#include "doc/rgbmap_rgb5a3.h"
 #include "doc/tag.h"
 
 #include <algorithm>
@@ -357,7 +357,7 @@ RgbMap* Sprite::rgbMap(frame_t frame, RgbMapFor forLayer) const
                    -1: transparentColor());
 
   if (m_rgbMap == NULL) {
-    m_rgbMap = new RgbMap();
+    m_rgbMap = new RgbMapRGB5A3;
     m_rgbMap->regenerate(palette(frame), maskIndex);
   }
   else if (!m_rgbMap->match(palette(frame)) ||
diff --git a/src/doc/sprite.h b/src/doc/sprite.h
index 1e6915676..79b1b0125 100644
--- a/src/doc/sprite.h
+++ b/src/doc/sprite.h
@@ -1,5 +1,5 @@
 // Aseprite Document Library
-// Copyright (C) 2018-2019  Igara Studio S.A.
+// Copyright (C) 2018-2020  Igara Studio S.A.
 // Copyright (C) 2001-2018  David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -42,6 +42,7 @@ namespace doc {
   class Palette;
   class Remap;
   class RgbMap;
+  class RgbMapRGB5A3;
   class SelectedFrames;
 
   typedef std::vector<Palette*> PalettesList;
@@ -199,7 +200,7 @@ namespace doc {
     gfx::Rect m_gridBounds;                // grid settings
 
     // Current rgb map
-    mutable RgbMap* m_rgbMap;
+    mutable RgbMapRGB5A3* m_rgbMap;
 
     Tags m_tags;
     Slices m_slices;
diff --git a/src/filters/brightness_contrast_filter.cpp b/src/filters/brightness_contrast_filter.cpp
index 30b2b5a2f..3d67f3d09 100644
--- a/src/filters/brightness_contrast_filter.cpp
+++ b/src/filters/brightness_contrast_filter.cpp
@@ -138,10 +138,7 @@ void BrightnessContrastFilter::applyToIndexed(FilterManager* filterMgr)
 
     color_t c = pal->getEntry(*(src_address++));
     applyFilterToRgb(target, c);
-    *(dst_address++) = rgbmap->mapColor(rgba_getr(c),
-                                        rgba_getg(c),
-                                        rgba_getb(c),
-                                        rgba_geta(c));
+    *(dst_address++) = rgbmap->mapColor(c);
   }
 }
 
diff --git a/src/filters/hue_saturation_filter.cpp b/src/filters/hue_saturation_filter.cpp
index 1ede7b0cc..8f4a40551 100644
--- a/src/filters/hue_saturation_filter.cpp
+++ b/src/filters/hue_saturation_filter.cpp
@@ -168,10 +168,7 @@ void HueSaturationFilter::applyToIndexed(FilterManager* filterMgr)
 
     color_t c = pal->getEntry(*(src_address++));
     applyFilterToRgb(target, c);
-    *(dst_address++) = rgbmap->mapColor(rgba_getr(c),
-                                        rgba_getg(c),
-                                        rgba_getb(c),
-                                        rgba_geta(c));
+    *(dst_address++) = rgbmap->mapColor(c);
   }
 }
 
diff --git a/src/render/quantization.cpp b/src/render/quantization.cpp
index ab6d39f4d..657ced0b1 100644
--- a/src/render/quantization.cpp
+++ b/src/render/quantization.cpp
@@ -177,7 +177,7 @@ Image* convert_pixel_format(
             if (a == 0)
               *dst_it = new_mask_color;
             else if (rgbmap)
-              *dst_it = rgbmap->mapColor(r, g, b, a);
+              *dst_it = rgbmap->mapColor(c);
             else
               *dst_it = palette->findBestfit(r, g, b, a, new_mask_color);
           }

From 886fdf8b3f11d0840b5780422a7f0d7c7137498d Mon Sep 17 00:00:00 2001
From: Gaspar Capello <gaspar@igarastudio.com>
Date: Fri, 10 Apr 2020 15:35:11 -0300
Subject: [PATCH 3/9] Add OctreeMap as an alternative RgbMap implementation to
 RgbMapRGB53A

There is a new experimental option to switch between both RgbMap
implementations.
---
 data/pref.xml                            |   1 +
 data/strings/en.ini                      |   5 +
 data/widgets/options.xml                 |   4 +
 src/app/CMakeLists.txt                   |   1 +
 src/app/commands/cmd_options.cpp         |   7 +
 src/app/commands/new_params.cpp          |  23 +-
 src/app/file/gif_format.cpp              |   2 +-
 src/app/pref/preferences.cpp             |   8 +
 src/app/pref/preferences.h               |   1 +
 src/app/script/values.cpp                |   3 +-
 src/app/ui/rgbmap_algorithm_selector.cpp |  40 +++
 src/app/ui/rgbmap_algorithm_selector.h   |  26 ++
 src/doc/CMakeLists.txt                   |   3 +-
 src/doc/octree_map.cpp                   | 297 +++++++++++++++++++++++
 src/doc/octree_map.h                     | 169 +++++++++++++
 src/doc/palette.cpp                      |  25 ++
 src/doc/palette.h                        |   2 +
 src/doc/rgbmap.h                         |   4 +
 src/doc/rgbmap_algorithm.h               |  21 ++
 src/doc/rgbmap_rgb5a3.cpp                |  16 +-
 src/doc/rgbmap_rgb5a3.h                  |   4 +-
 src/doc/sprite.cpp                       |  44 ++--
 src/doc/sprite.h                         |   8 +-
 23 files changed, 683 insertions(+), 31 deletions(-)
 create mode 100644 src/app/ui/rgbmap_algorithm_selector.cpp
 create mode 100644 src/app/ui/rgbmap_algorithm_selector.h
 create mode 100644 src/doc/octree_map.cpp
 create mode 100644 src/doc/octree_map.h
 create mode 100644 src/doc/rgbmap_algorithm.h

diff --git a/data/pref.xml b/data/pref.xml
index 4e220b006..07be3977f 100644
--- a/data/pref.xml
+++ b/data/pref.xml
@@ -190,6 +190,7 @@
       <option id="load_wintab_driver" type="bool" default="true" />
       <option id="flash_layer" type="bool" default="false" />
       <option id="nonactive_layers_opacity" type="int" default="255" />
+      <option id="rgbmap_algorithm" type="doc::RgbMapAlgorithm" default="doc::RgbMapAlgorithm::DEFAULT" />
     </section>
     <section id="news">
       <option id="cache_file" type="std::string" />
diff --git a/data/strings/en.ini b/data/strings/en.ini
index e750a96a5..e812fc395 100644
--- a/data/strings/en.ini
+++ b/data/strings/en.ini
@@ -971,6 +971,11 @@ square_pixels = Square Pixels (1:1)
 double_wide = Double-wide Pixels (2:1)
 double_high = Double-high Pixels (1:2)
 
+[rgbmap_algorithm_selector]
+label = RGB to palette index mapping:
+rgb5a3 = Table RGB 5 bits + Alpha 3 bits
+octree = Octree without Alpha
+
 [open_sequence]
 title = Notice
 description = Do you want to load the following files as an animation?
diff --git a/data/widgets/options.xml b/data/widgets/options.xml
index eea4d2f2d..c9d7d3744 100644
--- a/data/widgets/options.xml
+++ b/data/widgets/options.xml
@@ -489,6 +489,10 @@
             <label text="@.non_active_layer_opacity" />
             <slider id="nonactive_layers_opacity" min="0" max="255" width="128" />
           </hbox>
+          <hbox>
+            <label text="@rgbmap_algorithm_selector.label" />
+            <hbox id="rgbmap_algorithm_placeholder" />
+          </hbox>
         </vbox>
 
       </panel>
diff --git a/src/app/CMakeLists.txt b/src/app/CMakeLists.txt
index 49c70457d..9592f943f 100644
--- a/src/app/CMakeLists.txt
+++ b/src/app/CMakeLists.txt
@@ -366,6 +366,7 @@ if(ENABLE_UI)
     ui/preview_editor.cpp
     ui/recent_listbox.cpp
     ui/resources_listbox.cpp
+    ui/rgbmap_algorithm_selector.cpp
     ui/search_entry.cpp
     ui/select_accelerator.cpp
     ui/selection_mode_field.cpp
diff --git a/src/app/commands/cmd_options.cpp b/src/app/commands/cmd_options.cpp
index 0a257f80e..b695af36e 100644
--- a/src/app/commands/cmd_options.cpp
+++ b/src/app/commands/cmd_options.cpp
@@ -28,6 +28,7 @@
 #include "app/tx.h"
 #include "app/ui/color_button.h"
 #include "app/ui/pref_widget.h"
+#include "app/ui/rgbmap_algorithm_selector.h"
 #include "app/ui/separator_in_view.h"
 #include "app/ui/skin/skin_theme.h"
 #include "base/bind.h"
@@ -337,6 +338,10 @@ public:
 
     nonactiveLayersOpacity()->setValue(m_pref.experimental.nonactiveLayersOpacity());
 
+    rgbmapAlgorithmPlaceholder()->addChild(&m_rgbmapAlgorithmSelector);
+    m_rgbmapAlgorithmSelector.setExpansive(true);
+    m_rgbmapAlgorithmSelector.algorithm(m_pref.experimental.rgbmapAlgorithm());
+
     if (m_pref.editor.showScrollbars())
       showScrollbars()->setSelected(true);
 
@@ -632,6 +637,7 @@ public:
     m_pref.experimental.useNativeFileDialog(nativeFileDialog()->isSelected());
     m_pref.experimental.flashLayer(flashLayer()->isSelected());
     m_pref.experimental.nonactiveLayersOpacity(nonactiveLayersOpacity()->getValue());
+    m_pref.experimental.rgbmapAlgorithm(m_rgbmapAlgorithmSelector.algorithm());
 
 #ifdef _WIN32
     manager()->getDisplay()
@@ -1417,6 +1423,7 @@ private:
   int m_restoreUIScaling;
   std::vector<os::ColorSpacePtr> m_colorSpaces;
   std::string m_templateTextForDisplayCS;
+  RgbMapAlgorithmSelector m_rgbmapAlgorithmSelector;
 };
 
 class OptionsCommand : public Command {
diff --git a/src/app/commands/new_params.cpp b/src/app/commands/new_params.cpp
index be83c5dd0..a389ad8d7 100644
--- a/src/app/commands/new_params.cpp
+++ b/src/app/commands/new_params.cpp
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2019  Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 //
 // This program is distributed under the terms of
 // the End-User License Agreement for Aseprite.
@@ -18,6 +18,7 @@
 #include "base/string.h"
 #include "doc/algorithm/resize_image.h"
 #include "doc/color_mode.h"
+#include "doc/rgbmap_algorithm.h"
 #include "filters/color_curve.h"
 #include "filters/hue_saturation_filter.h"
 #include "filters/outline_filter.h"
@@ -179,6 +180,17 @@ void Param<filters::ColorCurve>::fromString(const std::string& value)
   setValue(curve);
 }
 
+template<>
+void Param<doc::RgbMapAlgorithm>::fromString(const std::string& value)
+{
+  if (base::utf8_icmp(value, "octree") == 0)
+    setValue(doc::RgbMapAlgorithm::OCTREE);
+  else if (base::utf8_icmp(value, "rgb5a3") == 0)
+    setValue(doc::RgbMapAlgorithm::RGB5A3);
+  else
+    setValue(doc::RgbMapAlgorithm::DEFAULT);
+}
+
 //////////////////////////////////////////////////////////////////////
 // Convert values from Lua
 //////////////////////////////////////////////////////////////////////
@@ -307,6 +319,15 @@ void Param<filters::ColorCurve>::fromLua(lua_State* L, int index)
   }
 }
 
+template<>
+void Param<doc::RgbMapAlgorithm>::fromLua(lua_State* L, int index)
+{
+  if (lua_type(L, index) == LUA_TSTRING)
+    fromString(lua_tostring(L, index));
+  else
+    setValue((doc::RgbMapAlgorithm)lua_tointeger(L, index));
+}
+
 void CommandWithNewParamsBase::loadParamsFromLuaTable(lua_State* L, int index)
 {
   onResetValues();
diff --git a/src/app/file/gif_format.cpp b/src/app/file/gif_format.cpp
index f398187d6..400c17138 100644
--- a/src/app/file/gif_format.cpp
+++ b/src/app/file/gif_format.cpp
@@ -1181,7 +1181,7 @@ private:
       framePalette = framePaletteRef.get();
 
       rgbmapRef.reset(new RgbMapRGB5A3);
-      rgbmapRef->regenerate(framePalette, m_transparentIndex);
+      rgbmapRef->regenerateMap(framePalette, m_transparentIndex);
       rgbmap = rgbmapRef.get();
     }
 
diff --git a/src/app/pref/preferences.cpp b/src/app/pref/preferences.cpp
index 48d2deee4..830e8838b 100644
--- a/src/app/pref/preferences.cpp
+++ b/src/app/pref/preferences.cpp
@@ -54,6 +54,14 @@ Preferences::Preferences()
 
   load();
 
+  // Create a connection with the default RgbMapAlgorithm preferences
+  // to change the default algorithm in the "doc" layer.
+  experimental.rgbmapAlgorithm.AfterChange.connect(
+    [](const doc::RgbMapAlgorithm& newValue){
+      doc::Sprite::SetDefaultRgbMapAlgorithm(newValue);
+    });
+  doc::Sprite::SetDefaultRgbMapAlgorithm(experimental.rgbmapAlgorithm());
+
   // Create a connection with the default document preferences grid
   // bounds to sync the default grid bounds for new sprites in the
   // "doc" layer.
diff --git a/src/app/pref/preferences.h b/src/app/pref/preferences.h
index b12577102..290fbb460 100644
--- a/src/app/pref/preferences.h
+++ b/src/app/pref/preferences.h
@@ -25,6 +25,7 @@
 #include "doc/color_mode.h"
 #include "doc/frame.h"
 #include "doc/layer_list.h"
+#include "doc/rgbmap_algorithm.h"
 #include "doc/sprite.h"
 #include "filters/tiled_mode.h"
 #include "gfx/rect.h"
diff --git a/src/app/script/values.cpp b/src/app/script/values.cpp
index e8fdab494..c4dfa2883 100644
--- a/src/app/script/values.cpp
+++ b/src/app/script/values.cpp
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2019  Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 //
 // This program is distributed under the terms of
 // the End-User License Agreement for Aseprite.
@@ -168,6 +168,7 @@ FOR_ENUM(app::tools::RotationAlgorithm)
 FOR_ENUM(doc::AniDir)
 FOR_ENUM(doc::BrushPattern)
 FOR_ENUM(doc::ColorMode)
+FOR_ENUM(doc::RgbMapAlgorithm)
 FOR_ENUM(filters::TiledMode)
 FOR_ENUM(render::OnionskinPosition)
 
diff --git a/src/app/ui/rgbmap_algorithm_selector.cpp b/src/app/ui/rgbmap_algorithm_selector.cpp
new file mode 100644
index 000000000..cc128d9e2
--- /dev/null
+++ b/src/app/ui/rgbmap_algorithm_selector.cpp
@@ -0,0 +1,40 @@
+// Aseprite
+// Copyright (C) 2020  Igara Studio S.A.
+//
+// This program is distributed under the terms of
+// the End-User License Agreement for Aseprite.
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "app/ui/rgbmap_algorithm_selector.h"
+
+#include "app/i18n/strings.h"
+
+namespace app {
+
+RgbMapAlgorithmSelector::RgbMapAlgorithmSelector()
+{
+  // addItem() must match the RgbMapAlgorithm enum
+  static_assert(int(doc::RgbMapAlgorithm::RGB5A3) == 0 &&
+                int(doc::RgbMapAlgorithm::OCTREE) == 1,
+                "Unexpected doc::RgbMapAlgorithm values");
+
+  addItem(Strings::rgbmap_algorithm_selector_rgb5a3());
+  addItem(Strings::rgbmap_algorithm_selector_octree());
+
+  algorithm(doc::RgbMapAlgorithm::DEFAULT);
+}
+
+doc::RgbMapAlgorithm RgbMapAlgorithmSelector::algorithm()
+{
+  return (doc::RgbMapAlgorithm)getSelectedItemIndex();
+}
+
+void RgbMapAlgorithmSelector::algorithm(const doc::RgbMapAlgorithm mapAlgo)
+{
+  setSelectedItemIndex((int)mapAlgo);
+}
+
+} // namespace app
diff --git a/src/app/ui/rgbmap_algorithm_selector.h b/src/app/ui/rgbmap_algorithm_selector.h
new file mode 100644
index 000000000..983bb33da
--- /dev/null
+++ b/src/app/ui/rgbmap_algorithm_selector.h
@@ -0,0 +1,26 @@
+// Aseprite
+// Copyright (C) 2020  Igara Studio S.A.
+//
+// This program is distributed under the terms of
+// the End-User License Agreement for Aseprite.
+
+#ifndef APP_UI_MAP_ALGORITHM_SELECTOR_H_INCLUDED
+#define APP_UI_MAP_ALGORITHM_SELECTOR_H_INCLUDED
+#pragma once
+
+#include "doc/rgbmap_algorithm.h"
+#include "ui/combobox.h"
+
+namespace app {
+
+  class RgbMapAlgorithmSelector : public ui::ComboBox {
+  public:
+    RgbMapAlgorithmSelector();
+
+    doc::RgbMapAlgorithm algorithm();
+    void algorithm(doc::RgbMapAlgorithm mapAlgo);
+  };
+
+} // namespace app
+
+#endif
diff --git a/src/doc/CMakeLists.txt b/src/doc/CMakeLists.txt
index d78b5922d..8f7d9c3d8 100644
--- a/src/doc/CMakeLists.txt
+++ b/src/doc/CMakeLists.txt
@@ -1,5 +1,5 @@
 # Aseprite Document Library
-# Copyright (C) 2020 Igara Studio S.A.
+# Copyright (C) 2019-2020 Igara Studio S.A.
 # Copyright (C) 2001-2018 David Capello
 
 if(WIN32)
@@ -49,6 +49,7 @@ add_library(doc-lib
   mask_io.cpp
   object.cpp
   object.cpp
+  octree_map.cpp
   palette.cpp
   palette_io.cpp
   primitives.cpp
diff --git a/src/doc/octree_map.cpp b/src/doc/octree_map.cpp
new file mode 100644
index 000000000..7aafe5e2b
--- /dev/null
+++ b/src/doc/octree_map.cpp
@@ -0,0 +1,297 @@
+// Aseprite
+// Copyright (c) 2020 Igara Studio S.A.
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "doc/octree_map.h"
+
+#include "doc/palette.h"
+
+#define MID_VALUE_COLOR ((rgba_r_mask / 2) + 1)
+#define MIN_LEVEL_OCTREE_DEEP 3
+
+namespace doc {
+
+void OctreeNode::addColor(color_t c, int level, OctreeNode* parent,
+                          int paletteIndex, int levelDeep)
+{
+  m_parent = parent;
+  if (level >= levelDeep) {
+    m_leafColor.add(c);
+    m_paletteIndex = paletteIndex;
+    return;
+  }
+  int index = getOctet(c, level);
+  if (!m_children) {
+    m_children.reset(new std::array<OctreeNode, 8>());
+  }
+  (*m_children)[index].addColor(c, level + 1, this, paletteIndex, levelDeep);
+}
+
+void OctreeNode::fillOrphansNodes(const Palette* palette,
+                                  color_t upstreamBranchColor, int level)
+{
+  for (int i=0; i<8; i++) {
+    if ((*m_children)[i].m_children)
+      (*m_children)[i].fillOrphansNodes(
+        palette,
+        upstreamBranchColor + octetToBranchColor(i, level),
+        level + 1);
+    else if (!((*m_children)[i].isLeaf())) {
+      // Here the node IS NOT a Leaf and HAS NOT children
+      // So, we must assign palette index to the current node
+      // to fill the "map holes" (i.e "death tree branches")
+      // BUT, if the level is low (a few bits to identify a color)
+      // 0, 1, 2, or 3, we need to create branchs/Leaves until
+      // the desired minimum color MSB bits.
+      if (level < MIN_LEVEL_OCTREE_DEEP) {
+        (*m_children)[i].fillMostSignificantNodes(level);
+        i--;
+        continue;
+      }
+      int currentBranchColorAdd = octetToBranchColor(i, level);
+      int midColorAdd = MID_VALUE_COLOR >> (level + 1);
+      midColorAdd = ((midColorAdd) << rgba_r_shift)
+                  + ((midColorAdd) << rgba_g_shift)
+                  + ((midColorAdd) << rgba_b_shift);
+      color_t branchColorMed = rgba_a_mask
+                             + upstreamBranchColor
+                             + currentBranchColorAdd
+                             + midColorAdd;
+      int indexMed = palette->findBestfit2(rgba_getr(branchColorMed),
+                                           rgba_getg(branchColorMed),
+                                           rgba_getb(branchColorMed));
+      (*m_children)[i].paletteIndex(indexMed);
+    }
+  }
+}
+
+void OctreeNode::fillMostSignificantNodes(int level)
+{
+  if (level < MIN_LEVEL_OCTREE_DEEP) {
+    m_children.reset(new std::array<OctreeNode, 8>());
+    level++;
+    for (int i=0; i<8; i++)
+      (*m_children)[i].fillMostSignificantNodes(level);
+  }
+}
+
+int OctreeNode::mapColor(int r, int g, int b, int level)
+{
+  int indexLevel = (  (b >> (7 - level)) & 1) * 4
+                   + ((g >> (7 - level)) & 1) * 2
+                   + ((r >> (7 - level)) & 1);
+  if ((*m_children)[indexLevel].m_children)
+    return (*m_children)[indexLevel].mapColor(r, g, b, level+1);
+  return (*m_children)[indexLevel].m_paletteIndex;
+}
+
+void OctreeNode::collectLeafNodes(std::vector<OctreeNode*>* leavesVector, int& paletteIndex)
+{
+  for (int i=0; i<8; i++) {
+    if ((*m_children)[i].isLeaf()) {
+      (*m_children)[i].paletteIndex(paletteIndex);
+      leavesVector->push_back(&(*m_children)[i]);
+      paletteIndex++;
+    }
+    else if ((*m_children)[i].m_children)
+      (*m_children)[i].collectLeafNodes(leavesVector, paletteIndex);
+  }
+}
+
+// removeLeaves(): remove leaves from a common parent
+// auxParentVector: i/o addreess of an auxiliary parent leaf Vector from outside this function.
+// rootLeavesVector: i/o address of the m_root->m_leavesVector
+int OctreeNode::removeLeaves(std::vector<OctreeNode*>& auxParentVector,
+                             std::vector<OctreeNode*>& rootLeavesVector,
+                             int octreeDeep)
+{
+  // Apply to OctreeNode which has children which are leaf nodes
+  int result = 0;
+  for (int i=octreeDeep; i>=0; i--) {
+    if ((*m_children)[i].isLeaf()) {
+      m_leafColor.add((*m_children)[i].getLeafColor());
+      result++;
+      if (rootLeavesVector[rootLeavesVector.size()-1] == &((*m_children)[i]))
+        rootLeavesVector.pop_back();
+    }
+  }
+  auxParentVector.push_back(this);
+  return result - 1;
+}
+
+OctreeMap::OctreeMap()
+  : m_root(new OctreeNode)
+  , m_leavesVector(new std::vector<OctreeNode*>())
+  , m_palette(nullptr)
+  , m_modifications(0)
+{
+}
+
+bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
+{
+
+  if (root()->children()) {
+    // We create paletteIndex to get a "global like" variable, in collectLeafNodes
+    // function, the purpose is having a incremental variable in the stack memory
+    // sharend between all recursive calls of collectLeafNodes.
+    int paletteIndex = 0;
+    root()->collectLeafNodes(m_leavesVector.get(), paletteIndex);
+  }
+
+  // If we can improve the octree accuracy, makePalette returns false, then
+  // outside from this function we must re-construct the octreeMap all again with
+  // deep level equal to 8.
+  if (levelDeep == 7 && m_leavesVector->size() < colorCount)
+    return false;
+
+
+  std::vector<OctreeNode*> auxLeavesVector; // auxiliary collapsed node accumulator
+  bool keepReducingMap = true;
+
+  for (int level = levelDeep; level > -1; level--) {
+    for (int i=m_leavesVector->size()-1; i>=0; i--) {
+      if (m_leavesVector->size() + auxLeavesVector.size() <= colorCount) {
+        for (int j=0; j < auxLeavesVector.size(); j++)
+          m_leavesVector->push_back(auxLeavesVector[auxLeavesVector.size() - 1 - j]);
+        keepReducingMap = false;
+        break;
+      }
+      else if (m_leavesVector->size() == 0) {
+        // When colorCount is < 8, auxLeavesVector->size() could reach the 8 size,
+        // if this is true and we don't stop the regular removeLeaves algorithm,
+        // the 8 remains colors will collapse in one.
+        // So, we have to reduce color with other method:
+        // Sort colors by pixelCount (most pixelCount on front of sortedVector),
+        // then:
+        // Blend in pairs from the least pixelCount colors.
+        if (auxLeavesVector.size() <= 8 && colorCount < 8 && colorCount > 0) {
+          // Sort colors:
+          std::vector<OctreeNode*> sortedVector;
+          int auxVectorSize = auxLeavesVector.size();
+          for (int k=0; k < auxVectorSize; k++) {
+            int maximumCount = -1;
+            int maximumIndex = -1;
+            for (int j=0; j < auxLeavesVector.size(); j++) {
+              if (auxLeavesVector[j]->getLeafColor().pixelCount() > maximumCount) {
+                maximumCount = auxLeavesVector[j]->getLeafColor().pixelCount();
+                maximumIndex = j;
+              }
+            }
+            sortedVector.push_back(auxLeavesVector[maximumIndex]);
+            auxLeavesVector.erase(auxLeavesVector.begin() + maximumIndex);
+          }
+          // End Sort colors.
+          // Blend colors:
+          for(;;) {
+            if (sortedVector.size() <= colorCount) {
+              for (int k=0; k<sortedVector.size(); k++)
+                m_leavesVector->push_back(sortedVector[k]);
+              break;
+            }
+            sortedVector[sortedVector.size()-2]->getLeafColor()
+              .add(sortedVector[sortedVector.size()-1]->getLeafColor());
+            sortedVector.pop_back();
+          }
+          // End Blend colors:
+          keepReducingMap = false;
+          break;
+        }
+        else
+          break;
+      }
+
+      m_leavesVector->back()->parent()->removeLeaves(auxLeavesVector, *m_leavesVector);
+    }
+    if (keepReducingMap) {
+      // Copy collapsed leaves to m_leavesVector
+      int auxLeavesVectorSize = auxLeavesVector.size();
+      for (int i=0; i<auxLeavesVectorSize; i++)
+        m_leavesVector->push_back(auxLeavesVector[auxLeavesVector.size() - 1 - i]);
+      auxLeavesVector.clear();
+    }
+    else
+      break;
+  }
+  int leafCount = m_leavesVector->size();
+  int aux = 0;
+  if (m_maskColor == 0x00FFFFFF)
+    palette->resize(leafCount);
+  else{
+    palette->resize(leafCount + 1);
+    palette->setEntry(0, m_maskColor);
+    aux = 1;
+  }
+
+  for (int i=0; i<leafCount; i++)
+    palette->setEntry(i+aux, (*m_leavesVector)[i]->getLeafColor().normalizeColor().LeafColorToColor());
+
+  return true;
+}
+
+void OctreeMap::fillOrphansNodes(Palette* palette)
+{
+  m_root->fillOrphansNodes(palette, 0, 0);
+}
+
+void OctreeMap::feedWithImage(Image* image, color_t maskColor, int levelDeep)
+{
+  ASSERT(image);
+  ASSERT(image->pixelFormat() == IMAGE_RGB);
+  uint32_t color;
+  const LockImageBits<RgbTraits> bits(image);
+  LockImageBits<RgbTraits>::const_iterator it = bits.begin(), end = bits.end();
+
+  for (; it != end; ++it) {
+    color = *it;
+    if (rgba_geta(color) > 0)
+      addColor(color, levelDeep);
+  }
+
+  m_maskColor = maskColor;
+}
+
+int OctreeMap::mapColor(color_t rgba) const
+{
+  if (rgba_geta(rgba) == 0 && m_maskColor >= 0)
+    return m_maskColor;
+  else if (m_root->children())
+    return m_root->mapColor(rgba_getr(rgba),
+                            rgba_getg(rgba),
+                            rgba_geta(rgba), 0);
+  else
+    return 0;
+}
+
+void OctreeMap::regenerateMap(const Palette* palette, const int maskIndex)
+{
+  ASSERT(palette);
+  if (!palette)
+    return;
+
+  // Skip useless regenerations
+  if (m_palette == palette &&
+      m_modifications == palette->getModifications() &&
+      m_maskIndex == maskIndex)
+    return;
+
+  m_root.reset(new OctreeNode());
+  m_leavesVector.reset(new std::vector<OctreeNode*>());
+  for (int i=0; i<palette->size(); i++)
+    m_root->addColor(palette->entry(i), 0, m_root.get(), i, 8);
+  m_root->fillOrphansNodes(palette, 0, 0);
+  m_palette = palette;
+  m_modifications = palette->getModifications();
+  m_maskIndex = maskIndex;
+  if (maskIndex < 0)
+    m_maskColor = 0x00ffffff;
+  else
+    m_maskColor = palette->getEntry(maskIndex);
+}
+
+} // namespace doc
diff --git a/src/doc/octree_map.h b/src/doc/octree_map.h
new file mode 100644
index 000000000..324255c4d
--- /dev/null
+++ b/src/doc/octree_map.h
@@ -0,0 +1,169 @@
+// Aseprite
+// Copyright (c) 2020 Igara Studio S.A.
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef DOC_OCTREEMAP_H_INCLUDED
+#define DOC_OCTREEMAP_H_INCLUDED
+#pragma once
+
+#include "doc/image_impl.h"
+#include "doc/palette.h"
+#include "doc/rgbmap.h"
+
+#include <vector>
+#include <array>
+
+namespace doc {
+
+class OctreeNode {
+private:
+  class LeafColor {
+  public:
+    LeafColor() :
+      m_r(0),
+      m_g(0),
+      m_b(0),
+      m_pixelCount(0)
+    {}
+
+    LeafColor(int r, int g, int b, int pixelCount) :
+      m_r((double)r),
+      m_g((double)g),
+      m_b((double)b),
+      m_pixelCount(pixelCount)
+    {}
+
+    void add(color_t c)
+    {
+      m_r += rgba_getr(c);
+      m_g += rgba_getg(c);
+      m_b += rgba_getb(c);
+      m_pixelCount++;
+    }
+
+    void add(LeafColor leafColor)
+    {
+      m_r += leafColor.m_r;
+      m_g += leafColor.m_g;
+      m_b += leafColor.m_b;
+      m_pixelCount += leafColor.m_pixelCount;
+    }
+
+    LeafColor normalizeColor()
+    {
+      int auxR = (((int)m_r) % m_pixelCount > m_pixelCount / 2)? 1 : 0;
+      int auxG = (((int)m_g) % m_pixelCount > m_pixelCount / 2)? 1 : 0;
+      int auxB = (((int)m_b) % m_pixelCount > m_pixelCount / 2)? 1 : 0;
+      return LeafColor(m_r / m_pixelCount + auxR,
+                           m_g / m_pixelCount + auxG,
+                           m_b / m_pixelCount + auxB,
+                           m_pixelCount);
+    }
+
+    color_t LeafColorToColor()
+    {
+      return 0xff000000 + (((int)m_b) << 16) + (((int)m_g) << 8) + (int)m_r;
+    }
+
+    int pixelCount() { return m_pixelCount; }
+
+private:
+    double m_r;
+    double m_g;
+    double m_b;
+    int m_pixelCount;
+  };
+
+public:
+  OctreeNode()
+  {
+    m_paletteIndex = 0;
+    m_children.reset(nullptr);
+    m_parent = nullptr;
+  }
+
+  static int getOctet(color_t c, int level)
+  {
+    int aux = c >> (7 - level);
+    int octet = aux & 1;
+    aux = aux >> (7);
+    octet += (aux & 2);
+    return octet + ((aux >> 7) & 4);
+  }
+
+  static color_t octetToBranchColor(int octet, int level)
+  {
+    int auxR = (octet & 1) << (7 - level);
+    int auxG = (octet & 2) << (14 - level);
+    int auxB = (octet & 4) << (21 - level);
+    return auxR + auxG + auxB;
+  }
+
+  OctreeNode* parent() const { return m_parent; }
+  std::array<OctreeNode, 8>* children() const { return m_children.get(); }
+  LeafColor getLeafColor() const { return m_leafColor; }
+
+  void addColor(color_t c, int level, OctreeNode* parent,
+                int paletteIndex = 0, int levelDeep = 7);
+
+  void fillOrphansNodes(const Palette* palette, color_t upstreamBranchColor, int level);
+
+  void fillMostSignificantNodes(int level);
+
+  int mapColor(int r, int g, int b, int level);
+
+  void collectLeafNodes(std::vector<OctreeNode*>* leavesVector, int& paletteIndex);
+
+  // removeLeaves(): remove leaves from a common parent
+  // auxParentVector: i/o addreess of an auxiliary parent leaf Vector from outside.
+  // rootLeavesVector: i/o address of the m_root->m_leavesVector
+  int removeLeaves(std::vector<OctreeNode*>& auxParentVector,
+                   std::vector<OctreeNode*>& rootLeavesVector,
+                   int octreeDeep = 7);
+
+private:
+  bool isLeaf() { return m_leafColor.pixelCount() > 0; }
+  void paletteIndex(int index) { m_paletteIndex = index; }
+
+  LeafColor m_leafColor;
+  int m_paletteIndex;
+  std::unique_ptr<std::array<OctreeNode, 8>> m_children;
+  OctreeNode* m_parent;
+};
+
+class OctreeMap : public RgbMap {
+public:
+  OctreeMap();
+
+  void addColor(color_t color, int levelDeep = 7)
+  {
+    m_root->addColor(color, 0, m_root.get(), 0, levelDeep);
+  }
+
+  // makePalette return true if a 7 level octreeDeep is OK, and false if we can add ONE level deep.
+  bool makePalette(Palette* palette, int colorCount, int leveleep = 7);
+
+  void feedWithImage(Image* image, color_t maskColor, int levelDeep = 7);
+
+  // RgbMap impl
+  void regenerateMap(const Palette* palette, const int maskIndex) override;
+  int mapColor(color_t rgba) const override;
+
+  int getModifications() const { return m_modifications; };
+
+private:
+  OctreeNode* root() const { return m_root.get(); };
+  void fillOrphansNodes(Palette* palette);
+
+  std::unique_ptr<OctreeNode> m_root;
+  std::unique_ptr<std::vector<OctreeNode*>> m_leavesVector;
+  const Palette* m_palette;
+  int m_modifications;
+  int m_maskIndex;
+  color_t m_maskColor;
+};
+
+} // namespace doc
+#endif
diff --git a/src/doc/palette.cpp b/src/doc/palette.cpp
index e1487089c..9894928d9 100644
--- a/src/doc/palette.cpp
+++ b/src/doc/palette.cpp
@@ -272,6 +272,31 @@ int Palette::findBestfit(int r, int g, int b, int a, int mask_index) const
   return bestfit;
 }
 
+int Palette::findBestfit2(int r, int g, int b) const
+{
+  ASSERT(r >= 0 && r <= 255);
+  ASSERT(g >= 0 && g <= 255);
+  ASSERT(b >= 0 && b <= 255);
+
+  int bestfit = 0;
+  int lowest = std::numeric_limits<int>::max();
+  int size = m_colors.size();
+
+  for (int i=0; i<size; ++i) {
+    color_t rgb = m_colors[i];
+    int rDiff = r - rgba_getr(rgb);
+    int gDiff = g - rgba_getg(rgb);
+    int bDiff = b - rgba_getb(rgb);
+
+    int diff = rDiff * rDiff * 900 + gDiff * gDiff * 3481 + bDiff * bDiff * 121;
+    if (diff < lowest) {
+      lowest = diff;
+      bestfit = i;
+    }
+  }
+  return bestfit;
+}
+
 void Palette::applyRemap(const Remap& remap)
 {
   Palette original(*this);
diff --git a/src/doc/palette.h b/src/doc/palette.h
index 544e8cb4d..2b28d9eb7 100644
--- a/src/doc/palette.h
+++ b/src/doc/palette.h
@@ -1,4 +1,5 @@
 // Aseprite Document Library
+// Copyright (c)      2020 Igara Studio S.A.
 // Copyright (c) 2001-2018 David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -89,6 +90,7 @@ namespace doc {
 
     int findExactMatch(int r, int g, int b, int a, int mask_index) const;
     int findBestfit(int r, int g, int b, int a, int mask_index) const;
+    int findBestfit2(int r, int g, int b) const;
 
     void applyRemap(const Remap& remap);
 
diff --git a/src/doc/rgbmap.h b/src/doc/rgbmap.h
index 54c40a644..d8037c81a 100644
--- a/src/doc/rgbmap.h
+++ b/src/doc/rgbmap.h
@@ -13,11 +13,15 @@
 
 namespace doc {
 
+  class Palette;
+
   // Matches a RGBA value with an index in a color palette (doc::Palette).
   class RgbMap {
   public:
     virtual ~RgbMap() { }
 
+    virtual void regenerateMap(const Palette* palette, const int maskIndex) = 0;
+
     // Should return the best index in a palette that matches the given RGBA values.
     virtual int mapColor(const color_t rgba) const = 0;
 
diff --git a/src/doc/rgbmap_algorithm.h b/src/doc/rgbmap_algorithm.h
new file mode 100644
index 000000000..c8f686ce8
--- /dev/null
+++ b/src/doc/rgbmap_algorithm.h
@@ -0,0 +1,21 @@
+// Aseprite Document Library
+// Copyright (c) 2020 Igara Studio S.A.
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef DOC_RGBMAP_ALGORITHM_H_INCLUDED
+#define DOC_RGBMAP_ALGORITHM_H_INCLUDED
+#pragma once
+
+namespace doc {
+
+  enum class RgbMapAlgorithm {
+    RGB5A3,
+    OCTREE,
+    DEFAULT = RGB5A3
+  };
+
+} // namespace doc
+
+#endif
diff --git a/src/doc/rgbmap_rgb5a3.cpp b/src/doc/rgbmap_rgb5a3.cpp
index 677779c4a..5f0ec2653 100644
--- a/src/doc/rgbmap_rgb5a3.cpp
+++ b/src/doc/rgbmap_rgb5a3.cpp
@@ -24,23 +24,23 @@ namespace doc {
 
 RgbMapRGB5A3::RgbMapRGB5A3()
   : m_map(MAPSIZE)
-  , m_palette(NULL)
+  , m_palette(nullptr)
   , m_modifications(0)
   , m_maskIndex(0)
 {
 }
 
-bool RgbMapRGB5A3::match(const Palette* palette) const
+void RgbMapRGB5A3::regenerateMap(const Palette* palette, int maskIndex)
 {
-  return (m_palette == palette &&
-    m_modifications == palette->getModifications());
-}
+  // Skip useless regenerations
+  if (m_palette == palette &&
+      m_modifications == palette->getModifications() &&
+      m_maskIndex == maskIndex)
+    return;
 
-void RgbMapRGB5A3::regenerate(const Palette* palette, int mask_index)
-{
   m_palette = palette;
   m_modifications = palette->getModifications();
-  m_maskIndex = mask_index;
+  m_maskIndex = maskIndex;
 
   // Mark all entries as invalid (need to be regenerated)
   for (uint16_t& entry : m_map)
diff --git a/src/doc/rgbmap_rgb5a3.h b/src/doc/rgbmap_rgb5a3.h
index e4a108361..05def365b 100644
--- a/src/doc/rgbmap_rgb5a3.h
+++ b/src/doc/rgbmap_rgb5a3.h
@@ -28,10 +28,8 @@ namespace doc {
   public:
     RgbMapRGB5A3();
 
-    bool match(const Palette* palette) const;
-    void regenerate(const Palette* palette, int mask_index);
-
     // RgbMap impl
+    void regenerateMap(const Palette* palette, int maskIndex) override;
     int mapColor(const color_t rgba) const override {
       const int r = rgba_getr(rgba);
       const int g = rgba_getg(rgba);
diff --git a/src/doc/sprite.cpp b/src/doc/sprite.cpp
index f066284e6..2f13a4452 100644
--- a/src/doc/sprite.cpp
+++ b/src/doc/sprite.cpp
@@ -18,6 +18,7 @@
 #include "doc/cels_range.h"
 #include "doc/image_impl.h"
 #include "doc/layer.h"
+#include "doc/octree_map.h"
 #include "doc/palette.h"
 #include "doc/primitives.h"
 #include "doc/remap.h"
@@ -31,9 +32,7 @@
 
 namespace doc {
 
-//////////////////////////////////////////////////////////////////////
-// Constructors/Destructor
-
+static RgbMapAlgorithm g_rgbMapAlgorithm = RgbMapAlgorithm::DEFAULT;
 static gfx::Rect g_defaultGridBounds(0, 0, 16, 16);
 
 // static
@@ -48,6 +47,21 @@ void Sprite::SetDefaultGridBounds(const gfx::Rect& defGridBounds)
   g_defaultGridBounds = defGridBounds;
 }
 
+// static
+RgbMapAlgorithm Sprite::DefaultRgbMapAlgorithm()
+{
+  return g_rgbMapAlgorithm;
+}
+
+// static
+void Sprite::SetDefaultRgbMapAlgorithm(const RgbMapAlgorithm mapAlgo)
+{
+  g_rgbMapAlgorithm = mapAlgo;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Constructors/Destructor
+
 Sprite::Sprite(const ImageSpec& spec,
                int ncolors)
   : Object(ObjectType::Sprite)
@@ -58,7 +72,6 @@ Sprite::Sprite(const ImageSpec& spec,
   , m_frlens(1, 100)            // First frame with 100 msecs of duration
   , m_root(new LayerGroup(this))
   , m_gridBounds(Sprite::DefaultGridBounds())
-  , m_rgbMap(nullptr)           // Initial RGB map
   , m_tags(this)
   , m_slices(this)
 {
@@ -98,9 +111,6 @@ Sprite::~Sprite()
     for (; it != end; ++it)
       delete *it;               // palette
   }
-
-  // Destroy RGB map
-  delete m_rgbMap;
 }
 
 // static
@@ -356,16 +366,20 @@ RgbMap* Sprite::rgbMap(frame_t frame, RgbMapFor forLayer) const
   int maskIndex = (forLayer == RgbMapFor::OpaqueLayer ?
                    -1: transparentColor());
 
-  if (m_rgbMap == NULL) {
-    m_rgbMap = new RgbMapRGB5A3;
-    m_rgbMap->regenerate(palette(frame), maskIndex);
-  }
-  else if (!m_rgbMap->match(palette(frame)) ||
-           m_rgbMap->maskIndex() != maskIndex) {
-    m_rgbMap->regenerate(palette(frame), maskIndex);
+  if (!m_rgbMap || m_rgbMapAlgorithm != g_rgbMapAlgorithm) {
+    m_rgbMapAlgorithm = g_rgbMapAlgorithm;
+    switch (m_rgbMapAlgorithm) {
+      case RgbMapAlgorithm::RGB5A3: m_rgbMap.reset(new RgbMapRGB5A3); break;
+      case RgbMapAlgorithm::OCTREE: m_rgbMap.reset(new OctreeMap); break;
+      default:
+        m_rgbMap.reset(nullptr);
+        ASSERT(false);
+        return nullptr;
+    }
   }
 
-  return m_rgbMap;
+  m_rgbMap->regenerateMap(palette(frame), maskIndex);
+  return m_rgbMap.get();
 }
 
 //////////////////////////////////////////////////////////////////////
diff --git a/src/doc/sprite.h b/src/doc/sprite.h
index 79b1b0125..4cd428e55 100644
--- a/src/doc/sprite.h
+++ b/src/doc/sprite.h
@@ -21,10 +21,12 @@
 #include "doc/object.h"
 #include "doc/pixel_format.h"
 #include "doc/pixel_ratio.h"
+#include "doc/rgbmap_algorithm.h"
 #include "doc/slices.h"
 #include "doc/tags.h"
 #include "gfx/rect.h"
 
+#include <memory>
 #include <vector>
 
 #define DOC_SPRITE_MAX_WIDTH  65535
@@ -101,8 +103,11 @@ namespace doc {
     color_t transparentColor() const { return m_spec.maskColor(); }
     void setTransparentColor(color_t color);
 
+    // Defaults
     static gfx::Rect DefaultGridBounds();
     static void SetDefaultGridBounds(const gfx::Rect& defGridBounds);
+    static RgbMapAlgorithm DefaultRgbMapAlgorithm();
+    static void SetDefaultRgbMapAlgorithm(const RgbMapAlgorithm mapAlgo);
 
     const gfx::Rect& gridBounds() const { return m_gridBounds; }
     void setGridBounds(const gfx::Rect& rc) { m_gridBounds = rc; }
@@ -200,7 +205,8 @@ namespace doc {
     gfx::Rect m_gridBounds;                // grid settings
 
     // Current rgb map
-    mutable RgbMapRGB5A3* m_rgbMap;
+    mutable RgbMapAlgorithm m_rgbMapAlgorithm;
+    mutable std::unique_ptr<RgbMap> m_rgbMap;
 
     Tags m_tags;
     Slices m_slices;

From 2e968d7a09fc6429a5bf8436248a4ae7e7d14027 Mon Sep 17 00:00:00 2001
From: David Capello <david@igarastudio.com>
Date: Fri, 10 Apr 2020 15:51:59 -0300
Subject: [PATCH 4/9] Minor changes in OctreeMap: Avoid extra heap allocations
 for members

---
 src/doc/octree_map.cpp | 50 ++++++++++++++++++++----------------------
 src/doc/octree_map.h   | 12 +++++-----
 2 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/src/doc/octree_map.cpp b/src/doc/octree_map.cpp
index 7aafe5e2b..85874c0f1 100644
--- a/src/doc/octree_map.cpp
+++ b/src/doc/octree_map.cpp
@@ -81,7 +81,7 @@ void OctreeNode::fillMostSignificantNodes(int level)
   }
 }
 
-int OctreeNode::mapColor(int r, int g, int b, int level)
+int OctreeNode::mapColor(int r, int g, int b, int level) const
 {
   int indexLevel = (  (b >> (7 - level)) & 1) * 4
                    + ((g >> (7 - level)) & 1) * 2
@@ -126,28 +126,25 @@ int OctreeNode::removeLeaves(std::vector<OctreeNode*>& auxParentVector,
 }
 
 OctreeMap::OctreeMap()
-  : m_root(new OctreeNode)
-  , m_leavesVector(new std::vector<OctreeNode*>())
-  , m_palette(nullptr)
+  : m_palette(nullptr)
   , m_modifications(0)
 {
 }
 
 bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
 {
-
-  if (root()->children()) {
+  if (m_root.children()) {
     // We create paletteIndex to get a "global like" variable, in collectLeafNodes
     // function, the purpose is having a incremental variable in the stack memory
     // sharend between all recursive calls of collectLeafNodes.
     int paletteIndex = 0;
-    root()->collectLeafNodes(m_leavesVector.get(), paletteIndex);
+    m_root.collectLeafNodes(&m_leavesVector, paletteIndex);
   }
 
   // If we can improve the octree accuracy, makePalette returns false, then
   // outside from this function we must re-construct the octreeMap all again with
   // deep level equal to 8.
-  if (levelDeep == 7 && m_leavesVector->size() < colorCount)
+  if (levelDeep == 7 && m_leavesVector.size() < colorCount)
     return false;
 
 
@@ -155,14 +152,14 @@ bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
   bool keepReducingMap = true;
 
   for (int level = levelDeep; level > -1; level--) {
-    for (int i=m_leavesVector->size()-1; i>=0; i--) {
-      if (m_leavesVector->size() + auxLeavesVector.size() <= colorCount) {
+    for (int i=m_leavesVector.size()-1; i>=0; i--) {
+      if (m_leavesVector.size() + auxLeavesVector.size() <= colorCount) {
         for (int j=0; j < auxLeavesVector.size(); j++)
-          m_leavesVector->push_back(auxLeavesVector[auxLeavesVector.size() - 1 - j]);
+          m_leavesVector.push_back(auxLeavesVector[auxLeavesVector.size() - 1 - j]);
         keepReducingMap = false;
         break;
       }
-      else if (m_leavesVector->size() == 0) {
+      else if (m_leavesVector.size() == 0) {
         // When colorCount is < 8, auxLeavesVector->size() could reach the 8 size,
         // if this is true and we don't stop the regular removeLeaves algorithm,
         // the 8 remains colors will collapse in one.
@@ -191,7 +188,7 @@ bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
           for(;;) {
             if (sortedVector.size() <= colorCount) {
               for (int k=0; k<sortedVector.size(); k++)
-                m_leavesVector->push_back(sortedVector[k]);
+                m_leavesVector.push_back(sortedVector[k]);
               break;
             }
             sortedVector[sortedVector.size()-2]->getLeafColor()
@@ -206,19 +203,19 @@ bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
           break;
       }
 
-      m_leavesVector->back()->parent()->removeLeaves(auxLeavesVector, *m_leavesVector);
+      m_leavesVector.back()->parent()->removeLeaves(auxLeavesVector, m_leavesVector);
     }
     if (keepReducingMap) {
       // Copy collapsed leaves to m_leavesVector
       int auxLeavesVectorSize = auxLeavesVector.size();
       for (int i=0; i<auxLeavesVectorSize; i++)
-        m_leavesVector->push_back(auxLeavesVector[auxLeavesVector.size() - 1 - i]);
+        m_leavesVector.push_back(auxLeavesVector[auxLeavesVector.size() - 1 - i]);
       auxLeavesVector.clear();
     }
     else
       break;
   }
-  int leafCount = m_leavesVector->size();
+  int leafCount = m_leavesVector.size();
   int aux = 0;
   if (m_maskColor == 0x00FFFFFF)
     palette->resize(leafCount);
@@ -229,14 +226,14 @@ bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
   }
 
   for (int i=0; i<leafCount; i++)
-    palette->setEntry(i+aux, (*m_leavesVector)[i]->getLeafColor().normalizeColor().LeafColorToColor());
+    palette->setEntry(i+aux, m_leavesVector[i]->getLeafColor().normalizeColor().LeafColorToColor());
 
   return true;
 }
 
 void OctreeMap::fillOrphansNodes(Palette* palette)
 {
-  m_root->fillOrphansNodes(palette, 0, 0);
+  m_root.fillOrphansNodes(palette, 0, 0);
 }
 
 void OctreeMap::feedWithImage(Image* image, color_t maskColor, int levelDeep)
@@ -260,10 +257,10 @@ int OctreeMap::mapColor(color_t rgba) const
 {
   if (rgba_geta(rgba) == 0 && m_maskColor >= 0)
     return m_maskColor;
-  else if (m_root->children())
-    return m_root->mapColor(rgba_getr(rgba),
-                            rgba_getg(rgba),
-                            rgba_geta(rgba), 0);
+  else if (m_root.children())
+    return m_root.mapColor(rgba_getr(rgba),
+                           rgba_getg(rgba),
+                           rgba_geta(rgba), 0);
   else
     return 0;
 }
@@ -280,11 +277,12 @@ void OctreeMap::regenerateMap(const Palette* palette, const int maskIndex)
       m_maskIndex == maskIndex)
     return;
 
-  m_root.reset(new OctreeNode());
-  m_leavesVector.reset(new std::vector<OctreeNode*>());
+  m_root = OctreeNode();
+  m_leavesVector.clear();
   for (int i=0; i<palette->size(); i++)
-    m_root->addColor(palette->entry(i), 0, m_root.get(), i, 8);
-  m_root->fillOrphansNodes(palette, 0, 0);
+    m_root.addColor(palette->entry(i), 0, &m_root, i, 8);
+  m_root.fillOrphansNodes(palette, 0, 0);
+
   m_palette = palette;
   m_modifications = palette->getModifications();
   m_maskIndex = maskIndex;
diff --git a/src/doc/octree_map.h b/src/doc/octree_map.h
index 324255c4d..6cbc3f222 100644
--- a/src/doc/octree_map.h
+++ b/src/doc/octree_map.h
@@ -12,8 +12,9 @@
 #include "doc/palette.h"
 #include "doc/rgbmap.h"
 
-#include <vector>
 #include <array>
+#include <memory>
+#include <vector>
 
 namespace doc {
 
@@ -112,7 +113,7 @@ public:
 
   void fillMostSignificantNodes(int level);
 
-  int mapColor(int r, int g, int b, int level);
+  int mapColor(int r, int g, int b, int level) const;
 
   void collectLeafNodes(std::vector<OctreeNode*>* leavesVector, int& paletteIndex);
 
@@ -139,7 +140,7 @@ public:
 
   void addColor(color_t color, int levelDeep = 7)
   {
-    m_root->addColor(color, 0, m_root.get(), 0, levelDeep);
+    m_root.addColor(color, 0, &m_root, 0, levelDeep);
   }
 
   // makePalette return true if a 7 level octreeDeep is OK, and false if we can add ONE level deep.
@@ -154,11 +155,10 @@ public:
   int getModifications() const { return m_modifications; };
 
 private:
-  OctreeNode* root() const { return m_root.get(); };
   void fillOrphansNodes(Palette* palette);
 
-  std::unique_ptr<OctreeNode> m_root;
-  std::unique_ptr<std::vector<OctreeNode*>> m_leavesVector;
+  OctreeNode m_root;
+  std::vector<OctreeNode*> m_leavesVector;
   const Palette* m_palette;
   int m_modifications;
   int m_maskIndex;

From f1899ee3976c6d817d760bd75026437a3162af63 Mon Sep 17 00:00:00 2001
From: Gaspar Capello <gaspar@igarastudio.com>
Date: Mon, 13 Apr 2020 11:16:40 -0300
Subject: [PATCH 5/9] Minor fix in OctreeMap::mapColor function

---
 src/doc/octree_map.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/octree_map.cpp b/src/doc/octree_map.cpp
index 85874c0f1..614344cc8 100644
--- a/src/doc/octree_map.cpp
+++ b/src/doc/octree_map.cpp
@@ -260,7 +260,7 @@ int OctreeMap::mapColor(color_t rgba) const
   else if (m_root.children())
     return m_root.mapColor(rgba_getr(rgba),
                            rgba_getg(rgba),
-                           rgba_geta(rgba), 0);
+                           rgba_getb(rgba), 0);
   else
     return 0;
 }

From 696bb9a53794e4137aad3b7ab8bf7724b6a200df Mon Sep 17 00:00:00 2001
From: Gaspar Capello <gaspar@igarastudio.com>
Date: Tue, 14 Apr 2020 20:01:25 -0300
Subject: [PATCH 6/9] Add possibility to use OctreeMap in
 create_palette_from_image()

---
 src/app/commands/cmd_color_quantization.cpp |  8 +--
 src/app/commands/cmd_new_file.cpp           |  3 +-
 src/app/file/file.cpp                       |  3 +-
 src/app/file/file_op_config.cpp             |  1 +
 src/app/file/file_op_config.h               |  6 ++-
 src/doc/octree_map.cpp                      | 15 ++++--
 src/doc/octree_map.h                        | 17 +++++--
 src/render/quantization.cpp                 | 54 +++++++++++++++++----
 src/render/quantization.h                   |  6 ++-
 9 files changed, 86 insertions(+), 27 deletions(-)

diff --git a/src/app/commands/cmd_color_quantization.cpp b/src/app/commands/cmd_color_quantization.cpp
index 5bf34b858..a249ca380 100644
--- a/src/app/commands/cmd_color_quantization.cpp
+++ b/src/app/commands/cmd_color_quantization.cpp
@@ -140,13 +140,15 @@ void ColorQuantizationCommand::onExecute(Context* ctx)
 
     SpriteJob job(reader, "Color Quantization");
     const bool newBlend = Preferences::instance().experimental.newBlend();
+    const RgbMapAlgorithm algorithm = Preferences::instance().experimental.rgbmapAlgorithm();
     job.startJobWithCallback(
-      [sprite, withAlpha, &tmpPalette, &job, newBlend]{
+      [sprite, withAlpha, &tmpPalette, &job, newBlend, algorithm]{
         render::create_palette_from_sprite(
           sprite, 0, sprite->lastFrame(),
           withAlpha, &tmpPalette,
-          &job,
-          newBlend);     // SpriteJob is a render::TaskDelegate
+          &job,                 // SpriteJob is a render::TaskDelegate
+          newBlend,
+          algorithm);
       });
     job.waitJob();
     if (job.isCanceled())
diff --git a/src/app/commands/cmd_new_file.cpp b/src/app/commands/cmd_new_file.cpp
index 0089157da..b3f4d60bf 100644
--- a/src/app/commands/cmd_new_file.cpp
+++ b/src/app/commands/cmd_new_file.cpp
@@ -275,7 +275,8 @@ void NewFileCommand::onExecute(Context* ctx)
       if (clipboardPalette.isBlack()) {
         render::create_palette_from_sprite(
           sprite.get(), 0, sprite->lastFrame(), true,
-          &clipboardPalette, nullptr, true);
+          &clipboardPalette, nullptr, true,
+          Preferences::instance().experimental.rgbmapAlgorithm());
       }
       sprite->setPalette(&clipboardPalette, false);
     }
diff --git a/src/app/file/file.cpp b/src/app/file/file.cpp
index f43cb51a1..41a632aa4 100644
--- a/src/app/file/file.cpp
+++ b/src/app/file/file.cpp
@@ -907,7 +907,8 @@ void FileOp::postLoad()
       std::shared_ptr<Palette> palette(
         render::create_palette_from_sprite(
           sprite, frame_t(0), sprite->lastFrame(), true,
-          nullptr, nullptr, m_config.newBlend));
+          nullptr, nullptr, m_config.newBlend,
+          m_config.rgbMapAlgorithm));
 
       sprite->resetPalettes();
       sprite->setPalette(palette.get(), false);
diff --git a/src/app/file/file_op_config.cpp b/src/app/file/file_op_config.cpp
index b64a6f15f..9c1da155b 100644
--- a/src/app/file/file_op_config.cpp
+++ b/src/app/file/file_op_config.cpp
@@ -22,6 +22,7 @@ void FileOpConfig::fillFromPreferences()
   newBlend = Preferences::instance().experimental.newBlend();
   defaultSliceColor = Preferences::instance().slices.defaultColor();
   workingCS = get_working_rgb_space_from_preferences();
+  rgbMapAlgorithm = Preferences::instance().experimental.rgbmapAlgorithm();
 }
 
 } // namespace app
diff --git a/src/app/file/file_op_config.h b/src/app/file/file_op_config.h
index 2f31a69df..398e034cc 100644
--- a/src/app/file/file_op_config.h
+++ b/src/app/file/file_op_config.h
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2019  Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 //
 // This program is distributed under the terms of
 // the End-User License Agreement for Aseprite.
@@ -10,6 +10,7 @@
 
 #include "app/color.h"
 #include "app/pref/preferences.h"
+#include "doc/rgbmap_algorithm.h"
 #include "gfx/color_space.h"
 
 namespace app {
@@ -32,6 +33,9 @@ namespace app {
 
     app::Color defaultSliceColor = app::Color::fromRgb(0, 0, 255);
 
+    // Algorithm used to create a palette from RGB files.
+    doc::RgbMapAlgorithm rgbMapAlgorithm = doc::RgbMapAlgorithm::DEFAULT;
+
     void fillFromPreferences();
   };
 
diff --git a/src/doc/octree_map.cpp b/src/doc/octree_map.cpp
index 614344cc8..4105e8f9b 100644
--- a/src/doc/octree_map.cpp
+++ b/src/doc/octree_map.cpp
@@ -34,7 +34,8 @@ void OctreeNode::addColor(color_t c, int level, OctreeNode* parent,
 }
 
 void OctreeNode::fillOrphansNodes(const Palette* palette,
-                                  color_t upstreamBranchColor, int level)
+                                  const color_t upstreamBranchColor,
+                                  const int level)
 {
   for (int i=0; i<8; i++) {
     if ((*m_children)[i].m_children)
@@ -131,7 +132,9 @@ OctreeMap::OctreeMap()
 {
 }
 
-bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
+bool OctreeMap::makePalette(Palette* palette,
+                            const int colorCount,
+                            const int levelDeep)
 {
   if (m_root.children()) {
     // We create paletteIndex to get a "global like" variable, in collectLeafNodes
@@ -231,18 +234,20 @@ bool OctreeMap::makePalette(Palette* palette, int colorCount, int levelDeep)
   return true;
 }
 
-void OctreeMap::fillOrphansNodes(Palette* palette)
+void OctreeMap::fillOrphansNodes(const Palette* palette)
 {
   m_root.fillOrphansNodes(palette, 0, 0);
 }
 
-void OctreeMap::feedWithImage(Image* image, color_t maskColor, int levelDeep)
+void OctreeMap::feedWithImage(const Image* image,
+                              const color_t maskColor,
+                              const int levelDeep)
 {
   ASSERT(image);
   ASSERT(image->pixelFormat() == IMAGE_RGB);
   uint32_t color;
   const LockImageBits<RgbTraits> bits(image);
-  LockImageBits<RgbTraits>::const_iterator it = bits.begin(), end = bits.end();
+  auto it = bits.begin(), end = bits.end();
 
   for (; it != end; ++it) {
     color = *it;
diff --git a/src/doc/octree_map.h b/src/doc/octree_map.h
index 6cbc3f222..9243cf913 100644
--- a/src/doc/octree_map.h
+++ b/src/doc/octree_map.h
@@ -109,7 +109,9 @@ public:
   void addColor(color_t c, int level, OctreeNode* parent,
                 int paletteIndex = 0, int levelDeep = 7);
 
-  void fillOrphansNodes(const Palette* palette, color_t upstreamBranchColor, int level);
+  void fillOrphansNodes(const Palette* palette,
+                        const color_t upstreamBranchColor,
+                        const int level);
 
   void fillMostSignificantNodes(int level);
 
@@ -143,10 +145,15 @@ public:
     m_root.addColor(color, 0, &m_root, 0, levelDeep);
   }
 
-  // makePalette return true if a 7 level octreeDeep is OK, and false if we can add ONE level deep.
-  bool makePalette(Palette* palette, int colorCount, int leveleep = 7);
+  // makePalette returns true if a 7 level octreeDeep is OK, and false
+  // if we can add ONE level deep.
+  bool makePalette(Palette* palette,
+                   const int colorCount,
+                   const int levelDeep = 7);
 
-  void feedWithImage(Image* image, color_t maskColor, int levelDeep = 7);
+  void feedWithImage(const Image* image,
+                     const color_t maskColor,
+                     const int levelDeep = 7);
 
   // RgbMap impl
   void regenerateMap(const Palette* palette, const int maskIndex) override;
@@ -155,7 +162,7 @@ public:
   int getModifications() const { return m_modifications; };
 
 private:
-  void fillOrphansNodes(Palette* palette);
+  void fillOrphansNodes(const Palette* palette);
 
   OctreeNode m_root;
   std::vector<OctreeNode*> m_leavesVector;
diff --git a/src/render/quantization.cpp b/src/render/quantization.cpp
index 657ced0b1..7617861cd 100644
--- a/src/render/quantization.cpp
+++ b/src/render/quantization.cpp
@@ -13,10 +13,10 @@
 
 #include "doc/image_impl.h"
 #include "doc/layer.h"
+#include "doc/octree_map.h"
 #include "doc/palette.h"
 #include "doc/primitives.h"
 #include "doc/remap.h"
-#include "doc/rgbmap.h"
 #include "doc/sprite.h"
 #include "gfx/hsv.h"
 #include "gfx/rgb.h"
@@ -44,9 +44,14 @@ Palette* create_palette_from_sprite(
   const bool withAlpha,
   Palette* palette,
   TaskDelegate* delegate,
-  const bool newBlend)
+  const bool newBlend,
+  const RgbMapAlgorithm mappingAlgorithm)
 {
   PaletteOptimizer optimizer;
+  OctreeMap octreemap;
+  const color_t maskColor = (sprite->backgroundLayer()
+                             && sprite->allLayersCount() == 1) ? 0x00FFFFFF:
+                                                                 sprite->transparentColor();
 
   if (!palette)
     palette = new Palette(fromFrame, 256);
@@ -60,7 +65,15 @@ Palette* create_palette_from_sprite(
   render.setNewBlend(newBlend);
   for (frame_t frame=fromFrame; frame<=toFrame; ++frame) {
     render.renderSprite(flat_image.get(), sprite, frame);
-    optimizer.feedWithImage(flat_image.get(), withAlpha);
+
+    switch (mappingAlgorithm) {
+      case RgbMapAlgorithm::RGB5A3:
+        optimizer.feedWithImage(flat_image.get(), withAlpha);
+        break;
+      case RgbMapAlgorithm::OCTREE:
+        octreemap.feedWithImage(flat_image.get(), maskColor);
+        break;
+    }
 
     if (delegate) {
       if (!delegate->continueTask())
@@ -71,12 +84,35 @@ Palette* create_palette_from_sprite(
     }
   }
 
-  // Generate an optimized palette
-  optimizer.calculate(
-    palette,
-    // Transparent color is needed if we have transparent layers
-    (sprite->backgroundLayer() &&
-     sprite->allLayersCount() == 1 ? -1: sprite->transparentColor()));
+  switch (mappingAlgorithm) {
+    case RgbMapAlgorithm::RGB5A3:
+      // Generate an optimized palette
+      optimizer.calculate(
+        palette,
+        // Transparent color is needed if we have transparent layers
+        (sprite->backgroundLayer() &&
+         sprite->allLayersCount() == 1 ? -1: sprite->transparentColor()));
+      break;
+    case RgbMapAlgorithm::OCTREE:
+      if (!octreemap.makePalette(palette, palette->size())) {
+        // We can use an 8-bit deep octree map, instead of 7-bit of the
+        // first attempt.
+        octreemap = OctreeMap();
+        for (frame_t frame=fromFrame; frame<=toFrame; ++frame) {
+          render.renderSprite(flat_image.get(), sprite, frame);
+          octreemap.feedWithImage(flat_image.get(), maskColor , 8);
+          if (delegate) {
+            if (!delegate->continueTask())
+              return nullptr;
+
+            delegate->notifyTaskProgress(
+              double(frame-fromFrame+1) / double(toFrame-fromFrame+1));
+          }
+        }
+        octreemap.makePalette(palette, palette->size(), 8);
+      }
+      break;
+  }
 
   return palette;
 }
diff --git a/src/render/quantization.h b/src/render/quantization.h
index 7e8876840..27fe354c8 100644
--- a/src/render/quantization.h
+++ b/src/render/quantization.h
@@ -1,5 +1,5 @@
 // Aseprite Rener Library
-// Copyright (c) 2019  Igara Studio S.A.
+// Copyright (c) 2019-2020  Igara Studio S.A.
 // Copyright (c) 2001-2017  David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -11,6 +11,7 @@
 
 #include "doc/frame.h"
 #include "doc/pixel_format.h"
+#include "doc/rgbmap_algorithm.h"
 #include "render/color_histogram.h"
 
 #include <vector>
@@ -45,7 +46,8 @@ namespace render {
     const bool withAlpha,
     doc::Palette* newPalette, // Can be NULL to create a new palette
     TaskDelegate* delegate,
-    const bool newBlend);
+    const bool newBlend,
+    const RgbMapAlgorithm mappingAlgorithm);
 
   // Changes the image pixel format. The dithering method is used only
   // when you want to convert from RGB to Indexed.

From 80cbb2caf59ae0a7ba6c5129455c594112d6eefa Mon Sep 17 00:00:00 2001
From: Gaspar Capello <gaspar@igarastudio.com>
Date: Wed, 15 Apr 2020 11:05:41 -0300
Subject: [PATCH 7/9] Add combobox to select RGB5A5/Octree algorithms in
 ColorQuantization dialog

---
 data/pref.xml                               |  1 +
 data/strings/en.ini                         |  3 +-
 data/widgets/palette_from_sprite.xml        | 11 +++-
 src/app/commands/cmd_color_quantization.cpp | 71 +++++++++++++++++++--
 4 files changed, 77 insertions(+), 9 deletions(-)

diff --git a/data/pref.xml b/data/pref.xml
index 07be3977f..8fde75eb3 100644
--- a/data/pref.xml
+++ b/data/pref.xml
@@ -258,6 +258,7 @@
       <option id="with_alpha" type="bool" default="true" />
       <option id="dithering_algorithm" type="std::string" />
       <option id="dithering_factor" type="int" default="100" />
+      <option id="advanced" type="bool" default="false" />
     </section>
     <section id="eyedropper" text="Editor">
       <option id="channel" type="EyedropperChannel" default="EyedropperChannel::COLOR_ALPHA" />
diff --git a/data/strings/en.ini b/data/strings/en.ini
index e812fc395..d96da92c2 100644
--- a/data/strings/en.ini
+++ b/data/strings/en.ini
@@ -1258,10 +1258,11 @@ bg_color = Background Color:
 
 [palette_from_sprite]
 title = Palette from Sprite
-new_palette = Create a new palette with a specific number of colors (or less):
+new_palette = Create new palette, color count limit:
 replace_palette = Replace current palette
 replace_range = Replace current range
 alpha_channel = Create entries with alpha component
+advanced_options = Advanced Options
 
 [palette_popup]
 load = &Load
diff --git a/data/widgets/palette_from_sprite.xml b/data/widgets/palette_from_sprite.xml
index b6d882c5f..0f3e0cbab 100644
--- a/data/widgets/palette_from_sprite.xml
+++ b/data/widgets/palette_from_sprite.xml
@@ -1,5 +1,6 @@
 <!-- Aseprite -->
-<!-- Copyright (C) 2015-2018 by David Capello -->
+<!-- Copyright (c) 2020  Igara Studio S.A. -->
+<!-- Copyright (c) 2015-2018  David Capello -->
 <gui>
 <window id="palette_from_sprite" text="@.title">
   <grid columns="2">
@@ -7,7 +8,15 @@
     <expr expansive="true" id="ncolors" magnet="true" />
     <radio id="current_palette" text="@.replace_palette" group="1" cell_hspan="2" />
     <radio id="current_range" text="@.replace_range" group="1" cell_hspan="2" />
+
+    <separator horizontal="true" cell_hspan="2" />
+
     <check id="alpha_channel" text="@.alpha_channel" cell_hspan="2" />
+    <check id="advanced_check" text="@.advanced_options" cell_hspan="2" />
+    <hbox id="advanced" cell_hspan="2">
+      <label text="@rgbmap_algorithm_selector.label" />
+      <hbox id="rgbmap_algorithm_placeholder" />
+    </hbox>
 
     <separator horizontal="true" cell_hspan="2" />
 
diff --git a/src/app/commands/cmd_color_quantization.cpp b/src/app/commands/cmd_color_quantization.cpp
index a249ca380..57dd8d42f 100644
--- a/src/app/commands/cmd_color_quantization.cpp
+++ b/src/app/commands/cmd_color_quantization.cpp
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2019 Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 // Copyright (C) 2001-2018  David Capello
 //
 // This program is distributed under the terms of
@@ -20,10 +20,12 @@
 #include "app/sprite_job.h"
 #include "app/transaction.h"
 #include "app/ui/color_bar.h"
+#include "app/ui/rgbmap_algorithm_selector.h"
 #include "app/ui_context.h"
 #include "doc/palette.h"
 #include "doc/sprite.h"
 #include "render/quantization.h"
+#include "ui/manager.h"
 
 #include "palette_from_sprite.xml.h"
 
@@ -36,8 +38,53 @@ struct ColorQuantizationParams : public NewParams {
   Param<bool> withAlpha { this, true, "withAlpha" };
   Param<int> maxColors { this, 256, "maxColors" };
   Param<bool> useRange { this, false, "useRange" };
+  Param<RgbMapAlgorithm> algorithm { this, RgbMapAlgorithm::DEFAULT, "algorithm" };
 };
 
+#if ENABLE_UI
+
+class PaletteFromSpriteWindow : public app::gen::PaletteFromSprite {
+public:
+  PaletteFromSpriteWindow() {
+    rgbmapAlgorithmPlaceholder()->addChild(&m_algoSelector);
+
+    advancedCheck()->Click.connect(
+      [this](ui::Event&){
+        advanced()->setVisible(advancedCheck()->isSelected());
+
+        const gfx::Rect origBounds = bounds();
+        setBounds(gfx::Rect(bounds().origin(), sizeHint()));
+        manager()->invalidateRect(origBounds);
+      });
+
+    m_algoSelector.Change.connect(
+      [this](){
+        switch (algorithm()) {
+          case RgbMapAlgorithm::RGB5A3:
+            alphaChannel()->setEnabled(true);
+            break;
+          case RgbMapAlgorithm::OCTREE:
+            alphaChannel()->setSelected(false);
+            alphaChannel()->setEnabled(false);
+            break;
+        }
+      });
+  }
+
+  doc::RgbMapAlgorithm algorithm() {
+    return m_algoSelector.algorithm();
+  }
+
+  void algorithm(const doc::RgbMapAlgorithm mapAlgo) {
+    m_algoSelector.algorithm(mapAlgo);
+  }
+
+private:
+  RgbMapAlgorithmSelector m_algoSelector;
+};
+
+#endif
+
 class ColorQuantizationCommand : public CommandWithNewParams<ColorQuantizationParams> {
 public:
   ColorQuantizationCommand();
@@ -65,8 +112,10 @@ void ColorQuantizationCommand::onExecute(Context* ctx)
   const bool ui = (params().ui() && ctx->isUIAvailable());
 #endif
 
+  auto& pref = Preferences::instance();
   bool withAlpha = params().withAlpha();
   int maxColors = params().maxColors();
+  RgbMapAlgorithm algorithm = params().algorithm();
   bool createPal;
 
   Site site = ctx->activeSite();
@@ -74,16 +123,22 @@ void ColorQuantizationCommand::onExecute(Context* ctx)
 
 #ifdef ENABLE_UI
   if (ui) {
-    app::gen::PaletteFromSprite window;
+    PaletteFromSpriteWindow window;
     {
       ContextReader reader(ctx);
       const Palette* curPalette = site.sprite()->palette(site.frame());
 
+      if (!params().algorithm.isSet())
+        algorithm = pref.experimental.rgbmapAlgorithm();
       if (!params().withAlpha.isSet())
-        withAlpha = App::instance()->preferences().quantization.withAlpha();
+        withAlpha = pref.quantization.withAlpha();
 
+      const bool advanced = pref.quantization.advanced();
+      window.advancedCheck()->setSelected(advanced);
+      window.advanced()->setVisible(advanced);
+
+      window.algorithm(algorithm);
       window.newPalette()->setSelected(true);
-      window.alphaChannel()->setSelected(withAlpha);
       window.ncolors()->setTextf("%d", maxColors);
 
       if (entries.picks() > 1) {
@@ -107,7 +162,10 @@ void ColorQuantizationCommand::onExecute(Context* ctx)
 
     maxColors = window.ncolors()->textInt();
     withAlpha = window.alphaChannel()->isSelected();
-    App::instance()->preferences().quantization.withAlpha(withAlpha);
+    algorithm = window.algorithm();
+
+    pref.quantization.withAlpha(withAlpha);
+    pref.quantization.advanced(window.advancedCheck()->isSelected());
 
     if (window.newPalette()->isSelected()) {
       createPal = true;
@@ -139,8 +197,7 @@ void ColorQuantizationCommand::onExecute(Context* ctx)
     Palette tmpPalette(frame, entries.picks());
 
     SpriteJob job(reader, "Color Quantization");
-    const bool newBlend = Preferences::instance().experimental.newBlend();
-    const RgbMapAlgorithm algorithm = Preferences::instance().experimental.rgbmapAlgorithm();
+    const bool newBlend = pref.experimental.newBlend();
     job.startJobWithCallback(
       [sprite, withAlpha, &tmpPalette, &job, newBlend, algorithm]{
         render::create_palette_from_sprite(

From 966daf5e34158d0e7a33a4a9505302bed2a0097b Mon Sep 17 00:00:00 2001
From: Gaspar Capello <gaspar@igarastudio.com>
Date: Wed, 15 Apr 2020 15:36:50 -0300
Subject: [PATCH 8/9] Add RgbMap algorithm option in RGB -> Indexed color mode
 conversion dialog

---
 data/strings/en.ini                          |  3 +-
 data/widgets/color_mode.xml                  | 10 ++-
 data/widgets/new_sprite.xml                  |  5 +-
 data/widgets/palette_from_sprite.xml         |  2 +-
 src/app/cmd/set_pixel_format.cpp             |  6 +-
 src/app/cmd/set_pixel_format.h               |  4 +-
 src/app/commands/cmd_change_pixel_format.cpp | 90 +++++++++++++++++---
 src/app/doc_exporter.cpp                     |  1 +
 src/doc/sprite.cpp                           | 27 ++++--
 src/doc/sprite.h                             |  9 +-
 10 files changed, 126 insertions(+), 31 deletions(-)

diff --git a/data/strings/en.ini b/data/strings/en.ini
index d96da92c2..f057bfe94 100644
--- a/data/strings/en.ini
+++ b/data/strings/en.ini
@@ -666,6 +666,7 @@ Check in case that you want to establish
 the given option as the default option.
 END
 reset = Reset
+advanced_options = Advanced Options
 
 [gif_options]
 title = GIF Options
@@ -965,7 +966,6 @@ background = Background:
 transparent = &Transparent
 white = &White
 black = &Black
-advanced_options = Advanced Options
 pixel_ratio = Pixel Aspect Ratio:
 square_pixels = Square Pixels (1:1)
 double_wide = Double-wide Pixels (2:1)
@@ -1262,7 +1262,6 @@ new_palette = Create new palette, color count limit:
 replace_palette = Replace current palette
 replace_range = Replace current range
 alpha_channel = Create entries with alpha component
-advanced_options = Advanced Options
 
 [palette_popup]
 load = &Load
diff --git a/data/widgets/color_mode.xml b/data/widgets/color_mode.xml
index adf4e8e9c..9cc1d2ea5 100644
--- a/data/widgets/color_mode.xml
+++ b/data/widgets/color_mode.xml
@@ -1,5 +1,5 @@
 <!-- Aseprite -->
-<!-- Copyright (C) 2019  Igara Studio S.A. -->
+<!-- Copyright (C) 2019-2020  Igara Studio S.A. -->
 <!-- Copyright (C) 2017  David Capello -->
 <gui>
 <window id="color_mode" text="@.title">
@@ -13,7 +13,15 @@
       <slider min="0" max="100" id="factor" minwidth="100" />
       <label text="%" />
     </hbox>
+
     <check text="@.flatten" id="flatten" />
+
+    <check id="advanced_check" text="@general.advanced_options" cell_hspan="2" />
+    <hbox id="advanced" cell_hspan="2">
+      <label text="@rgbmap_algorithm_selector.label" />
+      <hbox id="rgbmap_algorithm_placeholder" />
+    </hbox>
+
     <separator horizontal="true" />
     <hbox>
       <slider min="0" max="100" id="progress" minwidth="100" />
diff --git a/data/widgets/new_sprite.xml b/data/widgets/new_sprite.xml
index 4454f6949..2041ef933 100644
--- a/data/widgets/new_sprite.xml
+++ b/data/widgets/new_sprite.xml
@@ -1,5 +1,6 @@
 <!-- Aseprite -->
-<!-- Copyright (C) 2001-2018 by David Capello -->
+<!-- Copyright (c) 2020  Igara Studio S.A. -->
+<!-- Copyright (c) 2001-2018  David Capello -->
 <gui>
   <window id="new_sprite" text="@.title">
     <box vertical="true">
@@ -26,7 +27,7 @@
         <item text="@.black" icon="icon_black" />
       </buttonset>
 
-      <check id="advanced_check" text="@.advanced_options" />
+      <check id="advanced_check" text="@general.advanced_options" />
       <vbox id="advanced">
         <label text="@.pixel_ratio" />
         <combobox id="pixel_ratio" cell_align="horizontal">
diff --git a/data/widgets/palette_from_sprite.xml b/data/widgets/palette_from_sprite.xml
index 0f3e0cbab..11a73a731 100644
--- a/data/widgets/palette_from_sprite.xml
+++ b/data/widgets/palette_from_sprite.xml
@@ -12,7 +12,7 @@
     <separator horizontal="true" cell_hspan="2" />
 
     <check id="alpha_channel" text="@.alpha_channel" cell_hspan="2" />
-    <check id="advanced_check" text="@.advanced_options" cell_hspan="2" />
+    <check id="advanced_check" text="@general.advanced_options" cell_hspan="2" />
     <hbox id="advanced" cell_hspan="2">
       <label text="@rgbmap_algorithm_selector.label" />
       <hbox id="rgbmap_algorithm_placeholder" />
diff --git a/src/app/cmd/set_pixel_format.cpp b/src/app/cmd/set_pixel_format.cpp
index f78c9318b..e999f8d86 100644
--- a/src/app/cmd/set_pixel_format.cpp
+++ b/src/app/cmd/set_pixel_format.cpp
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2019  Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 // Copyright (C) 2001-2018  David Capello
 //
 // This program is distributed under the terms of
@@ -69,6 +69,7 @@ private:
 SetPixelFormat::SetPixelFormat(Sprite* sprite,
                                const PixelFormat newFormat,
                                const render::Dithering& dithering,
+                               const doc::RgbMapAlgorithm mapAlgorithm,
                                render::TaskDelegate* delegate)
   : WithSprite(sprite)
   , m_oldFormat(sprite->pixelFormat())
@@ -78,6 +79,7 @@ SetPixelFormat::SetPixelFormat(Sprite* sprite,
     return;
 
   SuperDelegate superDel(sprite->uniqueCels().size(), delegate);
+  const auto rgbMapFor = sprite->rgbMapForSprite();
 
   for (Cel* cel : sprite->uniqueCels()) {
     ImageRef old_image = cel->imageRef();
@@ -85,7 +87,7 @@ SetPixelFormat::SetPixelFormat(Sprite* sprite,
       render::convert_pixel_format
       (old_image.get(), nullptr, newFormat,
        dithering,
-       sprite->rgbMap(cel->frame()),
+       sprite->rgbMap(cel->frame(), rgbMapFor, mapAlgorithm),
        sprite->palette(cel->frame()),
        cel->layer()->isBackground(),
        old_image->maskColor(),
diff --git a/src/app/cmd/set_pixel_format.h b/src/app/cmd/set_pixel_format.h
index 178274d91..8d1876e66 100644
--- a/src/app/cmd/set_pixel_format.h
+++ b/src/app/cmd/set_pixel_format.h
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2019  Igara Studio S.A.
+// Copyright (C) 2019-2020  Igara Studio S.A.
 // Copyright (C) 2001-2017  David Capello
 //
 // This program is distributed under the terms of
@@ -12,6 +12,7 @@
 #include "app/cmd/with_sprite.h"
 #include "app/cmd_sequence.h"
 #include "doc/pixel_format.h"
+#include "doc/rgbmap_algorithm.h"
 
 namespace doc {
   class Sprite;
@@ -31,6 +32,7 @@ namespace cmd {
     SetPixelFormat(doc::Sprite* sprite,
                    const doc::PixelFormat newFormat,
                    const render::Dithering& dithering,
+                   const doc::RgbMapAlgorithm mapAlgorithm,
                    render::TaskDelegate* delegate);
 
   protected:
diff --git a/src/app/commands/cmd_change_pixel_format.cpp b/src/app/commands/cmd_change_pixel_format.cpp
index e6e9ac914..47ea53ec8 100644
--- a/src/app/commands/cmd_change_pixel_format.cpp
+++ b/src/app/commands/cmd_change_pixel_format.cpp
@@ -26,6 +26,7 @@
 #include "app/ui/dithering_selector.h"
 #include "app/ui/editor/editor.h"
 #include "app/ui/editor/editor_render.h"
+#include "app/ui/rgbmap_algorithm_selector.h"
 #include "app/ui/skin/skin_theme.h"
 #include "base/bind.h"
 #include "base/thread.h"
@@ -79,6 +80,7 @@ public:
                 const doc::frame_t frame,
                 const doc::PixelFormat pixelFormat,
                 const render::Dithering& dithering,
+                const doc::RgbMapAlgorithm rgbMapAlgorithm,
                 const gfx::Point& pos,
                 const bool newBlend)
     : m_image(dstImage)
@@ -91,10 +93,12 @@ public:
        sprite, frame,
        pixelFormat,
        dithering,
+       rgbMapAlgorithm,
        newBlend]() { // Copy the matrix
         run(sprite, frame,
             pixelFormat,
             dithering,
+            rgbMapAlgorithm,
             newBlend);
       })
   {
@@ -118,6 +122,7 @@ private:
            const doc::frame_t frame,
            const doc::PixelFormat pixelFormat,
            const render::Dithering& dithering,
+           const doc::RgbMapAlgorithm rgbMapAlgorithm,
            const bool newBlend) {
     doc::ImageRef tmp(
       Image::create(sprite->pixelFormat(),
@@ -138,7 +143,9 @@ private:
       m_image.get(),
       pixelFormat,
       dithering,
-      sprite->rgbMap(frame),
+      sprite->rgbMap(frame,
+                     sprite->rgbMapForSprite(),
+                     rgbMapAlgorithm),
       sprite->palette(frame),
       (sprite->backgroundLayer() != nullptr),
       0,
@@ -174,9 +181,11 @@ public:
     , m_imageBuffer(new doc::ImageBuffer)
     , m_selectedItem(nullptr)
     , m_ditheringSelector(nullptr)
+    , m_mapAlgorithmSelector(nullptr)
     , m_imageJustCreated(true)
   {
-    doc::PixelFormat from = m_editor->sprite()->pixelFormat();
+    const auto& pref = Preferences::instance();
+    const doc::PixelFormat from = m_editor->sprite()->pixelFormat();
 
     // Add the color mode in the window title
     switch (from) {
@@ -194,22 +203,48 @@ public:
       m_ditheringSelector = new DitheringSelector(DitheringSelector::SelectBoth);
       m_ditheringSelector->setExpansive(true);
 
+      m_mapAlgorithmSelector = new RgbMapAlgorithmSelector;
+      m_mapAlgorithmSelector->setExpansive(true);
+
       // Select default dithering method
       {
         int index = m_ditheringSelector->findItemIndex(
-          Preferences::instance().quantization.ditheringAlgorithm());
+          pref.quantization.ditheringAlgorithm());
         if (index >= 0)
           m_ditheringSelector->setSelectedItemIndex(index);
       }
 
-      m_ditheringSelector->Change.connect(
-        base::Bind<void>(&ColorModeWindow::onDithering, this));
-      ditheringPlaceholder()->addChild(m_ditheringSelector);
+      // Select default RgbMap algorithm
+      m_mapAlgorithmSelector->algorithm(pref.experimental.rgbmapAlgorithm());
 
-      factor()->Change.connect(base::Bind<void>(&ColorModeWindow::onDithering, this));
+      ditheringPlaceholder()->addChild(m_ditheringSelector);
+      rgbmapAlgorithmPlaceholder()->addChild(m_mapAlgorithmSelector);
+
+      const bool adv = pref.quantization.advanced();
+      advancedCheck()->setSelected(adv);
+      advanced()->setVisible(adv);
+
+      // Signals
+      m_ditheringSelector->Change.connect(
+        base::Bind<void>(&ColorModeWindow::onIndexParamChange, this));
+      m_mapAlgorithmSelector->Change.connect(
+        base::Bind<void>(&ColorModeWindow::onIndexParamChange, this));
+      factor()->Change.connect(
+        base::Bind<void>(&ColorModeWindow::onIndexParamChange, this));
+
+      advancedCheck()->Click.connect(
+        [this](ui::Event&){
+          advanced()->setVisible(advancedCheck()->isSelected());
+
+          const gfx::Rect origBounds = bounds();
+          setBounds(gfx::Rect(bounds().origin(), sizeHint()));
+          manager()->invalidateRect(origBounds);
+        });
     }
     else {
       amount()->setVisible(false);
+      advancedCheck()->setVisible(false);
+      advanced()->setVisible(false);
     }
     if (from != IMAGE_GRAYSCALE)
       colorMode()->addChild(new ConversionItem(IMAGE_GRAYSCALE));
@@ -224,7 +259,7 @@ public:
     progress()->setReadOnly(true);
 
     // Default dithering factor
-    factor()->setValue(Preferences::instance().quantization.ditheringFactor());
+    factor()->setValue(pref.quantization.ditheringFactor());
 
     // Select first option
     colorMode()->selectIndex(0);
@@ -249,24 +284,36 @@ public:
     return d;
   }
 
+  doc::RgbMapAlgorithm rgbMapAlgorithm() const {
+    if (m_mapAlgorithmSelector)
+      return m_mapAlgorithmSelector->algorithm();
+    else
+      return doc::RgbMapAlgorithm::DEFAULT;
+  }
+
   bool flattenEnabled() const {
     return flatten()->isSelected();
   }
 
-  // Save the dithering method used for the future
-  void saveDitheringOptions() {
+  void saveOptions() {
+    auto& pref = Preferences::instance();
+
+    // Save the dithering method used for the future
     if (m_ditheringSelector) {
       if (auto item = m_ditheringSelector->getSelectedItem()) {
-        Preferences::instance().quantization.ditheringAlgorithm(
+        pref.quantization.ditheringAlgorithm(
           item->text());
 
         if (m_ditheringSelector->ditheringAlgorithm() ==
             render::DitheringAlgorithm::ErrorDiffusion) {
-          Preferences::instance().quantization.ditheringFactor(
+          pref.quantization.ditheringFactor(
             factor()->getValue());
         }
       }
     }
+
+    if (m_mapAlgorithmSelector)
+      pref.quantization.advanced(advancedCheck()->isSelected());
   }
 
 private:
@@ -336,13 +383,14 @@ private:
         m_editor->frame(),
         dstPixelFormat,
         dithering(),
+        rgbMapAlgorithm(),
         visibleBounds.origin(),
         Preferences::instance().experimental.newBlend()));
 
     m_timer.start();
   }
 
-  void onDithering() {
+  void onIndexParamChange() {
     stop();
     m_selectedItem = nullptr;
     onChangeColorMode();
@@ -382,6 +430,7 @@ private:
   std::unique_ptr<ConvertThread> m_bgThread;
   ConversionItem* m_selectedItem;
   DitheringSelector* m_ditheringSelector;
+  RgbMapAlgorithmSelector* m_mapAlgorithmSelector;
   bool m_imageJustCreated;
 };
 
@@ -402,6 +451,7 @@ private:
   bool m_useUI;
   doc::PixelFormat m_format;
   render::Dithering m_dithering;
+  doc::RgbMapAlgorithm m_rgbmap;
 };
 
 ChangePixelFormatCommand::ChangePixelFormatCommand()
@@ -410,6 +460,7 @@ ChangePixelFormatCommand::ChangePixelFormatCommand()
   m_useUI = true;
   m_format = IMAGE_RGB;
   m_dithering = render::Dithering();
+  m_rgbmap = doc::RgbMapAlgorithm::DEFAULT;
 }
 
 void ChangePixelFormatCommand::onLoadParams(const Params& params)
@@ -454,6 +505,15 @@ void ChangePixelFormatCommand::onLoadParams(const Params& params)
     // TODO object slicing here (from BayerMatrix -> DitheringMatrix)
     m_dithering.matrix(render::BayerMatrix(8));
   }
+
+  // TODO change this with NewParams as in ColorQuantizationParams
+  std::string rgbmap = params.get("rgbmap");
+  if (rgbmap == "octree")
+    m_rgbmap = doc::RgbMapAlgorithm::OCTREE;
+  else if (rgbmap == "rgb5a3")
+    m_rgbmap = doc::RgbMapAlgorithm::RGB5A3;
+  else
+    m_rgbmap = doc::RgbMapAlgorithm::DEFAULT;
 }
 
 bool ChangePixelFormatCommand::onEnabled(Context* context)
@@ -518,9 +578,10 @@ void ChangePixelFormatCommand::onExecute(Context* context)
 
     m_format = window.pixelFormat();
     m_dithering = window.dithering();
+    m_rgbmap = window.rgbMapAlgorithm();
     flatten = window.flattenEnabled();
 
-    window.saveDitheringOptions();
+    window.saveOptions();
   }
 #endif // ENABLE_UI
 
@@ -554,6 +615,7 @@ void ChangePixelFormatCommand::onExecute(Context* context)
           new cmd::SetPixelFormat(
             sprite, m_format,
             m_dithering,
+            m_rgbmap,
             &job));             // SpriteJob is a render::TaskDelegate
       });
     job.waitJob();
diff --git a/src/app/doc_exporter.cpp b/src/app/doc_exporter.cpp
index a6e8877c9..593285ee7 100644
--- a/src/app/doc_exporter.cpp
+++ b/src/app/doc_exporter.cpp
@@ -1179,6 +1179,7 @@ void DocExporter::renderTexture(Context* ctx,
         sample.sprite(),
         textureImage->pixelFormat(),
         render::Dithering(),
+        Sprite::DefaultRgbMapAlgorithm(), // TODO add rgbmap algorithm preference
         nullptr)                // TODO add a delegate to show progress
         .execute(ctx);
     }
diff --git a/src/doc/sprite.cpp b/src/doc/sprite.cpp
index 2f13a4452..b1572d3d1 100644
--- a/src/doc/sprite.cpp
+++ b/src/doc/sprite.cpp
@@ -355,19 +355,34 @@ void Sprite::deletePalette(frame_t frame)
   }
 }
 
-RgbMap* Sprite::rgbMap(frame_t frame) const
+Sprite::RgbMapFor Sprite::rgbMapForSprite() const
 {
-  return rgbMap(frame, backgroundLayer() ? RgbMapFor::OpaqueLayer:
-                                           RgbMapFor::TransparentLayer);
+  return backgroundLayer() ? RgbMapFor::OpaqueLayer:
+                             RgbMapFor::TransparentLayer;
 }
 
-RgbMap* Sprite::rgbMap(frame_t frame, RgbMapFor forLayer) const
+RgbMap* Sprite::rgbMap(const frame_t frame) const
+{
+  return rgbMap(frame, rgbMapForSprite());
+}
+
+RgbMap* Sprite::rgbMap(const frame_t frame,
+                       const RgbMapFor forLayer) const
+{
+  return rgbMap(frame,
+                forLayer,
+                g_rgbMapAlgorithm);
+}
+
+RgbMap* Sprite::rgbMap(const frame_t frame,
+                       const RgbMapFor forLayer,
+                       const RgbMapAlgorithm mapAlgo) const
 {
   int maskIndex = (forLayer == RgbMapFor::OpaqueLayer ?
                    -1: transparentColor());
 
-  if (!m_rgbMap || m_rgbMapAlgorithm != g_rgbMapAlgorithm) {
-    m_rgbMapAlgorithm = g_rgbMapAlgorithm;
+  if (!m_rgbMap || m_rgbMapAlgorithm != mapAlgo) {
+    m_rgbMapAlgorithm = mapAlgo;
     switch (m_rgbMapAlgorithm) {
       case RgbMapAlgorithm::RGB5A3: m_rgbMap.reset(new RgbMapRGB5A3); break;
       case RgbMapAlgorithm::OCTREE: m_rgbMap.reset(new OctreeMap); break;
diff --git a/src/doc/sprite.h b/src/doc/sprite.h
index 4cd428e55..2e63dee54 100644
--- a/src/doc/sprite.h
+++ b/src/doc/sprite.h
@@ -137,8 +137,13 @@ namespace doc {
 
     void deletePalette(frame_t frame);
 
-    RgbMap* rgbMap(frame_t frame) const;
-    RgbMap* rgbMap(frame_t frame, RgbMapFor forLayer) const;
+    RgbMapFor rgbMapForSprite() const;
+    RgbMap* rgbMap(const frame_t frame) const;
+    RgbMap* rgbMap(const frame_t frame,
+                   const RgbMapFor forLayer) const;
+    RgbMap* rgbMap(const frame_t frame,
+                   const RgbMapFor forLayer,
+                   const RgbMapAlgorithm mapAlgo) const;
 
     ////////////////////////////////////////
     // Frames

From e7b955a0289f6a0fa9b65408e0e7d04f3e65071b Mon Sep 17 00:00:00 2001
From: Gaspar Capello <gaspar@igarastudio.com>
Date: Tue, 28 Apr 2020 08:48:30 -0300
Subject: [PATCH 9/9] Fix octree convolution matrix wrong results

Before this fix, convolution matrix results in mask color pixels.
The function OctreeMap::mapColor was returning mask color of all colors with alpha = 0
---
 src/doc/octree_map.cpp | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/src/doc/octree_map.cpp b/src/doc/octree_map.cpp
index 4105e8f9b..1bf03a1bd 100644
--- a/src/doc/octree_map.cpp
+++ b/src/doc/octree_map.cpp
@@ -260,14 +260,12 @@ void OctreeMap::feedWithImage(const Image* image,
 
 int OctreeMap::mapColor(color_t rgba) const
 {
-  if (rgba_geta(rgba) == 0 && m_maskColor >= 0)
-    return m_maskColor;
-  else if (m_root.children())
+  if (m_root.children())
     return m_root.mapColor(rgba_getr(rgba),
                            rgba_getg(rgba),
                            rgba_getb(rgba), 0);
   else
-    return 0;
+    return -1;
 }
 
 void OctreeMap::regenerateMap(const Palette* palette, const int maskIndex)
@@ -284,17 +282,30 @@ void OctreeMap::regenerateMap(const Palette* palette, const int maskIndex)
 
   m_root = OctreeNode();
   m_leavesVector.clear();
-  for (int i=0; i<palette->size(); i++)
+  m_maskIndex = maskIndex;
+  int maskColorBestFitIndex;
+  if (maskIndex < 0) {
+    m_maskColor = 0x00ffffff;
+    maskColorBestFitIndex = -1;
+  }
+  else {
+    m_maskColor = palette->getEntry(maskIndex);
+    maskColorBestFitIndex = palette->findBestfit(rgba_getr(m_maskColor),
+                                                 rgba_getg(m_maskColor),
+                                                 rgba_getb(m_maskColor), 255, maskIndex);
+  }
+
+  for (int i=0; i<palette->size(); i++) {
+    if (i == maskIndex) {
+      m_root.addColor(palette->entry(i), 0, &m_root, maskColorBestFitIndex, 8);
+      continue;
+    }
     m_root.addColor(palette->entry(i), 0, &m_root, i, 8);
+  }
   m_root.fillOrphansNodes(palette, 0, 0);
 
   m_palette = palette;
   m_modifications = palette->getModifications();
-  m_maskIndex = maskIndex;
-  if (maskIndex < 0)
-    m_maskColor = 0x00ffffff;
-  else
-    m_maskColor = palette->getEntry(maskIndex);
 }
 
 } // namespace doc