Added DXT1 encoding

radarhere · radarhere · commit 363fab4f9ba1 · 2021-11-08T21:53:17.000+11:00
diff --git a/Tests/test_file_dds.py b/Tests/test_file_dds.py
@@ -5,7 +5,7 @@
 
 from PIL import DdsImagePlugin, Image
 
-from .helper import assert_image_equal, assert_image_equal_tofile, hopper
+from .helper import assert_image_equal, assert_image_similar, assert_image_equal_tofile, hopper
 
 TEST_FILE_DXT1 = "Tests/images/dxt1-rgb-4bbp-noalpha_MipMaps-1.dds"
 TEST_FILE_DXT3 = "Tests/images/dxt3-argb-8bbp-explicitalpha_MipMaps-1.dds"
@@ -266,3 +266,11 @@ def test_save(mode, test_file, tmp_path):
 
         with Image.open(out) as reloaded:
             assert_image_equal(im, reloaded)
+
+def test_bcn(tmp_path):
+    im = Image.open("Tests/images/dxt1-rgb-4bbp-noalpha_MipMaps-1.dds")
+    out = str(tmp_path / "temp.dds")
+    im.save(out, mode="bcn")
+
+    reloaded = Image.open(out)
+    assert_image_similar(im, reloaded, 1)
diff --git a/setup.py b/setup.py
@@ -61,6 +61,7 @@ def get_version():
     "Reduce",
     "Bands",
     "BcnDecode",
+    "BcnEncode",
     "BitDecode",
     "Blend",
     "Chops",
diff --git a/src/PIL/DdsImagePlugin.py b/src/PIL/DdsImagePlugin.py
@@ -206,36 +206,59 @@ def _save(im, fp, filename):
     if im.mode not in ("RGB", "RGBA"):
         raise OSError(f"cannot write mode {im.mode} as DDS")
 
+    raw = im.encoderinfo.get("mode") != "bcn"
+    flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
+    if raw:
+        flags |= DDSD_PITCH
+        pitchorlinearsize = (im.width * (32 if im.mode == "RGBA" else 24) + 7) // 8
+        mipmaps = 0
+        pfflags = DDS_RGBA if im.mode == "RGBA" else DDPF_RGB
+        fourcc = o32(0)
+        rbitmask = 0xFF0000
+        gbitmask = 0xFF00
+        bbitmask = 0xFF
+        abitmask = 0xFF000000 if im.mode == "RGBA" else 0
+    else:
+        flags |= DDSD_MIPMAPCOUNT | DDSD_LINEARSIZE
+        pitchorlinearsize = (im.width + 3) * 4
+        mipmaps = 1
+        pfflags = DDPF_FOURCC
+        fourcc = b"DXT1"
+        rbitmask = 0
+        gbitmask = 0
+        bbitmask = 0
+        abitmask = 0
     fp.write(
         o32(DDS_MAGIC)
         + o32(124)  # header size
-        + o32(
-            DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT
-        )  # flags
+        + o32(flags)
         + o32(im.height)
         + o32(im.width)
-        + o32((im.width * (32 if im.mode == "RGBA" else 24) + 7) // 8)  # pitch
+        + o32(pitchorlinearsize)
         + o32(0)  # depth
-        + o32(0)  # mipmaps
+        + o32(mipmaps)
         + o32(0) * 11  # reserved
         + o32(32)  # pfsize
-        + o32(DDS_RGBA if im.mode == "RGBA" else DDPF_RGB)  # pfflags
-        + o32(0)  # fourcc
+        + o32(pfflags)  # pfflags
+        + fourcc
         + o32(32 if im.mode == "RGBA" else 24)  # bitcount
-        + o32(0xFF0000)  # rbitmask
-        + o32(0xFF00)  # gbitmask
-        + o32(0xFF)  # bbitmask
-        + o32(0xFF000000 if im.mode == "RGBA" else 0)  # abitmask
+        + o32(rbitmask)
+        + o32(gbitmask)
+        + o32(bbitmask)
+        + o32(abitmask)
         + o32(DDSCAPS_TEXTURE)  # dwCaps
         + o32(0)  # dwCaps2
         + o32(0)  # dwCaps3
         + o32(0)  # dwCaps4
         + o32(0)  # dwReserved2
     )
-    if im.mode == "RGBA":
-        r, g, b, a = im.split()
-        im = Image.merge("RGBA", (a, r, g, b))
-    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (im.mode[::-1], 0, 1))])
+    if raw:
+        if im.mode == "RGBA":
+            r, g, b, a = im.split()
+            im = Image.merge("RGBA", (a, r, g, b))
+        ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (im.mode[::-1], 0, 1))])
+    else:
+        ImageFile._save(im, fp, [("bcn", (0, 0) + im.size, 0, None)])
 
 
 def _accept(prefix):
diff --git a/src/_imaging.c b/src/_imaging.c
@@ -3940,6 +3940,8 @@ PyImaging_ZipDecoderNew(PyObject *self, PyObject *args);
 
 /* Encoders (in encode.c) */
 extern PyObject *
