Added DXT1 encoding

Author: radarhere

Tests/test_file_dds.py

@@ -9,7 +9,12 @@
 
 from PIL import DdsImagePlugin, Image
 
-from .helper import assert_image_equal, assert_image_equal_tofile, hopper
+from .helper import (
+    assert_image_equal,
+    assert_image_equal_tofile,
+    assert_image_similar,
+    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"
@@ -391,3 +396,12 @@ def test_save(mode: str, test_file: str, tmp_path: Path) -> None:
 
         with Image.open(out) as reloaded:
             assert_image_equal(im, reloaded)
+
+
+def test_bcn(tmp_path: Path) -> None:
+    out = str(tmp_path / "temp.dds")
+    with Image.open("Tests/images/dxt1-rgb-4bbp-noalpha_MipMaps-1.dds") as im:
+        im.save(out, mode="bcn")
+
+    with Image.open(out) as reloaded:
+        assert_image_similar(im, reloaded, 1.84)

setup.py

@@ -68,6 +68,7 @@ def get_version() -> str:
     "Reduce",
     "Bands",
     "BcnDecode",
+    "BcnEncode",
     "BitDecode",
     "Blend",
     "Chops",

src/PIL/DdsImagePlugin.py

@@ -518,30 +518,45 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
         msg = f"cannot write mode {im.mode} as DDS"
         raise OSError(msg)
 
-    alpha = im.mode[-1] == "A"
-    if im.mode[0] == "L":
-        pixel_flags = DDPF.LUMINANCE
-        rawmode = im.mode
-        if alpha:
-            rgba_mask = [0x000000FF, 0x000000FF, 0x000000FF]
+    flags = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PIXELFORMAT
+    bitcount = len(im.getbands()) * 8
+    raw = im.encoderinfo.get("mode") != "bcn"
+    if raw:
+        codec_name = "raw"
+        flags |= DDSD.PITCH
+        pitch = (im.width * bitcount + 7) // 8
+        mipmaps = 0
+
+        alpha = im.mode[-1] == "A"
+        if im.mode[0] == "L":
+            pixel_flags = DDPF.LUMINANCE
+            rawmode = im.mode
+            if alpha:
+                rgba_mask = [0x000000FF, 0x000000FF, 0x000000FF]
+            else:
+                rgba_mask = [0xFF000000, 0xFF000000, 0xFF000000]
         else:
-            rgba_mask = [0xFF000000, 0xFF000000, 0xFF000000]
-    else:
-        pixel_flags = DDPF.RGB
-        rawmode = im.mode[::-1]
-        rgba_mask = [0x00FF0000, 0x0000FF00, 0x000000FF]
+            pixel_flags = DDPF.RGB
+            rawmode = im.mode[::-1]
+            rgba_mask = [0x00FF0000, 0x0000FF00, 0x000000FF]
 
+            if alpha:
+                r, g, b, a = im.split()
+                im = Image.merge("RGBA", (a, r, g, b))
         if alpha:
-            r, g, b, a = im.split()
-            im = Image.merge("RGBA", (a, r, g, b))
-    if alpha:
-        pixel_flags |= DDPF.ALPHAPIXELS
-    rgba_mask.append(0xFF000000 if alpha else 0)
-
-    flags = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PITCH | DDSD.PIXELFORMAT
-    bitcount = len(im.getbands()) * 8
-    pitch = (im.width * bitcount + 7) // 8
+            pixel_flags |= DDPF.ALPHAPIXELS
+        rgba_mask.append(0xFF000000 if alpha else 0)
 
+        fourcc = 0
+    else:
+        codec_name = "bcn"
+        flags |= DDSD.MIPMAPCOUNT | DDSD.LINEARSIZE
+        pitch = (im.width + 3) * 4
+        mipmaps = 1
+        rawmode = None
+        rgba_mask = [0, 0, 0, 0]
+        pixel_flags = DDPF.FOURCC
+        fourcc = D3DFMT.DXT1
     fp.write(
         o32(DDS_MAGIC)
         + struct.pack(
@@ -552,15 +567,15 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
             im.width,
             pitch,
             0,  # depth
-            0,  # mipmaps
+            mipmaps,  # mipmaps
         )
         + struct.pack("11I", *((0,) * 11))  # reserved
         # pfsize, pfflags, fourcc, bitcount
-        + struct.pack("<4I", 32, pixel_flags, 0, bitcount)
+        + struct.pack("<4I", 32, pixel_flags, fourcc, bitcount)
         + struct.pack("<4I", *rgba_mask)  # dwRGBABitMask
         + struct.pack("<5I", DDSCAPS.TEXTURE, 0, 0, 0, 0)
     )
-    ImageFile._save(im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, rawmode)])
+    ImageFile._save(im, fp, [ImageFile._Tile(codec_name, (0, 0) + im.size, 0, rawmode)])
 
 
 def _accept(prefix: bytes) -> bool:

src/_imaging.c

@@ -4041,6 +4041,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);
@@ -4109,6 +4111,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},

src/encode.c

@@ -350,6 +350,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                                                                  */
 /* -------------------------------------------------------------------- */

src/libImaging/BcnEncode.c

@@ -0,0 +1,131 @@
+/*
+ * 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"
+
+typedef struct {
+    UINT8 color[3];
+} rgb;
+
+static rgb
+decode_565(UINT16 x) {
+    rgb item;
+    int r, g, b;
+    r = (x & 0xf800) >> 8;
+    r |= r >> 5;
+    item.color[0] = r;
+    g = (x & 0x7e0) >> 3;
+    g |= g >> 6;
+    item.color[1] = g;
+    b = (x & 0x1f) << 3;
+    b |= b >> 5;
+    item.color[2] = b;
+    return item;
+}
+
+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;
+        UINT16 color_min, color_max;
+        rgb block[16], color_min_rgb, color_max_rgb, *current_rgb;
+
+        // Determine the min and max colors in this 4x4 block
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < 4; j++) {
+                int x = state->x + i * im->pixelsize;
+                int y = state->y + j;
+                if (x >= state->xsize * im->pixelsize || y >= state->ysize) {
+                    // The 4x4 block extends past the edge of the image
+                    continue;
+                }
+
+                current_rgb = &block[i + j * 4];
+                for (k = 0; k < 3; k++) {
+                    current_rgb->color[k] = (UINT8)im->image[y][x + k];
+                }
+
+                UINT16 color = encode_565(*current_rgb);
+                if ((i == 0 && j == 0) || color < color_min) {
+                    color_min = color;
+                }
+                if ((i == 0 && j == 0) || color > color_max) {
+                    color_max = color;
+                }
+            }
+        }
+
+        *dst++ = color_max;
+        *dst++ = color_max >> 8;
+        *dst++ = color_min;
+        *dst++ = color_min >> 8;
+
+        color_min_rgb = decode_565(color_min);
+        color_max_rgb = decode_565(color_max);
+        for (i = 0; i < 4; i++) {
+            UINT8 l = 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(color_max_rgb.color[k] - color_min_rgb.color[k]);
+                    if (denom != 0) {
+                        distance +=
+                            abs(current_rgb->color[k] - color_min_rgb.color[k]) / denom;
+                        total += 1;
+                    }
+                }
+                if (total == 0) {
+                    continue;
+                }
+                distance *= 6 / total;
+                if (distance < 1) {
+                    l |= 1 << (j * 2);  // color_min
+                } else if (distance < 3) {
+                    l |= 3 << (j * 2);  // 1/3 * color_min + 2/3 * color_max
+                } else if (distance < 5) {
+                    l |= 2 << (j * 2);  // 2/3 * color_min + 1/3 * color_max
+                } else {
+                    // color_max
+                }
+            }
+            *dst++ = l;
+        }
+
+        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;
+}

src/libImaging/Imaging.h

@@ -567,6 +567,8 @@ typedef int (*ImagingCodec)(
 extern int
 ImagingBcnDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
 extern int
+ImagingBcnEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
+extern int
 ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
 extern int
 ImagingEpsEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);