+PyImaging_BcnEncoderNew(PyObject *self, PyObject *args);
+extern PyObject *
 PyImaging_EpsEncoderNew(PyObject *self, PyObject *args);
 extern PyObject *
 PyImaging_GifEncoderNew(PyObject *self, PyObject *args);
@@ -4009,6 +4011,7 @@ static PyMethodDef functions[] = {
 
     /* Codecs */
     {"bcn_decoder", (PyCFunction)PyImaging_BcnDecoderNew, METH_VARARGS},
+    {"bcn_encoder", (PyCFunction)PyImaging_BcnEncoderNew, METH_VARARGS},
     {"bit_decoder", (PyCFunction)PyImaging_BitDecoderNew, METH_VARARGS},
     {"eps_encoder", (PyCFunction)PyImaging_EpsEncoderNew, METH_VARARGS},
     {"fli_decoder", (PyCFunction)PyImaging_FliDecoderNew, METH_VARARGS},
diff --git a/src/encode.c b/src/encode.c
@@ -375,6 +375,24 @@ get_packer(ImagingEncoderObject *encoder, const char *mode, const char *rawmode)
     return 0;
 }
 
+/* -------------------------------------------------------------------- */
+/* BCN                                                                  */
+/* -------------------------------------------------------------------- */
+
+PyObject *
+PyImaging_BcnEncoderNew(PyObject *self, PyObject *args) {
+    ImagingEncoderObject *encoder;
+
+    encoder = PyImaging_EncoderNew(0);
+    if (encoder == NULL) {
+        return NULL;
+    }
+
+    encoder->encode = ImagingBcnEncode;
+
+    return (PyObject *)encoder;
+}
+
 /* -------------------------------------------------------------------- */
 /* EPS                                                                  */
 /* -------------------------------------------------------------------- */
diff --git a/src/libImaging/Bcn.h b/src/libImaging/Bcn.h
@@ -1,3 +1,7 @@
 typedef struct {
     char *pixel_format;
 } BCNSTATE;
+
+typedef struct {
+    UINT8 r, g, b, a;
+} rgba;
diff --git a/src/libImaging/BcnDecode.c b/src/libImaging/BcnDecode.c
@@ -15,10 +15,6 @@
 
 #include "Bcn.h"
 
-typedef struct {
-    UINT8 r, g, b, a;
-} rgba;
-
 typedef struct {
     UINT8 l;
 } lum;
@@ -87,7 +83,6 @@ decode_bc1_color(rgba *dst, const UINT8 *src, int separate_alpha) {
     g1 = p[1].g;
     b1 = p[1].b;
 
-
     /* NOTE: BC2 and BC3 reuse BC1 color blocks but always act like c0 > c1 */
     if (col.c0 > col.c1 || separate_alpha) {
         p[2].r = (2 * r0 + 1 * r1) / 3;
diff --git a/src/libImaging/BcnEncode.c b/src/libImaging/BcnEncode.c
@@ -0,0 +1,226 @@
+/*
+ * The Python Imaging Library
+ *
+ * encoder for DXT1-compressed data
+ *
+ * Format documentation:
+ *   https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
+ *
+ */
+
+#include "Imaging.h"
+
+#include "Bcn.h"
+
+static rgba
+decode_565(UINT16 x) {
+    rgba c;
+    int r, g, b;
+    r = (x & 0xf800) >> 8;
+    r |= r >> 5;
+    c.r = r;
+    g = (x & 0x7e0) >> 3;
+    g |= g >> 6;
+    c.g = g;
+    b = (x & 0x1f) << 3;
+    b |= b >> 5;
+    c.b = b;
+    c.a = 0xff;
+    return c;
+}
+
+typedef struct {
+    UINT8 color[3];
+} rgb;
+
+static UINT16
+encode_565(rgb item) {
+    UINT8 r, g, b;
+    r = item.color[0] >> (8 - 5);
+    g = item.color[1] >> (8 - 6);
+    b = item.color[2] >> (8 - 5);
+    return (r << (5 + 6)) | (g << 5) | b;
+}
+
+int
+ImagingBcnEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
+    UINT8 *dst = buf;
+
+    for (;;) {
+        int i, j, k, three_color_block = 0;
+        UINT16 cmin, cmax;
+        rgb block[16], cmin_rgb, cmax_rgb, *current_rgb;
+
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < 4; j++) {
+                UINT16 c;
+                int x = state->x + i * im->pixelsize;
+                int y = state->y + j;
+                if (x >= state->xsize * im->pixelsize || y >= state->ysize) {
+                    continue;
+                }
+
+                current_rgb = &block[i + j * 4];
+                for (k = 0; k < 3; k++) {
+                  current_rgb->color[k] = (UINT8)im->image[y][x+k];
+                }
+
+                c = encode_565(*current_rgb);
+                if ((i == 0 && j == 0) || c < cmin) {
+                  cmin = c;
+                }
+                if ((i == 0 && j == 0) || c > cmax) {
+                  cmax = c;
+                }
+            }
+        }
+        rgba back = decode_565(cmin);
+        cmin_rgb.color[0] = back.r;
+        cmin_rgb.color[1] = back.g;
+        cmin_rgb.color[2] = back.b;
+        back = decode_565(cmax);
+        cmax_rgb.color[0] = back.r;
+        cmax_rgb.color[1] = back.g;
+        cmax_rgb.color[2] = back.b;
+        if (cmin == cmax) {
+          UINT8 r = cmax_rgb.color[0];
+          UINT8 g = cmax_rgb.color[1];
+          UINT8 b = cmax_rgb.color[2];
+          int halves = 0;
+          int thirds = 0;
+          int posr = 0;
+          int negr = 0;
+          int posg = 0;
+          int negg = 0;
+          int posb = 0;
+          int negb = 0;
+          for (i = 0; i < 16; i++) {
+              for (j = 0; j < 3; j++) {
+                  int diff = block[i].color[j] - cmin_rgb.color[j];
+                  if (diff == (j == 1 ? 2 : 4)) {
+                      halves += 1;
+                  } else if (diff == (j == 1 ? 1 : 3) || diff == (j == 1 ? 3 : 5)) {
+                      thirds += 1;
+                  }
+                  if (j == 0) {
+                    if (diff > 0) {
+                      posr += 1;
+                    } else if (diff < 0) {
+                      negr += 1;
+                    }
+                  } else if (j == 1) {
+                    if (diff > 0) {
+                      posg += 1;
+                    } else if (diff < 0) {
+                      negg += 1;
+                    }
+                  } else {
+                    if (diff > 0) {
+                      posb += 1;
+                    } else if (diff < 0) {
+                      negb += 1;
+                    }
+                  }
+              }
+          }
+          three_color_block = halves > thirds ? 1 : 0;
+          if (posr > negr) {
+              cmax_rgb.color[0] += 8;
+          } else if (posr < negr) {
+              cmin_rgb.color[0] -= 8;
+          }
+          if (posg > negg) {
+              cmax_rgb.color[1] += 4;
+          } else if (posg < negg) {
+              cmin_rgb.color[1] -= 4;
+          }
+          if (posb > negb) {
+              cmax_rgb.color[2] += 8;
+          } else if (posb < negb) {
+              cmin_rgb.color[2] -= 8;
+          }
+          cmin = encode_565(cmin_rgb);
+          cmax = encode_565(cmax_rgb);
+        }
+        if (three_color_block == 1) {
+          *dst++ = cmin;
+          *dst++ = cmin >> 8;
+          *dst++ = cmax;
+          *dst++ = cmax >> 8;
+          for (i = 0; i < 4; i++) {
+            UINT8 m = 0;
+            for (j = 3; j > -1; j--) {
+              current_rgb = &block[i * 4 + j];
+
+              float distance = 0;
+              int total = 0;
+              for (k = 0; k < 3; k++) {
+                float denom = (float)abs(cmax_rgb.color[k] - cmin_rgb.color[k]);
+                if (denom != 0) {
+                  distance += abs(current_rgb->color[k] - cmin_rgb.color[k]) / denom;
+                  total += 1;
+                }
+              }
+              if (total != 0) {
+                distance *= (6 / total);
+              }
+              if (distance < 1.5) {
+                m |= 1 << (j * 2); // 01 cmin
+              } else if (distance < 4.5) {
+                m |= 2 << (j * 2); // 10 2 cmax 1 cmin
+              } else {
+                // 00 cmax
+              }
+            }
+            *dst++ = m;
+          }
+        } else {
+          *dst++ = cmax;
+          *dst++ = cmax >> 8;
+          *dst++ = cmin;
+          *dst++ = cmin >> 8;
+          for (i = 0; i < 4; i++) {
+            UINT8 m = 0;
+            for (j = 3; j > -1; j--) {
+              current_rgb = &block[i * 4 + j];
+
+              float distance = 0;
+              int total = 0;
+              for (k = 0; k < 3; k++) {
+                float denom = (float)abs(cmax_rgb.color[k] - cmin_rgb.color[k]);
+                if (denom != 0) {
+                  distance += abs(current_rgb->color[k] - cmin_rgb.color[k]) / denom;
+                  total += 1;
+                }
+              }
+              if (total != 0) {
+                distance *= (6 / total);
+              }
+              if (distance < 1) {
+                m |= 1 << (j * 2); // 01 cmin
+              } else if (distance < 3) {
+                m |= 3 << (j * 2); // 11 1 cmax 2 cmin
+              } else if (distance < 5) {
+                m |= 2 << (j * 2); // 10 2 cmax 1 cmin
+              } else {
+                // 00 cmax
+              }
+            }
+            *dst++ = m;
+          }
+        }
+
+        state->x += im->pixelsize * 4;
+
+        if (state->x >= state->xsize * im->pixelsize) {
+            state->x = 0;
+            state->y += 4;
+            if (state->y >= state->ysize) {
+                state->errcode = IMAGING_CODEC_END;
+                break;
+            }
+        }
+    }
+
+    return dst - buf;
+}
diff --git a/src/libImaging/Imaging.h b/src/libImaging/Imaging.h
