Merge branch 'master' into winbuild-rewrite

.github/workflows/test-docker.yml

@@ -14,6 +14,7 @@ jobs:
           arch,
           ubuntu-16.04-xenial-amd64,
           ubuntu-18.04-bionic-amd64,
+          ubuntu-20.04-focal-amd64,
           debian-9-stretch-x86,
           debian-10-buster-x86,
           centos-6-amd64,
@@ -21,8 +22,8 @@ jobs:
           centos-8-amd64,
           amazon-1-amd64,
           amazon-2-amd64,
-          fedora-30-amd64,
           fedora-31-amd64,
+          fedora-32-amd64,
         ]
         dockerTag: [master]
 

.travis.yml

@@ -28,6 +28,9 @@ matrix:
 
     - python: "pypy3"
       name: "PyPy3 Xenial"
+    - python: "3.9-dev"
+      name: "3.9-dev Xenial"
+      services: xvfb
     - python: "3.8"
       name: "3.8 Xenial"
       services: xvfb

CHANGES.rst

@@ -2,6 +2,21 @@
 Changelog (Pillow)
 ==================
 
+7.2.0 (unreleased)
+------------------
+
+- Fixed bug when unpickling TIFF images #4565
+  [radarhere]
+
+- Fix pickling WebP #4561
+  [hugovk, radarhere]
+
+7.1.2 (2020-04-25)
+------------------
+
+- Raise an EOFError when seeking too far in PNG #4528
+  [radarhere]
+
 7.1.1 (2020-04-02)
 ------------------
 

MANIFEST.in

@@ -21,10 +21,8 @@ exclude .appveyor.yml
 exclude .coveragerc
 exclude .editorconfig
 exclude .readthedocs.yml
-exclude azure-pipelines.yml
 exclude codecov.yml
 global-exclude .git*
 global-exclude *.pyc
 global-exclude *.so
-prune .azure-pipelines
 prune .ci

Tests/helper.py

@@ -272,12 +272,8 @@ def on_github_actions():
 
 
 def on_ci():
-    # Travis and AppVeyor have "CI"
+    # GitHub Actions, Travis and AppVeyor have "CI"
-    # Azure Pipelines has "TF_BUILD"
+    return "CI" in os.environ
-    # GitHub Actions has "GITHUB_ACTIONS"
-    return (
-        "CI" in os.environ or "TF_BUILD" in os.environ or "GITHUB_ACTIONS" in os.environ
-    )
 
 
 def is_big_endian():

Tests/test_file_wmf.py

@@ -66,7 +66,7 @@ def test_load_set_dpi():
             assert im.size == (164, 164)
 
             with Image.open("Tests/images/drawing_wmf_ref_144.png") as expected:
-                assert_image_similar(im, expected, 2.0)
+                assert_image_similar(im, expected, 2.1)
 
 
 def test_save(tmp_path):

Tests/test_imagefile.py

@@ -95,8 +95,9 @@ class TestImageFile:
 
     def test_raise_ioerror(self):
         with pytest.raises(IOError):
-            with pytest.raises(DeprecationWarning):
+            with pytest.warns(DeprecationWarning) as record:
                 ImageFile.raise_ioerror(1)
+        assert len(record) == 1
 
     def test_raise_oserror(self):
         with pytest.raises(OSError):

Tests/test_pickle.py

@@ -1,11 +1,14 @@
 import pickle
 
+import pytest
 from PIL import Image
 
+from .helper import skip_unless_feature
 
-def helper_pickle_file(tmp_path, pickle, protocol=0, mode=None):
+
+def helper_pickle_file(tmp_path, pickle, protocol, test_file, mode):
     # Arrange
-    with Image.open("Tests/images/hopper.jpg") as im:
+    with Image.open(test_file) as im:
         filename = str(tmp_path / "temp.pkl")
         if mode:
             im = im.convert(mode)
@@ -20,9 +23,7 @@ def helper_pickle_file(tmp_path, pickle, protocol=0, mode=None):
         assert im == loaded_im
 
 
-def helper_pickle_string(
+def helper_pickle_string(pickle, protocol, test_file, mode):
-    pickle, protocol=0, test_file="Tests/images/hopper.jpg", mode=None
-):
     with Image.open(test_file) as im:
         if mode:
             im = im.convert(mode)
@@ -35,41 +36,31 @@ def helper_pickle_string(
         assert im == loaded_im
 
 
-def test_pickle_image(tmp_path):
+@pytest.mark.parametrize(
+    ("test_file", "test_mode"),
+    [
+        ("Tests/images/hopper.jpg", None),
+        ("Tests/images/hopper.jpg", "L"),
+        ("Tests/images/hopper.jpg", "PA"),
+        pytest.param(
+            "Tests/images/hopper.webp", None, marks=skip_unless_feature("webp")
+        ),
+        ("Tests/images/hopper.tif", None),
+        ("Tests/images/test-card.png", None),
+        ("Tests/images/zero_bb.png", None),
+        ("Tests/images/zero_bb_scale2.png", None),
+        ("Tests/images/non_zero_bb.png", None),
+        ("Tests/images/non_zero_bb_scale2.png", None),
+        ("Tests/images/p_trns_single.png", None),
+        ("Tests/images/pil123p.png", None),
+        ("Tests/images/itxt_chunks.png", None),
+    ],
+)
+def test_pickle_image(tmp_path, test_file, test_mode):
     # Act / Assert
     for protocol in range(0, pickle.HIGHEST_PROTOCOL + 1):
-        helper_pickle_string(pickle, protocol)
+        helper_pickle_string(pickle, protocol, test_file, test_mode)
-        helper_pickle_file(tmp_path, pickle, protocol)
+        helper_pickle_file(tmp_path, pickle, protocol, test_file, test_mode)
-
-
-def test_pickle_p_mode():
-    # Act / Assert
-    for test_file in [
-        "Tests/images/test-card.png",
-        "Tests/images/zero_bb.png",
-        "Tests/images/zero_bb_scale2.png",
-        "Tests/images/non_zero_bb.png",
-        "Tests/images/non_zero_bb_scale2.png",
-        "Tests/images/p_trns_single.png",
-        "Tests/images/pil123p.png",
-        "Tests/images/itxt_chunks.png",
-    ]:
-        for protocol in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            helper_pickle_string(pickle, protocol=protocol, test_file=test_file)
-
-
-def test_pickle_pa_mode(tmp_path):
-    # Act / Assert
-    for protocol in range(0, pickle.HIGHEST_PROTOCOL + 1):
-        helper_pickle_string(pickle, protocol, mode="PA")
-        helper_pickle_file(tmp_path, pickle, protocol, mode="PA")
-
-
-def test_pickle_l_mode(tmp_path):
-    # Act / Assert
-    for protocol in range(0, pickle.HIGHEST_PROTOCOL + 1):
-        helper_pickle_string(pickle, protocol, mode="L")
-        helper_pickle_file(tmp_path, pickle, protocol, mode="L")
 
 
 def test_pickle_la_mode_with_palette(tmp_path):
@@ -88,3 +79,15 @@ def test_pickle_la_mode_with_palette(tmp_path):
 
         im.mode = "PA"
         assert im == loaded_im
+
+
+@skip_unless_feature("webp")
+def test_pickle_tell():
+    # Arrange
+    image = Image.open("Tests/images/hopper.webp")
+
+    # Act: roundtrip
+    unpickled_image = pickle.loads(pickle.dumps(image))
+
+    # Assert
+    assert unpickled_image.tell() == 0

docs/installation.rst

@@ -394,14 +394,18 @@ These platforms are built and tested for every change.
 +----------------------------------+--------------------------+-----------------------+
 | Debian 10 Buster                 | 3.7                      |x86                    |
 +----------------------------------+--------------------------+-----------------------+
-| Fedora 30                        | 3.7                      |x86-64                 |
-+----------------------------------+--------------------------+-----------------------+
 | Fedora 31                        | 3.7                      |x86-64                 |
 +----------------------------------+--------------------------+-----------------------+
+| Fedora 32                        | 3.8                      |x86-64                 |
++----------------------------------+--------------------------+-----------------------+
 | macOS 10.15 Catalina             | 3.5, 3.6, 3.7, 3.8, PyPy3|x86-64                 |
 +----------------------------------+--------------------------+-----------------------+
 | Ubuntu Linux 16.04 LTS           | 3.5, 3.6, 3.7, 3.8, PyPy3|x86-64                 |
 +----------------------------------+--------------------------+-----------------------+
+| Ubuntu Linux 18.04 LTS           | 3.6                      |x86-64                 |
++----------------------------------+--------------------------+-----------------------+
+| Ubuntu Linux 20.04 LTS           | 3.8                      |x86-64                 |
++----------------------------------+--------------------------+-----------------------+
 | Windows Server 2016              | 3.8                      |x86                    |
 |                                  +--------------------------+-----------------------+
 |                                  | 3.5                      |x86-64                 |

docs/reference/ImageDraw.rst

@@ -100,6 +100,25 @@ Example: Draw Partial Opacity Text
 
     out.show()
 
+Example: Draw Multiline Text
+----------------------------
+
+.. code-block:: python
+
+    from PIL import Image, ImageDraw, ImageFont
+
+    # create an image
+    out = Image.new("RGB", (150, 100), (255, 255, 255))
+
+    # get a font
+    fnt = ImageFont.truetype("Pillow/Tests/fonts/FreeMono.ttf", 40)
+    # get a drawing context
+    d = ImageDraw.Draw(out)
+
+    # draw multiline text
+    d.multiline_text((10,10), "Hello\nWorld", font=fnt, fill=(0, 0, 0))
+
+    out.show()
 
 
 Functions

docs/releasenotes/7.1.2.rst

@@ -0,0 +1,16 @@
+7.1.2
+-----
+
+Fix another regression seeking PNG files
+========================================
+
+This fixes a regression introduced in 7.1.0 when adding support for APNG files.
+
+When calling ``seek(n)`` on a regular PNG where ``n > 0``, it failed to raise an
+``EOFError`` as it should have done, resulting in:
+
+.. code-block:: python
+
+    AttributeError: 'NoneType' object has no attribute 'read'
+
+Pillow 7.1.2 now raises the correct exception.

docs/releasenotes/index.rst

@@ -6,6 +6,7 @@ Release Notes
 .. toctree::
   :maxdepth: 2
 
+  7.1.2
   7.1.1
   7.1.0
   7.0.0

src/PIL/DcxImagePlugin.py

@@ -59,16 +59,10 @@ class DcxImageFile(PcxImageFile):
 
         self.__fp = self.fp
         self.frame = None
+        self.n_frames = len(self._offset)
+        self.is_animated = self.n_frames > 1
         self.seek(0)
 
-    @property
-    def n_frames(self):
-        return len(self._offset)
-
-    @property
-    def is_animated(self):
-        return len(self._offset) > 1
-
     def seek(self, frame):
         if not self._seek_check(frame):
             return

src/PIL/FliImagePlugin.py

@@ -51,7 +51,8 @@ class FliImageFile(ImageFile.ImageFile):
             raise SyntaxError("not an FLI/FLC file")
 
         # frames
-        self.__framecount = i16(s[6:8])
+        self.n_frames = i16(s[6:8])
+        self.is_animated = self.n_frames > 1
 
         # image characteristics
         self.mode = "P"
@@ -110,14 +111,6 @@ class FliImageFile(ImageFile.ImageFile):
                 palette[i] = (r, g, b)
                 i += 1
 
-    @property
-    def n_frames(self):
-        return self.__framecount
-
-    @property
-    def is_animated(self):
-        return self.__framecount > 1
-
     def seek(self, frame):
         if not self._seek_check(frame):
             return

src/PIL/Image.py

@@ -2247,6 +2247,7 @@ class Image:
            :py:attr:`PIL.Image.BICUBIC`, or :py:attr:`PIL.Image.LANCZOS`.
            If omitted, it defaults to :py:attr:`PIL.Image.BICUBIC`.
            (was :py:attr:`PIL.Image.NEAREST` prior to version 2.5.0).
+           See: :ref:`concept-filters`.
         :param reducing_gap: Apply optimization by resizing the image
            in two steps. First, reducing the image by integer times
            using :py:meth:`~PIL.Image.Image.reduce` or
@@ -2324,7 +2325,7 @@ class Image:
           It may also be an object with a :py:meth:`~method.getdata` method
           that returns a tuple supplying new **method** and **data** values::
 
-            class Example(object):
+            class Example:
                 def getdata(self):
                     method = Image.EXTENT
                     data = (0, 0, 100, 100)
@@ -2336,6 +2337,7 @@ class Image:
            environment), or :py:attr:`PIL.Image.BICUBIC` (cubic spline
            interpolation in a 4x4 environment). If omitted, or if the image
            has mode "1" or "P", it is set to :py:attr:`PIL.Image.NEAREST`.
+           See: :ref:`concept-filters`.
         :param fill: If **method** is an
           :py:class:`~PIL.Image.ImageTransformHandler` object, this is one of
           the arguments passed to it. Otherwise, it is unused.

src/PIL/ImageFile.py

@@ -150,10 +150,10 @@ class ImageFile(Image.Image):
     def load(self):
         """Load image data based on tile list"""
 
-        pixel = Image.Image.load(self)
-
         if self.tile is None:
             raise OSError("cannot load this image")
+
+        pixel = Image.Image.load(self)
         if not self.tile:
             return pixel
 

src/PIL/MicImagePlugin.py

@@ -64,20 +64,14 @@ class MicImageFile(TiffImagePlugin.TiffImageFile):
 
         self.__fp = self.fp
         self.frame = None
+        self._n_frames = len(self.images)
+        self.is_animated = self._n_frames > 1
 
         if len(self.images) > 1:
             self.category = Image.CONTAINER
 
         self.seek(0)
 
-    @property
-    def n_frames(self):
-        return len(self.images)
-
-    @property
-    def is_animated(self):
-        return len(self.images) > 1
-
     def seek(self, frame):
         if not self._seek_check(frame):
             return

src/PIL/MpoImagePlugin.py

@@ -48,15 +48,16 @@ class MpoImageFile(JpegImagePlugin.JpegImageFile):
 
     def _after_jpeg_open(self, mpheader=None):
         self.mpinfo = mpheader if mpheader is not None else self._getmp()
-        self.__framecount = self.mpinfo[0xB001]
+        self.n_frames = self.mpinfo[0xB001]
         self.__mpoffsets = [
             mpent["DataOffset"] + self.info["mpoffset"] for mpent in self.mpinfo[0xB002]
         ]
         self.__mpoffsets[0] = 0
         # Note that the following assertion will only be invalid if something
         # gets broken within JpegImagePlugin.
-        assert self.__framecount == len(self.__mpoffsets)
+        assert self.n_frames == len(self.__mpoffsets)
         del self.info["mpoffset"]  # no longer needed
+        self.is_animated = self.n_frames > 1
         self.__fp = self.fp  # FIXME: hack
         self.__fp.seek(self.__mpoffsets[0])  # get ready to read first frame
         self.__frame = 0
@@ -67,14 +68,6 @@ class MpoImageFile(JpegImagePlugin.JpegImageFile):
     def load_seek(self, pos):
         self.__fp.seek(pos)
 
-    @property
-    def n_frames(self):
-        return self.__framecount
-
-    @property
-    def is_animated(self):
-        return self.__framecount > 1
-
     def seek(self, frame):
         if not self._seek_check(frame):
             return

src/PIL/PsdImagePlugin.py

@@ -119,6 +119,8 @@ class PsdImageFile(ImageFile.ImageFile):
             if size:
                 self.layers = _layerinfo(self.fp)
             self.fp.seek(end)
+        self.n_frames = len(self.layers)
+        self.is_animated = self.n_frames > 1
 
         #
         # image descriptor
@@ -130,14 +132,6 @@ class PsdImageFile(ImageFile.ImageFile):
         self.frame = 1
         self._min_frame = 1
 
-    @property
-    def n_frames(self):
-        return len(self.layers)
-
-    @property
-    def is_animated(self):
-        return len(self.layers) > 1
-
     def seek(self, layer):
         if not self._seek_check(layer):
             return

src/PIL/TiffImagePlugin.py

@@ -1015,10 +1015,6 @@ class TiffImageFile(ImageFile.ImageFile):
             self.seek(current)
         return self._n_frames
 
-    @property
-    def is_animated(self):
-        return self._is_animated
-
     def seek(self, frame):
         """Select a given frame as current image"""
         if not self._seek_check(frame):
@@ -1052,7 +1048,7 @@ class TiffImageFile(ImageFile.ImageFile):
             if self.__next == 0:
                 self._n_frames = frame + 1
             if len(self._frame_pos) == 1:
-                self._is_animated = self.__next != 0
+                self.is_animated = self.__next != 0
             self.__frame += 1
         self.fp.seek(self._frame_pos[frame])
         self.tag_v2.load(self.fp)
@@ -1066,7 +1062,7 @@ class TiffImageFile(ImageFile.ImageFile):
         return self.__frame
 
     def load(self):
-        if self.use_load_libtiff:
+        if self.tile and self.use_load_libtiff:
             return self._load_libtiff()
         return super().load()
 
@@ -1087,19 +1083,14 @@ class TiffImageFile(ImageFile.ImageFile):
 
         # allow closing if we're on the first frame, there's no next
         # This is the ImageFile.load path only, libtiff specific below.
-        if not self._is_animated:
+        if not self.is_animated:
             self._close_exclusive_fp_after_loading = True
 
     def _load_libtiff(self):
         """ Overload method triggered when we detect a compressed tiff
             Calls out to libtiff """
 
-        pixel = Image.Image.load(self)
+        Image.Image.load(self)
-
-        if self.tile is None:
-            raise OSError("cannot load this image")
-        if not self.tile:
-            return pixel
 
         self.load_prepare()
 
@@ -1138,7 +1129,7 @@ class TiffImageFile(ImageFile.ImageFile):
         except ValueError:
             raise OSError("Couldn't set the image")
 
-        close_self_fp = self._exclusive_fp and not self._is_animated
+        close_self_fp = self._exclusive_fp and not self.is_animated
         if hasattr(self.fp, "getvalue"):
             # We've got a stringio like thing passed in. Yay for all in memory.
             # The decoder needs the entire file in one shot, so there's not

src/PIL/WebPImagePlugin.py

@@ -38,6 +38,8 @@ class WebPImageFile(ImageFile.ImageFile):
 
     format = "WEBP"
     format_description = "WebP image"
+    __loaded = 0
+    __logical_frame = 0
 
     def _open(self):
         if not _webp.HAVE_WEBPANIM:
@@ -52,7 +54,8 @@ class WebPImageFile(ImageFile.ImageFile):
             self._size = width, height
             self.fp = BytesIO(data)
             self.tile = [("raw", (0, 0) + self.size, 0, self.mode)]
-            self._n_frames = 1
+            self.n_frames = 1
+            self.is_animated = False
             return
 
         # Use the newer AnimDecoder API to parse the (possibly) animated file,
@@ -70,7 +73,8 @@ class WebPImageFile(ImageFile.ImageFile):
             bgcolor & 0xFF,
         )
         self.info["background"] = (bg_r, bg_g, bg_b, bg_a)
-        self._n_frames = frame_count
+        self.n_frames = frame_count
+        self.is_animated = self.n_frames > 1
         self.mode = "RGB" if mode == "RGBX" else mode
         self.rawmode = mode
         self.tile = []
@@ -88,30 +92,15 @@ class WebPImageFile(ImageFile.ImageFile):
 
         # Initialize seek state
         self._reset(reset=False)
-        self.seek(0)
 
     def _getexif(self):
         if "exif" not in self.info:
             return None
         return dict(self.getexif())
 
-    @property
-    def n_frames(self):
-        return self._n_frames
-
-    @property
-    def is_animated(self):
-        return self._n_frames > 1
-
     def seek(self, frame):
-        if not _webp.HAVE_WEBPANIM:
+        if not self._seek_check(frame):
-            return super().seek(frame)
+            return
-
-        # Perform some simple checks first
-        if frame >= self._n_frames:
-            raise EOFError("attempted to seek beyond end of sequence")
-        if frame < 0:
-            raise EOFError("negative frame index is not valid")
 
         # Set logical frame to requested position
         self.__logical_frame = frame

src/_imagingtk.c

@@ -4,8 +4,8 @@
  * tkinter hooks
  *
  * history:
- * 99-07-26 fl	created
+ * 99-07-26 fl created
- * 99-08-15 fl	moved to its own support module
+ * 99-08-15 fl moved to its own support module
  *
  * Copyright (c) Secret Labs AB 1999.
  *
@@ -45,8 +45,8 @@ _tkinit(PyObject* self, PyObject* args)
         interp = (Tcl_Interp*)PyLong_AsVoidPtr(arg);
     else {
         TkappObject* app;
-	/* Do it the hard way.  This will break if the TkappObject
+        /* Do it the hard way.  This will break if the TkappObject
-	   layout changes */
+        layout changes */
         app = (TkappObject*)PyLong_AsVoidPtr(arg);
         interp = app->interp;
     }

src/_webp.c

@@ -836,7 +836,7 @@ void addAnimFlagToModule(PyObject* m) {
 
 void addTransparencyFlagToModule(PyObject* m) {
     PyModule_AddObject(m, "HAVE_TRANSPARENCY",
-		       PyBool_FromLong(!WebPDecoderBuggyAlpha()));
+               PyBool_FromLong(!WebPDecoderBuggyAlpha()));
 }
 
 static int setup_module(PyObject* m) {

src/display.c

@@ -28,7 +28,7 @@
 #include "Imaging.h"
 
 /* -------------------------------------------------------------------- */
-/* Windows DIB support	*/
+/* Windows DIB support */
 
 #ifdef _WIN32
 
@@ -57,12 +57,12 @@ _new(const char* mode, int xsize, int ysize)
 
     display = PyObject_New(ImagingDisplayObject, &ImagingDisplayType);
     if (display == NULL)
-	return NULL;
+        return NULL;
 
     display->dib = ImagingNewDIB(mode, xsize, ysize);
     if (!display->dib) {
-	Py_DECREF(display);
+        Py_DECREF(display);
-	return NULL;
+        return NULL;
     }
 
     return display;
@@ -72,7 +72,7 @@ static void
 _delete(ImagingDisplayObject* display)
 {
     if (display->dib)
-	ImagingDeleteDIB(display->dib);
+        ImagingDeleteDIB(display->dib);
     PyObject_Del(display);
 }
 
@@ -81,7 +81,7 @@ _expose(ImagingDisplayObject* display, PyObject* args)
 {
     HDC hdc;
     if (!PyArg_ParseTuple(args, F_HANDLE, &hdc))
-	return NULL;
+        return NULL;
 
     ImagingExposeDIB(display->dib, hdc);
 
@@ -98,7 +98,7 @@ _draw(ImagingDisplayObject* display, PyObject* args)
     if (!PyArg_ParseTuple(args, F_HANDLE "(iiii)(iiii)", &hdc,
                           dst+0, dst+1, dst+2, dst+3,
                           src+0, src+1, src+2, src+3))
-	return NULL;
+        return NULL;
 
     ImagingDrawDIB(display->dib, hdc, dst, src);
 
@@ -117,15 +117,15 @@ _paste(ImagingDisplayObject* display, PyObject* args)
     int xy[4];
     xy[0] = xy[1] = xy[2] = xy[3] = 0;
     if (!PyArg_ParseTuple(args, "O|(iiii)", &op, xy+0, xy+1, xy+2, xy+3))
-	return NULL;
+        return NULL;
     im = PyImaging_AsImaging(op);
     if (!im)
-	return NULL;
+        return NULL;
 
     if (xy[2] <= xy[0])
-	xy[2] = xy[0] + im->xsize;
+        xy[2] = xy[0] + im->xsize;
     if (xy[3] <= xy[1])
-	xy[3] = xy[1] + im->ysize;
+        xy[3] = xy[1] + im->ysize;
 
     ImagingPasteDIB(display->dib, im, xy);
 
@@ -140,7 +140,7 @@ _query_palette(ImagingDisplayObject* display, PyObject* args)
     int status;
 
     if (!PyArg_ParseTuple(args, F_HANDLE, &hdc))
-	return NULL;
+        return NULL;
 
     status = ImagingQueryPaletteDIB(display->dib, hdc);
 
@@ -154,7 +154,7 @@ _getdc(ImagingDisplayObject* display, PyObject* args)
     HDC dc;
 
     if (!PyArg_ParseTuple(args, F_HANDLE, &window))
-	return NULL;
+        return NULL;
 
     dc = GetDC(window);
     if (!dc) {
@@ -172,7 +172,7 @@ _releasedc(ImagingDisplayObject* display, PyObject* args)
     HDC dc;
 
     if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE, &window, &dc))
-	return NULL;
+        return NULL;
 
     ReleaseDC(window, dc);
 
@@ -228,13 +228,13 @@ static struct PyMethodDef methods[] = {
 static PyObject*
 _getattr_mode(ImagingDisplayObject* self, void* closure)
 {
-	return Py_BuildValue("s", self->dib->mode);
+    return Py_BuildValue("s", self->dib->mode);
 }
 
 static PyObject*
 _getattr_size(ImagingDisplayObject* self, void* closure)
 {
-	return Py_BuildValue("ii", self->dib->xsize, self->dib->ysize);
+    return Py_BuildValue("ii", self->dib->xsize, self->dib->ysize);
 }
 
 static struct PyGetSetDef getsetters[] = {
@@ -244,13 +244,13 @@ static struct PyGetSetDef getsetters[] = {
 };
 
 static PyTypeObject ImagingDisplayType = {
-	PyVarObject_HEAD_INIT(NULL, 0)
+    PyVarObject_HEAD_INIT(NULL, 0)
-	"ImagingDisplay",		/*tp_name*/
+    "ImagingDisplay",            /*tp_name*/
-	sizeof(ImagingDisplayObject),	/*tp_size*/
+    sizeof(ImagingDisplayObject),/*tp_size*/
-	0,				/*tp_itemsize*/
+    0,                           /*tp_itemsize*/
-	/* methods */
+    /* methods */
-	(destructor)_delete,		/*tp_dealloc*/
+    (destructor)_delete,        /*tp_dealloc*/
-	0,				/*tp_print*/
+    0,                          /*tp_print*/
     0,                          /*tp_getattr*/
     0,                          /*tp_setattr*/
     0,                          /*tp_compare*/
@@ -285,11 +285,11 @@ PyImaging_DisplayWin32(PyObject* self, PyObject* args)
     int xsize, ysize;
 
     if (!PyArg_ParseTuple(args, "s(ii)", &mode, &xsize, &ysize))
-	return NULL;
+        return NULL;
 
     display = _new(mode, xsize, ysize);
     if (display == NULL)
-	return NULL;
+        return NULL;
 
     return (PyObject*) display;
 }
@@ -647,7 +647,7 @@ PyImaging_CreateWindowWin32(PyObject* self, PyObject* args)
     PyObject* callback;
     int width = 0, height = 0;
     if (!PyArg_ParseTuple(args, "sO|ii", &title, &callback, &width, &height))
-	return NULL;
+        return NULL;
 
     if (width <= 0)
         width = CW_USEDEFAULT;
@@ -817,7 +817,7 @@ error:
 #endif /* _WIN32 */
 
 /* -------------------------------------------------------------------- */
-/* X11 support	*/
+/* X11 support */
 
 #ifdef HAVE_XCB
 #include <xcb/xcb.h>

src/encode.c

@@ -1095,7 +1095,7 @@ PyImaging_JpegEncoderNew(PyObject* self, PyObject* args)
 
 
 /* -------------------------------------------------------------------- */
-/* JPEG	2000								*/
+/* JPEG 2000                                                            */
 /* -------------------------------------------------------------------- */
 
 #ifdef HAVE_OPENJPEG

src/libImaging/BitDecode.c

@@ -5,7 +5,7 @@
  * decoder for packed bitfields (converts to floating point)
  *
  * history:
- *	97-05-31 fl	created (much more than originally intended)
+ * 97-05-31 fl created (much more than originally intended)
  *
  * Copyright (c) Fredrik Lundh 1997.
  * Copyright (c) Secret Labs AB 1997.
@@ -27,18 +27,18 @@ ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     if (state->state == 0) {
 
-	/* Initialize context variables */
+        /* Initialize context variables */
 
         /* this decoder only works for float32 image buffers */
         if (im->type != IMAGING_TYPE_FLOAT32) {
-	    state->errcode = IMAGING_CODEC_CONFIG;
+            state->errcode = IMAGING_CODEC_CONFIG;
-	    return -1;
+            return -1;
         }
 
         /* sanity check */
         if (bitstate->bits < 1 || bitstate->bits >= 32) {
-	    state->errcode = IMAGING_CODEC_CONFIG;
+            state->errcode = IMAGING_CODEC_CONFIG;
-	    return -1;
+            return -1;
         }
 
         bitstate->mask = (1<<bitstate->bits)-1;
@@ -46,14 +46,14 @@ ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
         if (bitstate->sign)
             bitstate->signmask = (1<<(bitstate->bits-1));
 
-	/* check image orientation */
+        /* check image orientation */
-	if (state->ystep < 0) {
+        if (state->ystep < 0) {
-	    state->y = state->ysize-1;
+            state->y = state->ysize-1;
-	    state->ystep = -1;
+            state->ystep = -1;
-	} else
+        } else
-	    state->ystep = 1;
+            state->ystep = 1;
 
-	state->state = 1;
+        state->state = 1;
 
     }
 
@@ -119,7 +119,7 @@ ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
             *(FLOAT32*)(&im->image32[state->y][state->x]) = pixel;
 
             /* step forward */
-	    if (++state->x >= state->xsize) {
+            if (++state->x >= state->xsize) {
                 /* new line */
                 state->y += state->ystep;
                 if (state->y < 0 || state->y >= state->ysize) {

src/libImaging/Blend.c

@@ -5,9 +5,9 @@
  * interpolate between two existing images
  *
  * history:
- * 96-03-20 fl	Created
+ * 96-03-20 fl Created
- * 96-05-18 fl	Simplified blend expression
+ * 96-05-18 fl Simplified blend expression
- * 96-10-05 fl	Fixed expression bug, special case for interpolation
+ * 96-10-05 fl Fixed expression bug, special case for interpolation
  *
  * Copyright (c) Fredrik Lundh 1996.
  * Copyright (c) Secret Labs AB 1997.
@@ -32,48 +32,48 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha)
         return ImagingError_ModeError();
 
     if (imIn1->type  != imIn2->type  ||
-	imIn1->bands != imIn2->bands ||
+        imIn1->bands != imIn2->bands ||
-	imIn1->xsize != imIn2->xsize ||
+        imIn1->xsize != imIn2->xsize ||
-	imIn1->ysize != imIn2->ysize)
+        imIn1->ysize != imIn2->ysize)
-	return ImagingError_Mismatch();
+        return ImagingError_Mismatch();
 
     /* Shortcuts */
     if (alpha == 0.0)
-	return ImagingCopy(imIn1);
+        return ImagingCopy(imIn1);
     else if (alpha == 1.0)
-	return ImagingCopy(imIn2);
+        return ImagingCopy(imIn2);
 
     imOut = ImagingNewDirty(imIn1->mode, imIn1->xsize, imIn1->ysize);
     if (!imOut)
-	return NULL;
+        return NULL;
 
     if (alpha >= 0 && alpha <= 1.0) {
-	/* Interpolate between bands */
+        /* Interpolate between bands */
-	for (y = 0; y < imIn1->ysize; y++) {
+        for (y = 0; y < imIn1->ysize; y++) {
-	    UINT8* in1 = (UINT8*) imIn1->image[y];
+            UINT8* in1 = (UINT8*) imIn1->image[y];
-	    UINT8* in2 = (UINT8*) imIn2->image[y];
+            UINT8* in2 = (UINT8*) imIn2->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
-	    for (x = 0; x < imIn1->linesize; x++)
+            for (x = 0; x < imIn1->linesize; x++)
-		out[x] = (UINT8)
+                out[x] = (UINT8)
-		    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
+                    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
-	}
+        }
     } else {
-	/* Extrapolation; must make sure to clip resulting values */
+        /* Extrapolation; must make sure to clip resulting values */
-	for (y = 0; y < imIn1->ysize; y++) {
+        for (y = 0; y < imIn1->ysize; y++) {
-	    UINT8* in1 = (UINT8*) imIn1->image[y];
+            UINT8* in1 = (UINT8*) imIn1->image[y];
-	    UINT8* in2 = (UINT8*) imIn2->image[y];
+            UINT8* in2 = (UINT8*) imIn2->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
-	    for (x = 0; x < imIn1->linesize; x++) {
+            for (x = 0; x < imIn1->linesize; x++) {
-		float temp = (float)
+                float temp = (float)
-		    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
+                    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
-		if (temp <= 0.0)
+                if (temp <= 0.0)
-		    out[x] = 0;
+                    out[x] = 0;
-		else if (temp >= 255.0)
+                else if (temp >= 255.0)
-		    out[x] = 255;
+                    out[x] = 255;
-		else
+                else
-		    out[x] = (UINT8) temp;
+                    out[x] = (UINT8) temp;
-	    }
+            }
-	}
+        }
     }
 
     return imOut;

src/libImaging/ConvertYCbCr.c

@@ -5,7 +5,7 @@
  * code to convert YCbCr data
  *
  * history:
- * 98-07-01 hk	Created
+ * 98-07-01 hk Created
  *
  * Copyright (c) Secret Labs AB 1998
  *

src/libImaging/Copy.c

@@ -26,7 +26,7 @@ _copy(Imaging imOut, Imaging imIn)
     int y;
 
     if (!imIn)
-	return (Imaging) ImagingError_ValueError(NULL);
+        return (Imaging) ImagingError_ValueError(NULL);
 
     imOut = ImagingNew2Dirty(imIn->mode, imOut, imIn);
     if (!imOut)
@@ -36,7 +36,7 @@ _copy(Imaging imOut, Imaging imIn)
 
     ImagingSectionEnter(&cookie);
     if (imIn->block != NULL && imOut->block != NULL)
-	memcpy(imOut->block, imIn->block, imIn->ysize * imIn->linesize);
+        memcpy(imOut->block, imIn->block, imIn->ysize * imIn->linesize);
     else
         for (y = 0; y < imIn->ysize; y++)
             memcpy(imOut->image[y], imIn->image[y], imIn->linesize);

src/libImaging/Crop.c

@@ -5,9 +5,9 @@
  * cut region from image
  *
  * history:
- * 95-11-27 fl	Created
+ * 95-11-27 fl Created
- * 98-07-10 fl	Fixed "null result" error
+ * 98-07-10 fl Fixed "null result" error
- * 99-02-05 fl	Rewritten to use Paste primitive
+ * 99-02-05 fl Rewritten to use Paste primitive
  *
  * Copyright (c) Secret Labs AB 1997-99.
  * Copyright (c) Fredrik Lundh 1995.
@@ -28,7 +28,7 @@ ImagingCrop(Imaging imIn, int sx0, int sy0, int sx1, int sy1)
     INT32 zero = 0;
 
     if (!imIn)
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     xsize = sx1 - sx0;
     if (xsize < 0)
@@ -39,12 +39,12 @@ ImagingCrop(Imaging imIn, int sx0, int sy0, int sx1, int sy1)
 
     imOut = ImagingNewDirty(imIn->mode, xsize, ysize);
     if (!imOut)
-	return NULL;
+        return NULL;
 
     ImagingCopyPalette(imOut, imIn);
 
     if (sx0 < 0 || sy0 < 0 || sx1 > imIn->xsize || sy1 > imIn->ysize)
-	(void) ImagingFill(imOut, &zero);
+        (void) ImagingFill(imOut, &zero);
 
     dx0 = -sx0;
     dy0 = -sy0;

src/libImaging/EpsEncode.c

@@ -5,11 +5,11 @@
  * encoder for EPS hex data
  *
  * history:
- *	96-04-19 fl	created
+ * 96-04-19 fl created
- *	96-06-27 fl	don't drop last block of encoded data
+ * 96-06-27 fl don't drop last block of encoded data
  *
  * notes:
- *	FIXME: rename to HexEncode.c ??
+ * FIXME: rename to HexEncode.c ??
  *
  * Copyright (c) Fredrik Lundh 1996.
  * Copyright (c) Secret Labs AB 1997.
@@ -31,47 +31,47 @@ ImagingEpsEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
     UINT8* in, i;
 
     if (!state->state) {
-	state->state = HEXBYTE;
+        state->state = HEXBYTE;
-	state->xsize *= im->pixelsize; /* Hack! */
+        state->xsize *= im->pixelsize; /* Hack! */
     }
 
     in = (UINT8*) im->image[state->y];
 
     for (;;) {
 
-	if (state->state == NEWLINE) {
+        if (state->state == NEWLINE) {
-	    if (bytes < 1)
+            if (bytes < 1)
-		break;
+                break;
-	    *ptr++ = '\n';
+            *ptr++ = '\n';
-	    bytes--;
+            bytes--;
-	    state->state = HEXBYTE;
+            state->state = HEXBYTE;
-	}
+        }
 
-	if (bytes < 2)
+        if (bytes < 2)
-	    break;
+            break;
 
-	i = in[state->x++];
+        i = in[state->x++];
-	*ptr++ = hex[(i>>4)&15];
+        *ptr++ = hex[(i>>4)&15];
-	*ptr++ = hex[i&15];
+        *ptr++ = hex[i&15];
-	bytes -= 2;
+        bytes -= 2;
 
-	/* Skip junk bytes */
+        /* Skip junk bytes */
-	if (im->bands == 3 && (state->x & 3) == 3)
+        if (im->bands == 3 && (state->x & 3) == 3)
-	    state->x++;
+            state->x++;
 
-	if (++state->count >= 79/2) {
+        if (++state->count >= 79/2) {
-	    state->state = NEWLINE;
+            state->state = NEWLINE;
-	    state->count = 0;
+            state->count = 0;
-	}
+        }
 
-	if (state->x >= state->xsize) {
+        if (state->x >= state->xsize) {
-	    state->x = 0;
+            state->x = 0;
-	    if (++state->y >= state->ysize) {
+            if (++state->y >= state->ysize) {
-		state->errcode = IMAGING_CODEC_END;
+                state->errcode = IMAGING_CODEC_END;
-		break;
+                break;
-	    }
+            }
-	    in = (UINT8*) im->image[state->y];
+            in = (UINT8*) im->image[state->y];
-	}
+        }
 
     }
 

src/libImaging/Except.c

@@ -57,7 +57,7 @@ void *
 ImagingError_ValueError(const char *message)
 {
     if (!message)
-	message = "exception: bad argument to function";
+        message = "exception: bad argument to function";
     fprintf(stderr, "*** %s\n", message);
     return NULL;
 }

src/libImaging/Fill.c

@@ -5,9 +5,9 @@
  * fill image with constant pixel value
  *
  * history:
- * 95-11-26 fl	moved from Imaging.c
+ * 95-11-26 fl moved from Imaging.c
- * 96-05-17 fl	added radial fill, renamed wedge to linear
+ * 96-05-17 fl added radial fill, renamed wedge to linear
- * 98-06-23 fl	changed ImageFill signature
+ * 98-06-23 fl changed ImageFill signature
  *
  * Copyright (c) Secret Labs AB 1997-98.  All rights reserved.
  * Copyright (c) Fredrik Lundh 1995-96.

src/libImaging/FliDecode.c

@@ -5,8 +5,8 @@
  * decoder for Autodesk Animator FLI/FLC animations
  *
  * history:
- *	97-01-03 fl	Created
+ * 97-01-03 fl Created
- *	97-01-17 fl	Added SS2 support (FLC)
+ * 97-01-17 fl Added SS2 support (FLC)
  *
  * Copyright (c) Fredrik Lundh 1997.
  * Copyright (c) Secret Labs AB 1997.
@@ -18,10 +18,10 @@
 #include "Imaging.h"
 
 
-#define	I16(ptr)\
+#define I16(ptr)\
     ((ptr)[0] + ((ptr)[1] << 8))
 
-#define	I32(ptr)\
+#define I32(ptr)\
     ((ptr)[0] + ((ptr)[1] << 8) + ((ptr)[2] << 16) + ((ptr)[3] << 24))
 
 #define ERR_IF_DATA_OOB(offset) \
@@ -29,7 +29,7 @@
     state->errcode = IMAGING_CODEC_OVERRUN; \
     return -1; \
   }
-    
+
 int
 ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
 {
@@ -42,7 +42,7 @@ ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
     /* If not even the chunk size is present, we'd better leave */
 
     if (bytes < 4)
-	return 0;
+        return 0;
 
     /* We don't decode anything unless we have a full chunk in the
        input buffer */
@@ -51,7 +51,7 @@ ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     framesize = I32(ptr);
     if (framesize < I32(ptr))
-	return 0;
+        return 0;
 
     /* Make sure this is a frame chunk.  The Python driver takes
        case of other chunk types. */
@@ -61,8 +61,8 @@ ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
         return -1;
     }
     if (I16(ptr+4) != 0xF1FA) {
-	state->errcode = IMAGING_CODEC_UNKNOWN;
+        state->errcode = IMAGING_CODEC_UNKNOWN;
-	return -1;
+        return -1;
     }
 
     chunks = I16(ptr+6);
@@ -71,173 +71,173 @@ ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     /* Process subchunks */
     for (c = 0; c < chunks; c++) {
-	UINT8* data;
+        UINT8* data;
-	if (bytes < 10) {
+        if (bytes < 10) {
-	    state->errcode = IMAGING_CODEC_OVERRUN;
+            state->errcode = IMAGING_CODEC_OVERRUN;
-	    return -1;
+            return -1;
-	}
+        }
-	data = ptr + 6;
+        data = ptr + 6;
-	switch (I16(ptr+4)) {
+        switch (I16(ptr+4)) {
-	case 4: case 11:
+            case 4: case 11:
-	    /* FLI COLOR chunk */
+                /* FLI COLOR chunk */
-	    break; /* ignored; handled by Python code */
+                break; /* ignored; handled by Python code */
-	case 7:
+            case 7:
-	    /* FLI SS2 chunk (word delta) */
+                /* FLI SS2 chunk (word delta) */
-	    /* OOB ok, we've got 4 bytes min on entry */
+                /* OOB ok, we've got 4 bytes min on entry */
-	    lines = I16(data); data += 2;
+                lines = I16(data); data += 2;
-	    for (l = y = 0; l < lines && y < state->ysize; l++, y++) {
+                for (l = y = 0; l < lines && y < state->ysize; l++, y++) {
-		UINT8* local_buf = (UINT8*) im->image[y];
+                    UINT8* local_buf = (UINT8*) im->image[y];
-		int p, packets;
+                    int p, packets;
-		ERR_IF_DATA_OOB(2)
+                    ERR_IF_DATA_OOB(2)
-		packets = I16(data); data += 2;
+                    packets = I16(data); data += 2;
-		while (packets & 0x8000) {
+                    while (packets & 0x8000) {
-		    /* flag word */
+                        /* flag word */
-		    if (packets & 0x4000) {
+                        if (packets & 0x4000) {
-			y += 65536 - packets; /* skip lines */
+                            y += 65536 - packets; /* skip lines */
-			if (y >= state->ysize) {
+                            if (y >= state->ysize) {
-			    state->errcode = IMAGING_CODEC_OVERRUN;
+                                state->errcode = IMAGING_CODEC_OVERRUN;
-			    return -1;
+                                return -1;
-			}
+                            }
-			local_buf = (UINT8*) im->image[y];
+                            local_buf = (UINT8*) im->image[y];
-		    } else {
+                        } else {
-			/* store last byte (used if line width is odd) */
+                            /* store last byte (used if line width is odd) */
-			local_buf[state->xsize-1] = (UINT8) packets;
+                            local_buf[state->xsize-1] = (UINT8) packets;
-		    }
+                        }
-		    ERR_IF_DATA_OOB(2)
+                        ERR_IF_DATA_OOB(2)
-		    packets = I16(data); data += 2;
+                        packets = I16(data); data += 2;
-		}
+                    }
-		for (p = x = 0; p < packets; p++) {
+                    for (p = x = 0; p < packets; p++) {
-		    ERR_IF_DATA_OOB(2)
+                        ERR_IF_DATA_OOB(2)
-		    x += data[0]; /* pixel skip */
+                        x += data[0]; /* pixel skip */
-		    if (data[1] >= 128) {
+                        if (data[1] >= 128) {
-			ERR_IF_DATA_OOB(4)
+                            ERR_IF_DATA_OOB(4)
-			i = 256-data[1]; /* run */
+                            i = 256-data[1]; /* run */
-			if (x + i + i > state->xsize)
+                            if (x + i + i > state->xsize)
-			    break;
+                                break;
-			for (j = 0; j < i; j++) {
+                            for (j = 0; j < i; j++) {
-			    local_buf[x++] = data[2];
+                                local_buf[x++] = data[2];
-			    local_buf[x++] = data[3];
+                                local_buf[x++] = data[3];
-			}
+                            }
-			data += 2 + 2;
+                            data += 2 + 2;
-		    } else {
+                        } else {
-			i = 2 * (int) data[1]; /* chunk */
+                            i = 2 * (int) data[1]; /* chunk */
-			if (x + i > state->xsize)
+                            if (x + i > state->xsize)
-			    break;
+                                break;
-			ERR_IF_DATA_OOB(2+i)
+                            ERR_IF_DATA_OOB(2+i)
-			memcpy(local_buf + x, data + 2, i);
+                            memcpy(local_buf + x, data + 2, i);
-			data += 2 + i;
+                            data += 2 + i;
-			x += i;
+                            x += i;
-		    }
+                        }
-		}
+                    }
-		if (p < packets)
+                    if (p < packets)
-		    break; /* didn't process all packets */
+                        break; /* didn't process all packets */
-	    }
+                }
-	    if (l < lines) {
+                if (l < lines) {
-		/* didn't process all lines */
+                    /* didn't process all lines */
-		state->errcode = IMAGING_CODEC_OVERRUN;
+                    state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
+                    return -1;
-	    }
+                }
-	    break;
+                break;
-	case 12:
+            case 12:
-	    /* FLI LC chunk (byte delta) */
+                /* FLI LC chunk (byte delta) */
-	    /* OOB Check ok, we have 4 bytes min here */
+                /* OOB Check ok, we have 4 bytes min here */
-	    y = I16(data); ymax = y + I16(data+2); data += 4;
+                y = I16(data); ymax = y + I16(data+2); data += 4;
-	    for (; y < ymax && y < state->ysize; y++) {
+                for (; y < ymax && y < state->ysize; y++) {
-		UINT8* out = (UINT8*) im->image[y];
+                    UINT8* out = (UINT8*) im->image[y];
-                ERR_IF_DATA_OOB(1)
+                            ERR_IF_DATA_OOB(1)
-		int p, packets = *data++;
+                    int p, packets = *data++;
-		for (p = x = 0; p < packets; p++, x += i) {
+                    for (p = x = 0; p < packets; p++, x += i) {
-		    ERR_IF_DATA_OOB(2)
+                        ERR_IF_DATA_OOB(2)
-		    x += data[0]; /* skip pixels */
+                        x += data[0]; /* skip pixels */
-		    if (data[1] & 0x80) {
+                        if (data[1] & 0x80) {
-			i = 256-data[1]; /* run */
+                            i = 256-data[1]; /* run */
-			if (x + i > state->xsize)
+                            if (x + i > state->xsize)
-			    break;
+                                break;
-			ERR_IF_DATA_OOB(3)
+                            ERR_IF_DATA_OOB(3)
-			memset(out + x, data[2], i);
+                            memset(out + x, data[2], i);
-			data += 3;
+                            data += 3;
-		    } else {
+                        } else {
-			i = data[1]; /* chunk */
+                            i = data[1]; /* chunk */
-			if (x + i > state->xsize)
+                            if (x + i > state->xsize)
-			    break;
+                                break;
-			ERR_IF_DATA_OOB(2+i)
+                            ERR_IF_DATA_OOB(2+i)
-			memcpy(out + x, data + 2, i);
+                            memcpy(out + x, data + 2, i);
-			data += i + 2;
+                            data += i + 2;
-		    }
+                        }
-		}
+                    }
-		if (p < packets)
+                    if (p < packets)
-		    break; /* didn't process all packets */
+                        break; /* didn't process all packets */
-	    }
+                }
-	    if (y < ymax) {
+                if (y < ymax) {
-		/* didn't process all lines */
+                    /* didn't process all lines */
-		state->errcode = IMAGING_CODEC_OVERRUN;
+                    state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
+                    return -1;
-	    }
+                }
-	    break;
+                break;
-	case 13:
+            case 13:
-	    /* FLI BLACK chunk */
+                /* FLI BLACK chunk */
-	    for (y = 0; y < state->ysize; y++)
+                for (y = 0; y < state->ysize; y++)
-		memset(im->image[y], 0, state->xsize);
+                    memset(im->image[y], 0, state->xsize);
-	    break;
+                break;
-	case 15:
+            case 15:
-	    /* FLI BRUN chunk */
+                /* FLI BRUN chunk */
-	    /* OOB, ok, we've got 4 bytes min on entry */
+                /* OOB, ok, we've got 4 bytes min on entry */
-	    for (y = 0; y < state->ysize; y++) {
+                for (y = 0; y < state->ysize; y++) {
-		UINT8* out = (UINT8*) im->image[y];
+                    UINT8* out = (UINT8*) im->image[y];
-		data += 1; /* ignore packetcount byte */
+                    data += 1; /* ignore packetcount byte */
-		for (x = 0; x < state->xsize; x += i) {
+                    for (x = 0; x < state->xsize; x += i) {
-		    ERR_IF_DATA_OOB(2)
+                        ERR_IF_DATA_OOB(2)
-		    if (data[0] & 0x80) {
+                        if (data[0] & 0x80) {
-			i = 256 - data[0];
+                            i = 256 - data[0];
-			if (x + i > state->xsize) {
+                            if (x + i > state->xsize) {
-			    break; /* safety first */
+                                break; /* safety first */
-			}
+                            }
-			ERR_IF_DATA_OOB(i+1)
+                            ERR_IF_DATA_OOB(i+1)
-			memcpy(out + x, data + 1, i);
+                            memcpy(out + x, data + 1, i);
-			data += i + 1;
+                            data += i + 1;
-		    } else {
+                        } else {
-			i = data[0];
+                            i = data[0];
-			if (x + i > state->xsize)
+                            if (x + i > state->xsize)
-			    break; /* safety first */
+                                break; /* safety first */
-			memset(out + x, data[1], i);
+                            memset(out + x, data[1], i);
-			data += 2;
+                            data += 2;
-		    }
+                        }
-		}
+                    }
-		if (x != state->xsize) {
+                    if (x != state->xsize) {
-		    /* didn't unpack whole line */
+                        /* didn't unpack whole line */
-		    state->errcode = IMAGING_CODEC_OVERRUN;
+                        state->errcode = IMAGING_CODEC_OVERRUN;
-		    return -1;
+                        return -1;
-		}
+                    }
-	    }
+                }
-	    break;
+                break;
-	case 16:
+            case 16:
-	    /* COPY chunk */
+                /* COPY chunk */
-	    if (state->xsize > bytes/state->ysize) {
+                if (state->xsize > bytes/state->ysize) {
-		/* not enough data for frame */
+                    /* not enough data for frame */
-		return ptr - buf; /* bytes consumed */
+                    return ptr - buf; /* bytes consumed */
-	    }
+                }
-	    for (y = 0; y < state->ysize; y++) {
+                for (y = 0; y < state->ysize; y++) {
-		UINT8* local_buf = (UINT8*) im->image[y];
+                    UINT8* local_buf = (UINT8*) im->image[y];
-		memcpy(local_buf, data, state->xsize);
+                    memcpy(local_buf, data, state->xsize);
-		data += state->xsize;
+                    data += state->xsize;
-	    }
+                }
-	    break;
+                break;
-	case 18:
+            case 18:
-	    /* PSTAMP chunk */
+                /* PSTAMP chunk */
-	    break; /* ignored */
+                break; /* ignored */
-	default:
+            default:
-	    /* unknown chunk */
+                /* unknown chunk */
-	    /* printf("unknown FLI/FLC chunk: %d\n", I16(ptr+4)); */
+                /* printf("unknown FLI/FLC chunk: %d\n", I16(ptr+4)); */
-	    state->errcode = IMAGING_CODEC_UNKNOWN;
+                state->errcode = IMAGING_CODEC_UNKNOWN;
-	    return -1;
+                return -1;
-	}
+        }
-	advance = I32(ptr);
+        advance = I32(ptr);
-	if (advance < 0 || advance > bytes) {
+        if (advance < 0 || advance > bytes) {
-	    state->errcode = IMAGING_CODEC_OVERRUN;
+            state->errcode = IMAGING_CODEC_OVERRUN;
-	    return -1;
+            return -1;
-	}
+        }
-	ptr += advance;
+        ptr += advance;
-	bytes -= advance;
+        bytes -= advance;
     }
 
     return -1; /* end of frame */

src/libImaging/GetBBox.c

@@ -33,47 +33,47 @@ ImagingGetBBox(Imaging im, int bbox[4])
     bbox[1] = -1;
     bbox[2] = bbox[3] = 0;
 
-#define	GETBBOX(image, mask)\
+#define GETBBOX(image, mask)\
     for (y = 0; y < im->ysize; y++) {\
-	has_data = 0;\
+        has_data = 0;\
-	for (x = 0; x < im->xsize; x++)\
+        for (x = 0; x < im->xsize; x++)\
-	    if (im->image[y][x] & mask) {\
+            if (im->image[y][x] & mask) {\
-		has_data = 1;\
+                has_data = 1;\
-		if (x < bbox[0])\
+                if (x < bbox[0])\
-		    bbox[0] = x;\
+                    bbox[0] = x;\
-		if (x >= bbox[2])\
+                if (x >= bbox[2])\
-		    bbox[2] = x+1;\
+                    bbox[2] = x+1;\
-	    }\
+            }\
-	if (has_data) {\
+        if (has_data) {\
-	    if (bbox[1] < 0)\
+            if (bbox[1] < 0)\
-		bbox[1] = y;\
+            bbox[1] = y;\
-	    bbox[3] = y+1;\
+            bbox[3] = y+1;\
-	}\
+        }\
     }
 
     if (im->image8) {
-	GETBBOX(image8, 0xff);
+        GETBBOX(image8, 0xff);
     } else {
-	INT32 mask = 0xffffffff;
+        INT32 mask = 0xffffffff;
-	if (im->bands == 3) {
+        if (im->bands == 3) {
-	    ((UINT8*) &mask)[3] = 0;
+            ((UINT8*) &mask)[3] = 0;
-	} else if (strcmp(im->mode, "RGBa") == 0 ||
+        } else if (strcmp(im->mode, "RGBa") == 0 ||
-	           strcmp(im->mode, "RGBA") == 0 ||
+                   strcmp(im->mode, "RGBA") == 0 ||
-	           strcmp(im->mode, "La") == 0 ||
+                   strcmp(im->mode, "La") == 0 ||
-	           strcmp(im->mode, "LA") == 0 ||
+                   strcmp(im->mode, "LA") == 0 ||
-	           strcmp(im->mode, "PA") == 0) {
+                   strcmp(im->mode, "PA") == 0) {
 #ifdef WORDS_BIGENDIAN
-	    mask = 0x000000ff;
+        mask = 0x000000ff;
 #else
-	    mask = 0xff000000;
+        mask = 0xff000000;
 #endif
-	}
+        }
-	GETBBOX(image32, mask);
+        GETBBOX(image32, mask);
     }
 
     /* Check that we got a box */
     if (bbox[1] < 0)
-	return 0; /* no data */
+        return 0; /* no data */
 
     return 1; /* ok */
 }
@@ -91,25 +91,25 @@ ImagingGetProjection(Imaging im, UINT8* xproj, UINT8* yproj)
     memset(xproj, 0, im->xsize);
     memset(yproj, 0, im->ysize);
 
-#define	GETPROJ(image, mask)\
+    #define GETPROJ(image, mask)\
-    for (y = 0; y < im->ysize; y++) {\
+        for (y = 0; y < im->ysize; y++) {\
-	has_data = 0;\
+            has_data = 0;\
-	for (x = 0; x < im->xsize; x++)\
+            for (x = 0; x < im->xsize; x++)\
-	    if (im->image[y][x] & mask) {\
+                if (im->image[y][x] & mask) {\
-		has_data = 1;\
+                    has_data = 1;\
-		xproj[x] = 1;\
+                    xproj[x] = 1;\
-	    }\
+                }\
-	if (has_data)\
+                if (has_data)\
-	    yproj[y] = 1;\
+                    yproj[y] = 1;\
-    }
+                }
 
     if (im->image8) {
-	GETPROJ(image8, 0xff);
+        GETPROJ(image8, 0xff);
     } else {
-	INT32 mask = 0xffffffff;
+        INT32 mask = 0xffffffff;
-	if (im->bands == 3)
+        if (im->bands == 3)
-	    ((UINT8*) &mask)[3] = 0;
+            ((UINT8*) &mask)[3] = 0;
-	GETPROJ(image32, mask);
+        GETPROJ(image32, mask);
     }
 
     return 1; /* ok */
@@ -124,7 +124,7 @@ ImagingGetExtrema(Imaging im, void *extrema)
     FLOAT32 fmin, fmax;
 
     if (im->bands != 1) {
-	(void) ImagingError_ModeError();
+        (void) ImagingError_ModeError();
         return -1; /* mismatch */
     }
 
@@ -202,11 +202,11 @@ ImagingGetExtrema(Imaging im, void *extrema)
           memcpy(extrema, &v, sizeof(v));
           v = (UINT16) imax;
           memcpy(((char*)extrema) + sizeof(v), &v, sizeof(v));
-	  break;
+          break;
       }
       /* FALL THROUGH */
     default:
-	(void) ImagingError_ModeError();
+        (void) ImagingError_ModeError();
         return -1;
     }
     return 1; /* ok */
@@ -265,14 +265,14 @@ getcolors32(Imaging im, int maxcolors, int* size)
     /* printf("code_poly=%d\n", code_poly); */
 
     if (!code_size)
-	return ImagingError_MemoryError(); /* just give up */
+        return ImagingError_MemoryError(); /* just give up */
 
     if (!im->image32)
-	return ImagingError_ModeError();
+        return ImagingError_ModeError();
 
     table = calloc(code_size + 1, sizeof(ImagingColorItem));
     if (!table)
-	return ImagingError_MemoryError();
+        return ImagingError_MemoryError();
 
     pixel_mask = 0xffffffff;
     if (im->bands == 3)

src/libImaging/Gif.h

@@ -10,10 +10,10 @@
 
 /* Max size for a LZW code word. */
 
-#define	GIFBITS	    12
+#define GIFBITS     12
 
-#define	GIFTABLE    (1<<GIFBITS)
+#define GIFTABLE    (1<<GIFBITS)
-#define	GIFBUFFER   (1<<GIFBITS)
+#define GIFBUFFER   (1<<GIFBITS)
 
 
 typedef struct {

src/libImaging/GifDecode.c

@@ -5,15 +5,15 @@
  * a fast, suspendable GIF decoder
  *
  * history:
- * 95-09-03 fl	Created
+ * 95-09-03 fl Created
- * 95-09-05 fl	Fixed sign problem on 16-bit platforms
+ * 95-09-05 fl Fixed sign problem on 16-bit platforms
- * 95-09-13 fl	Added some storage shortcuts
+ * 95-09-13 fl Added some storage shortcuts
- * 96-03-28 fl	Revised API, integrated with PIL
+ * 96-03-28 fl Revised API, integrated with PIL
- * 96-12-10 fl	Added interlace support
+ * 96-12-10 fl Added interlace support
- * 96-12-16 fl	Fixed premature termination bug introduced by last fix
+ * 96-12-16 fl Fixed premature termination bug introduced by last fix
- * 97-01-05 fl	Don't mess up on bogus configuration
+ * 97-01-05 fl Don't mess up on bogus configuration
- * 97-01-17 fl	Don't mess up on very small, interlaced files
+ * 97-01-17 fl Don't mess up on very small, interlaced files
- * 99-02-07 fl	Minor speedups
+ * 99-02-07 fl Minor speedups
  *
  * Copyright (c) Secret Labs AB 1997-99.
  * Copyright (c) Fredrik Lundh 1995-97.
@@ -25,7 +25,7 @@
 #include "Imaging.h"
 
 #include <stdio.h>
-#include <memory.h>	/* memcpy() */
+#include <memory.h> /* memcpy() */
 
 #include "Gif.h"
 
@@ -34,23 +34,23 @@
     state->x = 0;\
     state->y += context->step;\
     while (state->y >= state->ysize)\
-	switch (context->interlace) {\
+        switch (context->interlace) {\
-	case 1:\
+            case 1:\
-	    context->repeat = state->y = 4;\
+                context->repeat = state->y = 4;\
-	    context->interlace = 2;\
+                context->interlace = 2;\
-	    break;\
+                break;\
-	case 2:\
+            case 2:\
-	    context->step = 4;\
+                context->step = 4;\
-	    context->repeat = state->y = 2;\
+                context->repeat = state->y = 2;\
-	    context->interlace = 3;\
+                context->interlace = 3;\
-	    break;\
+                break;\
-	case 3:\
+            case 3:\
-	    context->step = 2;\
+                context->step = 2;\
-	    context->repeat = state->y = 1;\
+                context->repeat = state->y = 1;\
-	    context->interlace = 0;\
+                context->interlace = 0;\
-	    break;\
+                break;\
-	default:\
+            default:\
-	    return -1;\
+                return -1;\
         }\
     if (state->y < state->ysize)\
         out = im->image8[state->y + state->yoff] + state->xoff;\
@@ -70,227 +70,227 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
 
     if (!state->state) {
 
-	/* Initialise state */
+    /* Initialise state */
-	if (context->bits < 0 || context->bits > 12) {
+    if (context->bits < 0 || context->bits > 12) {
-	    state->errcode = IMAGING_CODEC_CONFIG;
+        state->errcode = IMAGING_CODEC_CONFIG;
-	    return -1;
+        return -1;
-	}
+    }
 
-	/* Clear code */
+    /* Clear code */
-	context->clear = 1 << context->bits;
+    context->clear = 1 << context->bits;
 
-	/* End code */
+    /* End code */
-	context->end = context->clear + 1;
+    context->end = context->clear + 1;
 
-	/* Interlace */
+    /* Interlace */
-	if (context->interlace) {
+    if (context->interlace) {
-	    context->interlace = 1;
+        context->interlace = 1;
-	    context->step = context->repeat = 8;
+        context->step = context->repeat = 8;
-	} else
+    } else
-	    context->step = 1;
+        context->step = 1;
 
-	state->state = 1;
+        state->state = 1;
     }
 
     out = im->image8[state->y + state->yoff] + state->xoff + state->x;
 
     for (;;) {
 
-	if (state->state == 1) {
+        if (state->state == 1) {
 
-	    /* First free entry in table */
+            /* First free entry in table */
-	    context->next = context->clear + 2;
+            context->next = context->clear + 2;
 
-	    /* Initial code size */
+            /* Initial code size */
-	    context->codesize = context->bits + 1;
+            context->codesize = context->bits + 1;
-	    context->codemask = (1 << context->codesize) - 1;
+            context->codemask = (1 << context->codesize) - 1;
 
-	    /* Buffer pointer.  We fill the buffer from right, which
+            /* Buffer pointer.  We fill the buffer from right, which
-	       allows us to return all of it in one operation. */
+               allows us to return all of it in one operation. */
-	    context->bufferindex = GIFBUFFER;
+            context->bufferindex = GIFBUFFER;
 
-	    state->state = 2;
+            state->state = 2;
-	}
+        }
 
-	if (context->bufferindex < GIFBUFFER) {
+        if (context->bufferindex < GIFBUFFER) {
 
-	    /* Return whole buffer in one chunk */
+            /* Return whole buffer in one chunk */
-	    i = GIFBUFFER - context->bufferindex;
+            i = GIFBUFFER - context->bufferindex;
-	    p = &context->buffer[context->bufferindex];
+            p = &context->buffer[context->bufferindex];
 
-	    context->bufferindex = GIFBUFFER;
+            context->bufferindex = GIFBUFFER;
 
-	} else {
+        } else {
 
-	    /* Get current symbol */
+            /* Get current symbol */
 
-	    while (context->bitcount < context->codesize) {
+            while (context->bitcount < context->codesize) {
 
-		if (context->blocksize > 0) {
+                if (context->blocksize > 0) {
 
-		    /* Read next byte */
+                    /* Read next byte */
-		    c = *ptr++; bytes--;
+                    c = *ptr++; bytes--;
 
-		    context->blocksize--;
+                    context->blocksize--;
 
-		    /* New bits are shifted in from from the left. */
+                    /* New bits are shifted in from from the left. */
-		    context->bitbuffer |= (INT32) c << context->bitcount;
+                    context->bitbuffer |= (INT32) c << context->bitcount;
-		    context->bitcount += 8;
+                    context->bitcount += 8;
 
-		} else {
+                } else {
 
-		    /* New GIF block */
+                    /* New GIF block */
 
-		    /* We don't start decoding unless we have a full block */
+                    /* We don't start decoding unless we have a full block */
-		    if (bytes < 1)
+                    if (bytes < 1)
-			return ptr - buffer;
+                        return ptr - buffer;
-		    c = *ptr;
+                    c = *ptr;
-		    if (bytes < c+1)
+                    if (bytes < c+1)
-			return ptr - buffer;
+                        return ptr - buffer;
 
-		    context->blocksize = c;
+                    context->blocksize = c;
 
-		    ptr++; bytes--;
+                    ptr++; bytes--;
 
-		}
+                }
-	    }
+            }
 
-	    /* Extract current symbol from bit buffer. */
+            /* Extract current symbol from bit buffer. */
-	    c = (int) context->bitbuffer & context->codemask;
+            c = (int) context->bitbuffer & context->codemask;
 
-	    /* Adjust buffer */
+            /* Adjust buffer */
-	    context->bitbuffer >>= context->codesize;
+            context->bitbuffer >>= context->codesize;
-	    context->bitcount -= context->codesize;
+            context->bitcount -= context->codesize;
 
-	    /* If c is less than "clear", it's a data byte.  Otherwise,
+            /* If c is less than "clear", it's a data byte.  Otherwise,
-	       it's either clear/end or a code symbol which should be
+               it's either clear/end or a code symbol which should be
-	       expanded. */
+               expanded. */
 
-	    if (c == context->clear) {
+            if (c == context->clear) {
-		if (state->state != 2)
+                if (state->state != 2)
-		    state->state = 1;
+                    state->state = 1;
-		continue;
+                continue;
-	    }
+            }
 
-	    if (c == context->end)
+            if (c == context->end)
-		break;
+                break;
 
-	    i = 1;
+            i = 1;
-	    p = &context->lastdata;
+            p = &context->lastdata;
 
-	    if (state->state == 2) {
+            if (state->state == 2) {
 
-		/* First valid symbol after clear; use as is */
+                /* First valid symbol after clear; use as is */
-		if (c > context->clear) {
+                if (c > context->clear) {
-		    state->errcode = IMAGING_CODEC_BROKEN;
+                    state->errcode = IMAGING_CODEC_BROKEN;
-		    return -1;
+                    return -1;
-		}
+                }
 
-		context->lastdata = context->lastcode = c;
+                context->lastdata = context->lastcode = c;
-		state->state = 3;
+                state->state = 3;
 
-	    } else {
+            } else {
 
-		thiscode = c;
+                thiscode = c;
 
-		if (c > context->next) {
+                if (c > context->next) {
-		    state->errcode = IMAGING_CODEC_BROKEN;
+                    state->errcode = IMAGING_CODEC_BROKEN;
-		    return -1;
+                    return -1;
-		}
+                }
 
-		if (c == context->next) {
+                if (c == context->next) {
 
-		    /* c == next is allowed. not sure why. */
+                    /* c == next is allowed. not sure why. */
 
-		    if (context->bufferindex <= 0) {
+                    if (context->bufferindex <= 0) {
-			state->errcode = IMAGING_CODEC_BROKEN;
+                        state->errcode = IMAGING_CODEC_BROKEN;
-			return -1;
+                        return -1;
-		    }
+                    }
 
-		    context->buffer[--context->bufferindex] =
+                    context->buffer[--context->bufferindex] =
-			context->lastdata;
+                    context->lastdata;
 
-		    c = context->lastcode;
+                    c = context->lastcode;
 
-		}
+                }
 
-		while (c >= context->clear) {
+                while (c >= context->clear) {
 
-		    /* Copy data string to buffer (beginning from right) */
+                    /* Copy data string to buffer (beginning from right) */
 
-		    if (context->bufferindex <= 0 || c >= GIFTABLE) {
+                    if (context->bufferindex <= 0 || c >= GIFTABLE) {
-			state->errcode = IMAGING_CODEC_BROKEN;
+                        state->errcode = IMAGING_CODEC_BROKEN;
-			return -1;
+                        return -1;
-		    }
+                    }
 
-		    context->buffer[--context->bufferindex] =
+                    context->buffer[--context->bufferindex] =
-			context->data[c];
+                    context->data[c];
 
-		    c = context->link[c];
+                    c = context->link[c];
-		}
+                }
 
-		context->lastdata = c;
+                context->lastdata = c;
 
-		if (context->next < GIFTABLE) {
+                if (context->next < GIFTABLE) {
 
-		    /* We'll only add this symbol if we have room
+                    /* We'll only add this symbol if we have room
-		       for it (take advise, Netscape!) */
+                       for it (take advise, Netscape!) */
-		    context->data[context->next] = c;
+                    context->data[context->next] = c;
-		    context->link[context->next] = context->lastcode;
+                    context->link[context->next] = context->lastcode;
 
-		    if (context->next == context->codemask &&
+                    if (context->next == context->codemask &&
-			context->codesize < GIFBITS) {
+                    context->codesize < GIFBITS) {
 
-			/* Expand code size */
+                        /* Expand code size */
-			context->codesize++;
+                        context->codesize++;
-			context->codemask = (1 << context->codesize) - 1;
+                        context->codemask = (1 << context->codesize) - 1;
-		    }
+                    }
 
-		    context->next++;
+                    context->next++;
 
-		}
+                }
 
-		context->lastcode = thiscode;
+                context->lastcode = thiscode;
 
-	    }
+            }
-	}
+        }
 
-	/* Copy the bytes into the image */
+        /* Copy the bytes into the image */
-	if (state->y >= state->ysize) {
+        if (state->y >= state->ysize) {
-	    state->errcode = IMAGING_CODEC_OVERRUN;
+            state->errcode = IMAGING_CODEC_OVERRUN;
-	    return -1;
+            return -1;
-	}
+        }
 
-	/* To squeeze some extra pixels out of this loop, we test for
+        /* To squeeze some extra pixels out of this loop, we test for
-	   some common cases and handle them separately. */
+           some common cases and handle them separately. */
 
-	/* FIXME: should we handle the transparency index in here??? */
+        /* FIXME: should we handle the transparency index in here??? */
 
-	if (i == 1) {
+        if (i == 1) {
-	    if (state->x < state->xsize-1) {
+            if (state->x < state->xsize-1) {
-		/* Single pixel, not at the end of the line. */
+                /* Single pixel, not at the end of the line. */
-		*out++ = p[0];
+                *out++ = p[0];
-		state->x++;
+                state->x++;
-		continue;
+                continue;
-	    }
+            }
-	} else if (state->x + i <= state->xsize) {
+        } else if (state->x + i <= state->xsize) {
-	    /* This string fits into current line. */
+            /* This string fits into current line. */
-	    memcpy(out, p, i);
+            memcpy(out, p, i);
-            out += i;
+                out += i;
-	    state->x += i;
+            state->x += i;
-	    if (state->x == state->xsize) {
+            if (state->x == state->xsize) {
-		NEWLINE(state, context);
+                NEWLINE(state, context);
-	    }
+            }
-	    continue;
+            continue;
-	}
+        }
 
-	/* No shortcut, copy pixel by pixel */
+        /* No shortcut, copy pixel by pixel */
-	for (c = 0; c < i; c++) {
+        for (c = 0; c < i; c++) {
-	    *out++ = p[c];
+            *out++ = p[c];
-	    if (++state->x >= state->xsize) {
+            if (++state->x >= state->xsize) {
-		NEWLINE(state, context);
+                NEWLINE(state, context);
-	    }
+            }
-	}
+        }
     }
 
     return ptr - buffer;

src/libImaging/GifEncode.c

@@ -5,11 +5,11 @@
  * encoder for uncompressed GIF data
  *
  * history:
- * 97-01-05 fl	created (writes uncompressed data)
+ * 97-01-05 fl created (writes uncompressed data)
- * 97-08-27 fl	fixed off-by-one error in buffer size test
+ * 97-08-27 fl fixed off-by-one error in buffer size test
- * 98-07-09 fl	added interlace write support
+ * 98-07-09 fl added interlace write support
- * 99-02-07 fl	rewritten, now uses a run-length encoding strategy
+ * 99-02-07 fl rewritten, now uses a run-length encoding strategy
- * 99-02-08 fl	improved run-length encoding for long runs
+ * 99-02-08 fl improved run-length encoding for long runs
  *
  * Copyright (c) Secret Labs AB 1997-99.
  * Copyright (c) Fredrik Lundh 1997.
@@ -145,17 +145,17 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
 
     if (!state->state) {
 
-	/* place a clear code in the output buffer */
+        /* place a clear code in the output buffer */
-	context->bitbuffer = CLEAR_CODE;
+        context->bitbuffer = CLEAR_CODE;
-	context->bitcount = 9;
+        context->bitcount = 9;
 
-	state->count = FIRST_CODE;
+        state->count = FIRST_CODE;
 
-	if (context->interlace) {
+        if (context->interlace) {
-	    context->interlace = 1;
+            context->interlace = 1;
-	    context->step = 8;
+            context->step = 8;
-	} else
+        } else
-	    context->step = 1;
+            context->step = 1;
 
         context->last = -1;
 
@@ -169,152 +169,152 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
 
     for (;;)
 
-	switch (state->state) {
+        switch (state->state) {
 
-        case INIT:
+            case INIT:
-        case ENCODE:
+            case ENCODE:
 
-            /* identify and store a run of pixels */
+                /* identify and store a run of pixels */
 
-            if (state->x == 0 || state->x >= state->xsize) {
+                if (state->x == 0 || state->x >= state->xsize) {
 
-                if (!context->interlace && state->y >= state->ysize) {
+                    if (!context->interlace && state->y >= state->ysize) {
-                    state->state = ENCODE_EOF;
+                        state->state = ENCODE_EOF;
-                    break;
-                }
-
-                if (context->flush) {
-                    state->state = FLUSH;
-                    break;
-                }
-
-                /* get another line of data */
-                state->shuffle(
-                    state->buffer,
-                    (UINT8*) im->image[state->y + state->yoff] +
-                    state->xoff * im->pixelsize, state->xsize
-                    );
-
-                state->x = 0;
-
-                if (state->state == INIT) {
-                    /* preload the run-length buffer and get going */
-                    context->last = state->buffer[0];
-                    context->count = state->x = 1;
-                    state->state = ENCODE;
-                }
-
-                /* step forward, according to the interlace settings */
-                state->y += context->step;
-                while (context->interlace && state->y >= state->ysize)
-                    switch (context->interlace) {
-                    case 1:
-                        state->y = 4;
-                        context->interlace = 2;
                         break;
-                    case 2:
-                        context->step = 4;
-                        state->y = 2;
-                        context->interlace = 3;
-                        break;
-                    case 3:
-                        context->step = 2;
-                        state->y = 1;
-                        context->interlace = 0;
-                        break;
-                    default:
-                        /* just make sure we don't loop forever */
-                        context->interlace = 0;
                     }
 
-            }
+                    if (context->flush) {
+                        state->state = FLUSH;
+                        break;
+                    }
 
-            this = state->buffer[state->x++];
+                    /* get another line of data */
+                    state->shuffle(
+                        state->buffer,
+                        (UINT8*) im->image[state->y + state->yoff] +
+                        state->xoff * im->pixelsize, state->xsize
+                    );
 
-            if (this == context->last)
+                    state->x = 0;
-                context->count++;
-            else {
-                EMIT_RUN(label1);
-                context->last = this;
-                context->count = 1;
-            }
-	    break;
 
+                    if (state->state == INIT) {
+                        /* preload the run-length buffer and get going */
+                        context->last = state->buffer[0];
+                        context->count = state->x = 1;
+                        state->state = ENCODE;
+                    }
 
-        case ENCODE_EOF:
+                    /* step forward, according to the interlace settings */
+                    state->y += context->step;
+                    while (context->interlace && state->y >= state->ysize)
+                        switch (context->interlace) {
+                            case 1:
+                                state->y = 4;
+                                context->interlace = 2;
+                                break;
+                            case 2:
+                                context->step = 4;
+                                state->y = 2;
+                                context->interlace = 3;
+                                break;
+                            case 3:
+                                context->step = 2;
+                                state->y = 1;
+                                context->interlace = 0;
+                                break;
+                            default:
+                                /* just make sure we don't loop forever */
+                                context->interlace = 0;
+                        }
 
-            /* write the final run */
-            EMIT_RUN(label2);
-
-            /* write an end of image marker */
-            EMIT(EOF_CODE);
-
-            /* empty the bit buffer */
-            while (context->bitcount > 0) {
-                if (!emit(context, (UINT8) context->bitbuffer)) {
-                    state->errcode = IMAGING_CODEC_MEMORY;
-                    return 0;
                 }
-                context->bitbuffer >>= 8;
-                context->bitcount -= 8;
-            }
 
-            /* flush the last block, and exit */
+                this = state->buffer[state->x++];
-            if (context->block) {
-                GIFENCODERBLOCK* block;
-                block = context->flush;
-                while (block && block->next)
-                    block = block->next;
-                if (block)
-                    block->next = context->block;
-                else
-                    context->flush = context->block;
-                context->block = NULL;
-            }
 
-            state->state = EXIT;
+                if (this == context->last)
+                    context->count++;
+                else {
+                    EMIT_RUN(label1);
+                    context->last = this;
+                    context->count = 1;
+                }
+                break;
 
-            /* fall through... */
 
-	case EXIT:
+            case ENCODE_EOF:
-	case FLUSH:
 
-            while (context->flush) {
+                /* write the final run */
+                EMIT_RUN(label2);
 
-                /* get a block from the flush queue */
+                /* write an end of image marker */
-                block = context->flush;
+                EMIT(EOF_CODE);
 
-                if (block->size > 0) {
+                /* empty the bit buffer */
+                while (context->bitcount > 0) {
+                    if (!emit(context, (UINT8) context->bitbuffer)) {
+                        state->errcode = IMAGING_CODEC_MEMORY;
+                        return 0;
+                    }
+                    context->bitbuffer >>= 8;
+                    context->bitcount -= 8;
+                }
 
-                    /* make sure it fits into the output buffer */
+                /* flush the last block, and exit */
-                    if (bytes < block->size+1)
+                if (context->block) {
+                    GIFENCODERBLOCK* block;
+                    block = context->flush;
+                    while (block && block->next)
+                        block = block->next;
+                    if (block)
+                        block->next = context->block;
+                    else
+                        context->flush = context->block;
+                    context->block = NULL;
+                }
+
+                state->state = EXIT;
+
+                /* fall through... */
+
+            case EXIT:
+            case FLUSH:
+
+                    while (context->flush) {
+
+                        /* get a block from the flush queue */
+                        block = context->flush;
+
+                        if (block->size > 0) {
+
+                            /* make sure it fits into the output buffer */
+                            if (bytes < block->size+1)
+                                return ptr - buf;
+
+                            ptr[0] = block->size;
+                            memcpy(ptr+1, block->data, block->size);
+
+                            ptr += block->size+1;
+                            bytes -= block->size+1;
+
+                        }
+
+                        context->flush = block->next;
+
+                        if (context->free)
+                            free(context->free);
+                        context->free = block;
+
+                    }
+
+                    if (state->state == EXIT) {
+                        /* this was the last block! */
+                        if (context->free)
+                            free(context->free);
+                        state->errcode = IMAGING_CODEC_END;
                         return ptr - buf;
+                    }
 
-                    ptr[0] = block->size;
+                    state->state = ENCODE;
-                    memcpy(ptr+1, block->data, block->size);
+                    break;
-
+    }
-                    ptr += block->size+1;
-                    bytes -= block->size+1;
-
-                }
-
-                context->flush = block->next;
-
-                if (context->free)
-                    free(context->free);
-                context->free = block;
-
-            }
-
-            if (state->state == EXIT) {
-                /* this was the last block! */
-                if (context->free)
-                    free(context->free);
-                state->errcode = IMAGING_CODEC_END;
-                return ptr - buf;
-            }
-
-            state->state = ENCODE;
-	    break;
-        }
 }

src/libImaging/HexDecode.c

@@ -5,7 +5,7 @@
  * decoder for hex encoded image data
  *
  * history:
- *	96-05-16 fl	Created
+ * 96-05-16 fl Created
  *
  * Copyright (c) Fredrik Lundh 1996.
  * Copyright (c) Secret Labs AB 1997.
@@ -16,9 +16,9 @@
 
 #include "Imaging.h"
 
-#define	HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
+#define HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
-		(v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
+        (v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
-		(v >= 'A' && v <= 'F') ? v - 'A' + 10 : -1)
+        (v >= 'A' && v <= 'F') ? v - 'A' + 10 : -1)
 
 int
 ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
@@ -30,38 +30,38 @@ ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     for (;;) {
 
-	if (bytes < 2)
+        if (bytes < 2)
-	    return ptr - buf;
+            return ptr - buf;
 
-	a = HEX(ptr[0]);
+        a = HEX(ptr[0]);
-	b = HEX(ptr[1]);
+        b = HEX(ptr[1]);
 
-	if (a < 0 || b < 0) {
+        if (a < 0 || b < 0) {
 
-	    ptr++;
+            ptr++;
-	    bytes--;
+            bytes--;
 
-	} else {
+        } else {
 
-	    ptr += 2;
+            ptr += 2;
-	    bytes -= 2;
+            bytes -= 2;
 
-	    state->buffer[state->x] = (a<<4) + b;
+            state->buffer[state->x] = (a<<4) + b;
 
-	    if (++state->x >= state->bytes) {
+            if (++state->x >= state->bytes) {
 
-		/* Got a full line, unpack it */
+                /* Got a full line, unpack it */
-		state->shuffle((UINT8*) im->image[state->y], state->buffer,
+                state->shuffle((UINT8*) im->image[state->y], state->buffer,
-			       state->xsize);
+                           state->xsize);
 
-		state->x = 0;
+                state->x = 0;
 
-		if (++state->y >= state->ysize) {
+                if (++state->y >= state->ysize) {
-		    /* End of file (errcode = 0) */
+                    /* End of file (errcode = 0) */
-		    return -1;
+                    return -1;
-		}
+                }
-	    }
+            }
 
-	}
+        }
     }
 }

src/libImaging/Histo.c

@@ -30,7 +30,7 @@ void
 ImagingHistogramDelete(ImagingHistogram h)
 {
     if (h->histogram)
-	free(h->histogram);
+        free(h->histogram);
     free(h);
 }
 
@@ -60,115 +60,115 @@ ImagingGetHistogram(Imaging im, Imaging imMask, void* minmax)
     FLOAT32 fmin, fmax, scale;
 
     if (!im)
-	return ImagingError_ModeError();
+        return ImagingError_ModeError();
 
     if (imMask) {
-	/* Validate mask */
+        /* Validate mask */
-	if (im->xsize != imMask->xsize || im->ysize != imMask->ysize)
+        if (im->xsize != imMask->xsize || im->ysize != imMask->ysize)
-	    return ImagingError_Mismatch();
+            return ImagingError_Mismatch();
-	if (strcmp(imMask->mode, "1") != 0 && strcmp(imMask->mode, "L") != 0)
+        if (strcmp(imMask->mode, "1") != 0 && strcmp(imMask->mode, "L") != 0)
-	    return ImagingError_ValueError("bad transparency mask");
+            return ImagingError_ValueError("bad transparency mask");
     }
 
     h = ImagingHistogramNew(im);
 
     if (imMask) {
-	/* mask */
+        /* mask */
-	if (im->image8) {
+        if (im->image8) {
-            ImagingSectionEnter(&cookie);
+                ImagingSectionEnter(&cookie);
-	    for (y = 0; y < im->ysize; y++)
+            for (y = 0; y < im->ysize; y++)
-		for (x = 0; x < im->xsize; x++)
+                for (x = 0; x < im->xsize; x++)
-		    if (imMask->image8[y][x] != 0)
+                    if (imMask->image8[y][x] != 0)
-			h->histogram[im->image8[y][x]]++;
+                    h->histogram[im->image8[y][x]]++;
-            ImagingSectionLeave(&cookie);
+                    ImagingSectionLeave(&cookie);
-	} else { /* yes, we need the braces. C isn't Python! */
+        } else { /* yes, we need the braces. C isn't Python! */
             if (im->type != IMAGING_TYPE_UINT8) {
                 ImagingHistogramDelete(h);
                 return ImagingError_ModeError();
             }
             ImagingSectionEnter(&cookie);
-	    for (y = 0; y < im->ysize; y++) {
+            for (y = 0; y < im->ysize; y++) {
-		UINT8* in = (UINT8*) im->image32[y];
+                UINT8* in = (UINT8*) im->image32[y];
-		for (x = 0; x < im->xsize; x++)
+                for (x = 0; x < im->xsize; x++)
-		    if (imMask->image8[y][x] != 0) {
+                    if (imMask->image8[y][x] != 0) {
-			h->histogram[(*in++)]++;
-			h->histogram[(*in++)+256]++;
-			h->histogram[(*in++)+512]++;
-			h->histogram[(*in++)+768]++;
-		    } else
-			in += 4;
-	    }
-            ImagingSectionLeave(&cookie);
-	}
-    } else {
-	/* mask not given; process pixels in image */
-	if (im->image8) {
-            ImagingSectionEnter(&cookie);
-	    for (y = 0; y < im->ysize; y++)
-		for (x = 0; x < im->xsize; x++)
-		    h->histogram[im->image8[y][x]]++;
-            ImagingSectionLeave(&cookie);
-	} else {
-            switch (im->type) {
-            case IMAGING_TYPE_UINT8:
-                ImagingSectionEnter(&cookie);
-                for (y = 0; y < im->ysize; y++) {
-                    UINT8* in = (UINT8*) im->image[y];
-                    for (x = 0; x < im->xsize; x++) {
                         h->histogram[(*in++)]++;
                         h->histogram[(*in++)+256]++;
                         h->histogram[(*in++)+512]++;
                         h->histogram[(*in++)+768]++;
-                    }
+                    } else
-                }
+                        in += 4;
-                ImagingSectionLeave(&cookie);
+            }
-                break;
+            ImagingSectionLeave(&cookie);
-            case IMAGING_TYPE_INT32:
+        }
-                if (!minmax) {
+    } else {
-                    ImagingHistogramDelete(h);
+        /* mask not given; process pixels in image */
-                    return ImagingError_ValueError("min/max not given");
+        if (im->image8) {
-                }
-                if (!im->xsize || !im->ysize)
-                    break;
-                memcpy(&imin, minmax, sizeof(imin));
-                memcpy(&imax, ((char*)minmax) + sizeof(imin), sizeof(imax));
-                if (imin >= imax)
-                    break;
                 ImagingSectionEnter(&cookie);
-                scale = 255.0F / (imax - imin);
+            for (y = 0; y < im->ysize; y++)
-                for (y = 0; y < im->ysize; y++) {
+                for (x = 0; x < im->xsize; x++)
-                    INT32* in = im->image32[y];
+                    h->histogram[im->image8[y][x]]++;
-                    for (x = 0; x < im->xsize; x++) {
+                    ImagingSectionLeave(&cookie);
-                        i = (int) (((*in++)-imin)*scale);
+        } else {
-                        if (i >= 0 && i < 256)
+            switch (im->type) {
-                            h->histogram[i]++;
+                case IMAGING_TYPE_UINT8:
+                    ImagingSectionEnter(&cookie);
+                    for (y = 0; y < im->ysize; y++) {
+                        UINT8* in = (UINT8*) im->image[y];
+                        for (x = 0; x < im->xsize; x++) {
+                            h->histogram[(*in++)]++;
+                            h->histogram[(*in++)+256]++;
+                            h->histogram[(*in++)+512]++;
+                            h->histogram[(*in++)+768]++;
+                        }
                     }
-                }
+                    ImagingSectionLeave(&cookie);
-                ImagingSectionLeave(&cookie);
-                break;
-            case IMAGING_TYPE_FLOAT32:
-                if (!minmax) {
-                    ImagingHistogramDelete(h);
-                    return ImagingError_ValueError("min/max not given");
-                }
-                if (!im->xsize || !im->ysize)
                     break;
-                memcpy(&fmin, minmax, sizeof(fmin));
+                case IMAGING_TYPE_INT32:
-                memcpy(&fmax, ((char*)minmax) + sizeof(fmin), sizeof(fmax));
+                    if (!minmax) {
-                if (fmin >= fmax)
+                        ImagingHistogramDelete(h);
-                    break;
+                        return ImagingError_ValueError("min/max not given");
-                ImagingSectionEnter(&cookie);
-                scale = 255.0F / (fmax - fmin);
-                for (y = 0; y < im->ysize; y++) {
-                    FLOAT32* in = (FLOAT32*) im->image32[y];
-                    for (x = 0; x < im->xsize; x++) {
-                        i = (int) (((*in++)-fmin)*scale);
-                        if (i >= 0 && i < 256)
-                            h->histogram[i]++;
                     }
-                }
+                    if (!im->xsize || !im->ysize)
-                ImagingSectionLeave(&cookie);
+                        break;
-                break;
+                    memcpy(&imin, minmax, sizeof(imin));
+                    memcpy(&imax, ((char*)minmax) + sizeof(imin), sizeof(imax));
+                    if (imin >= imax)
+                        break;
+                    ImagingSectionEnter(&cookie);
+                    scale = 255.0F / (imax - imin);
+                    for (y = 0; y < im->ysize; y++) {
+                        INT32* in = im->image32[y];
+                        for (x = 0; x < im->xsize; x++) {
+                            i = (int) (((*in++)-imin)*scale);
+                            if (i >= 0 && i < 256)
+                                h->histogram[i]++;
+                        }
+                    }
+                    ImagingSectionLeave(&cookie);
+                    break;
+                case IMAGING_TYPE_FLOAT32:
+                    if (!minmax) {
+                        ImagingHistogramDelete(h);
+                        return ImagingError_ValueError("min/max not given");
+                    }
+                    if (!im->xsize || !im->ysize)
+                        break;
+                    memcpy(&fmin, minmax, sizeof(fmin));
+                    memcpy(&fmax, ((char*)minmax) + sizeof(fmin), sizeof(fmax));
+                    if (fmin >= fmax)
+                        break;
+                    ImagingSectionEnter(&cookie);
+                    scale = 255.0F / (fmax - fmin);
+                    for (y = 0; y < im->ysize; y++) {
+                        FLOAT32* in = (FLOAT32*) im->image32[y];
+                        for (x = 0; x < im->xsize; x++) {
+                            i = (int) (((*in++)-fmin)*scale);
+                            if (i >= 0 && i < 256)
+                                h->histogram[i]++;
+                        }
+                    }
+                    ImagingSectionLeave(&cookie);
+                    break;
             }
         }
     }

src/libImaging/ImPlatform.h

@@ -39,41 +39,41 @@
 /* For System that are not Windows, we'll need to define these. */
 
 #if SIZEOF_SHORT == 2
-#define	INT16 short
+#define INT16 short
 #elif SIZEOF_INT == 2
-#define	INT16 int
+#define INT16 int
 #else
-#define	INT16 short /* most things works just fine anyway... */
+#define INT16 short /* most things works just fine anyway... */
 #endif
 
 #if SIZEOF_SHORT == 4
-#define	INT32 short
+#define INT32 short
 #elif SIZEOF_INT == 4
-#define	INT32 int
+#define INT32 int
 #elif SIZEOF_LONG == 4
-#define	INT32 long
+#define INT32 long
 #else
 #error Cannot find required 32-bit integer type
 #endif
 
 #if SIZEOF_LONG == 8
-#define	INT64 long
+#define INT64 long
 #elif SIZEOF_LONG_LONG == 8
-#define	INT64 long
+#define INT64 long
 #endif
 
-#define	INT8  signed char
+#define INT8  signed char
-#define	UINT8 unsigned char
+#define UINT8 unsigned char
 
-#define	UINT16 unsigned INT16
+#define UINT16 unsigned INT16
-#define	UINT32 unsigned INT32
+#define UINT32 unsigned INT32
 
 #endif
 
 /* assume IEEE; tweak if necessary (patches are welcome) */
-#define	FLOAT16 UINT16
+#define FLOAT16 UINT16
-#define	FLOAT32 float
+#define FLOAT32 float
-#define	FLOAT64 double
+#define FLOAT64 double
 
 #ifdef _MSC_VER
 typedef signed __int64       int64_t;

src/libImaging/Jpeg.h

@@ -14,13 +14,13 @@
 
 
 typedef struct {
-    struct jpeg_error_mgr pub;	/* "public" fields */
+    struct jpeg_error_mgr pub;    /* "public" fields */
-    jmp_buf setjmp_buffer;	/* for return to caller */
+    jmp_buf setjmp_buffer;        /* for return to caller */
 } JPEGERROR;
 
 
 /* -------------------------------------------------------------------- */
-/* Decoder								*/
+/* Decoder                                                              */
 
 typedef struct {
     struct jpeg_source_mgr pub;
@@ -56,7 +56,7 @@ typedef struct {
 
 
 /* -------------------------------------------------------------------- */
-/* Encoder								*/
+/* Encoder                                                              */
 
 typedef struct {
     struct jpeg_destination_mgr pub;

src/libImaging/Jpeg2K.h

@@ -14,7 +14,7 @@
 #define BUFFER_SIZE OPJ_J2K_STREAM_CHUNK_SIZE
 
 /* -------------------------------------------------------------------- */
-/* Decoder								*/
+/* Decoder                                                              */
 /* -------------------------------------------------------------------- */
 
 typedef struct {
@@ -44,7 +44,7 @@ typedef struct {
 } JPEG2KDECODESTATE;
 
 /* -------------------------------------------------------------------- */
-/* Encoder								*/
+/* Encoder                                                              */
 /* -------------------------------------------------------------------- */
 
 typedef struct {

src/libImaging/JpegDecode.c

@@ -301,14 +301,14 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t by
 /* -------------------------------------------------------------------- */
 
 int ImagingJpegDecodeCleanup(ImagingCodecState state){
-	/* called to free the decompression engine when the decode terminates
+    /* called to free the decompression engine when the decode terminates
-	   due to a corrupt or truncated image
+       due to a corrupt or truncated image
-	*/
+    */
     JPEGSTATE* context = (JPEGSTATE*) state->context;
 
-	/* Clean up */
+    /* Clean up */
-	jpeg_destroy_decompress(&context->cinfo);
+    jpeg_destroy_decompress(&context->cinfo);
-	return -1;
+    return -1;
 }
 
 #endif

src/libImaging/JpegEncode.c

@@ -78,7 +78,7 @@ error(j_common_ptr cinfo)
 
 
 /* -------------------------------------------------------------------- */
-/* Encoder								*/
+/* Encoder                                                              */
 /* -------------------------------------------------------------------- */
 
 int
@@ -88,24 +88,24 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
     int ok;
 
     if (setjmp(context->error.setjmp_buffer)) {
-	/* JPEG error handler */
+        /* JPEG error handler */
-	jpeg_destroy_compress(&context->cinfo);
+        jpeg_destroy_compress(&context->cinfo);
-	state->errcode = IMAGING_CODEC_BROKEN;
+        state->errcode = IMAGING_CODEC_BROKEN;
-	return -1;
+        return -1;
     }
 
     if (!state->state) {
 
-	/* Setup compression context (very similar to the decoder) */
+        /* Setup compression context (very similar to the decoder) */
-	context->cinfo.err = jpeg_std_error(&context->error.pub);
+        context->cinfo.err = jpeg_std_error(&context->error.pub);
-	context->error.pub.error_exit = error;
+        context->error.pub.error_exit = error;
-	jpeg_create_compress(&context->cinfo);
+        jpeg_create_compress(&context->cinfo);
-	jpeg_buffer_dest(&context->cinfo, &context->destination);
+        jpeg_buffer_dest(&context->cinfo, &context->destination);
 
         context->extra_offset = 0;
 
-	/* Ready to encode */
+        /* Ready to encode */
-	state->state = 1;
+        state->state = 1;
 
     }
 
@@ -115,212 +115,212 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
 
     switch (state->state) {
 
-    case 1:
+        case 1:
 
-	context->cinfo.image_width = state->xsize;
+            context->cinfo.image_width = state->xsize;
-	context->cinfo.image_height = state->ysize;
+            context->cinfo.image_height = state->ysize;
 
-	switch (state->bits) {
+            switch (state->bits) {
-        case 8:
+                case 8:
-            context->cinfo.input_components = 1;
+                    context->cinfo.input_components = 1;
-            context->cinfo.in_color_space = JCS_GRAYSCALE;
+                    context->cinfo.in_color_space = JCS_GRAYSCALE;
-            break;
+                    break;
-        case 24:
+                case 24:
-            context->cinfo.input_components = 3;
+                    context->cinfo.input_components = 3;
-            if (strcmp(im->mode, "YCbCr") == 0)
+                    if (strcmp(im->mode, "YCbCr") == 0)
-                context->cinfo.in_color_space = JCS_YCbCr;
+                        context->cinfo.in_color_space = JCS_YCbCr;
-            else
+                    else
-                context->cinfo.in_color_space = JCS_RGB;
+                        context->cinfo.in_color_space = JCS_RGB;
-            break;
+                    break;
-        case 32:
+                case 32:
-            context->cinfo.input_components = 4;
+                    context->cinfo.input_components = 4;
-            context->cinfo.in_color_space = JCS_CMYK;
+                    context->cinfo.in_color_space = JCS_CMYK;
-        #ifdef JCS_EXTENSIONS
+                #ifdef JCS_EXTENSIONS
-            if (strcmp(context->rawmode, "RGBX") == 0)
+                    if (strcmp(context->rawmode, "RGBX") == 0)
-                context->cinfo.in_color_space = JCS_EXT_RGBX;
+                        context->cinfo.in_color_space = JCS_EXT_RGBX;
-        #endif
+                #endif
-            break;
+                    break;
-        default:
+                default:
-            state->errcode = IMAGING_CODEC_CONFIG;
+                    state->errcode = IMAGING_CODEC_CONFIG;
-            return -1;
+                    return -1;
-	}
+            }
 
-	/* Compressor configuration */
+            /* Compressor configuration */
-	jpeg_set_defaults(&context->cinfo);
+            jpeg_set_defaults(&context->cinfo);
 
-	/* Use custom quantization tables */
+            /* Use custom quantization tables */
-	if (context->qtables) {
+            if (context->qtables) {
-	    int i;
+                int i;
-	    int quality = 100;
+                int quality = 100;
-	    int last_q = 0;
+                int last_q = 0;
-	    if (context->quality != -1) {
+                if (context->quality != -1) {
-		quality = context->quality;
+                    quality = context->quality;
-	    }
+                }
-        for (i = 0; i < context->qtablesLen; i++) {
+                for (i = 0; i < context->qtablesLen; i++) {
-            // TODO: Should add support for none baseline
+                    // TODO: Should add support for none baseline
-            jpeg_add_quant_table(&context->cinfo, i, &context->qtables[i * DCTSIZE2],
+                    jpeg_add_quant_table(&context->cinfo, i, &context->qtables[i * DCTSIZE2],
-                                 quality, TRUE);
+                                         quality, TRUE);
-            context->cinfo.comp_info[i].quant_tbl_no = i;
+                    context->cinfo.comp_info[i].quant_tbl_no = i;
-            last_q = i;
+                    last_q = i;
-        }
+                }
-        if (context->qtablesLen == 1) {
+                if (context->qtablesLen == 1) {
-            // jpeg_set_defaults created two qtables internally, but we only wanted one.
+                    // jpeg_set_defaults created two qtables internally, but we only wanted one.
-            jpeg_add_quant_table(&context->cinfo, 1, &context->qtables[0],
+                    jpeg_add_quant_table(&context->cinfo, 1, &context->qtables[0],
-                                 quality, TRUE);
+                                         quality, TRUE);
-        }
+                }
-        for (i = last_q; i < context->cinfo.num_components; i++) {
+                for (i = last_q; i < context->cinfo.num_components; i++) {
-            context->cinfo.comp_info[i].quant_tbl_no = last_q;
+                    context->cinfo.comp_info[i].quant_tbl_no = last_q;
-        }
+                }
-	} else if (context->quality != -1) {
+            } else if (context->quality != -1) {
-	    jpeg_set_quality(&context->cinfo, context->quality, 1);
+                jpeg_set_quality(&context->cinfo, context->quality, 1);
-	}
+            }
 
-	/* Set subsampling options */
+            /* Set subsampling options */
-	switch (context->subsampling)
+            switch (context->subsampling)
-	    {
+                {
-	    case 0:  /* 1x1 1x1 1x1 (4:4:4) : None */
+                case 0:  /* 1x1 1x1 1x1 (4:4:4) : None */
-		{
+                {
-		    context->cinfo.comp_info[0].h_samp_factor = 1;
+                    context->cinfo.comp_info[0].h_samp_factor = 1;
-		    context->cinfo.comp_info[0].v_samp_factor = 1;
+                    context->cinfo.comp_info[0].v_samp_factor = 1;
-		    context->cinfo.comp_info[1].h_samp_factor = 1;
+                    context->cinfo.comp_info[1].h_samp_factor = 1;
-		    context->cinfo.comp_info[1].v_samp_factor = 1;
+                    context->cinfo.comp_info[1].v_samp_factor = 1;
-		    context->cinfo.comp_info[2].h_samp_factor = 1;
+                    context->cinfo.comp_info[2].h_samp_factor = 1;
-		    context->cinfo.comp_info[2].v_samp_factor = 1;
+                    context->cinfo.comp_info[2].v_samp_factor = 1;
-		    break;
+                    break;
-		}
+                }
-	    case 1:  /* 2x1, 1x1, 1x1 (4:2:2) : Medium */
+                case 1:  /* 2x1, 1x1, 1x1 (4:2:2) : Medium */
-		{
+                {
-		    context->cinfo.comp_info[0].h_samp_factor = 2;
+                    context->cinfo.comp_info[0].h_samp_factor = 2;
-		    context->cinfo.comp_info[0].v_samp_factor = 1;
+                    context->cinfo.comp_info[0].v_samp_factor = 1;
-		    context->cinfo.comp_info[1].h_samp_factor = 1;
+                    context->cinfo.comp_info[1].h_samp_factor = 1;
-		    context->cinfo.comp_info[1].v_samp_factor = 1;
+                    context->cinfo.comp_info[1].v_samp_factor = 1;
-		    context->cinfo.comp_info[2].h_samp_factor = 1;
+                    context->cinfo.comp_info[2].h_samp_factor = 1;
-		    context->cinfo.comp_info[2].v_samp_factor = 1;
+                    context->cinfo.comp_info[2].v_samp_factor = 1;
-		    break;
+                    break;
-		}
+                }
-	    case 2:  /* 2x2, 1x1, 1x1 (4:2:0) : High */
+                case 2:  /* 2x2, 1x1, 1x1 (4:2:0) : High */
-		{
+                {
-		    context->cinfo.comp_info[0].h_samp_factor = 2;
+                    context->cinfo.comp_info[0].h_samp_factor = 2;
-		    context->cinfo.comp_info[0].v_samp_factor = 2;
+                    context->cinfo.comp_info[0].v_samp_factor = 2;
-		    context->cinfo.comp_info[1].h_samp_factor = 1;
+                    context->cinfo.comp_info[1].h_samp_factor = 1;
-		    context->cinfo.comp_info[1].v_samp_factor = 1;
+                    context->cinfo.comp_info[1].v_samp_factor = 1;
-		    context->cinfo.comp_info[2].h_samp_factor = 1;
+                    context->cinfo.comp_info[2].h_samp_factor = 1;
-		    context->cinfo.comp_info[2].v_samp_factor = 1;
+                    context->cinfo.comp_info[2].v_samp_factor = 1;
-		    break;
+                    break;
-		}
+                }
-	    default:
+                default:
-		{
+                {
-		    /* Use the lib's default */
+                    /* Use the lib's default */
-		    break;
+                    break;
-		}
+                }
-	    }
+                }
-	if (context->progressive)
+            if (context->progressive)
-	    jpeg_simple_progression(&context->cinfo);
+                jpeg_simple_progression(&context->cinfo);
-	context->cinfo.smoothing_factor = context->smooth;
+                context->cinfo.smoothing_factor = context->smooth;
-	context->cinfo.optimize_coding = (boolean) context->optimize;
+                context->cinfo.optimize_coding = (boolean) context->optimize;
-        if (context->xdpi > 0 && context->ydpi > 0) {
+                if (context->xdpi > 0 && context->ydpi > 0) {
-            context->cinfo.density_unit = 1; /* dots per inch */
+                    context->cinfo.density_unit = 1; /* dots per inch */
-            context->cinfo.X_density = context->xdpi;
+                    context->cinfo.X_density = context->xdpi;
-            context->cinfo.Y_density = context->ydpi;
+                    context->cinfo.Y_density = context->ydpi;
-        }
+                }
-	switch (context->streamtype) {
+            switch (context->streamtype) {
-	case 1:
+                case 1:
-	    /* tables only -- not yet implemented */
+                    /* tables only -- not yet implemented */
-	    state->errcode = IMAGING_CODEC_CONFIG;
+                    state->errcode = IMAGING_CODEC_CONFIG;
-	    return -1;
+                    return -1;
-	case 2:
+                case 2:
-	    /* image only */
+                    /* image only */
-	    jpeg_suppress_tables(&context->cinfo, TRUE);
+                    jpeg_suppress_tables(&context->cinfo, TRUE);
-	    jpeg_start_compress(&context->cinfo, FALSE);
+                    jpeg_start_compress(&context->cinfo, FALSE);
-            /* suppress extra section */
+                    /* suppress extra section */
-            context->extra_offset = context->extra_size;
+                    context->extra_offset = context->extra_size;
-	    break;
+                    break;
-	default:
+                default:
-	    /* interchange stream */
+                    /* interchange stream */
-	    jpeg_start_compress(&context->cinfo, TRUE);
+                    jpeg_start_compress(&context->cinfo, TRUE);
-	    break;
+                    break;
-	}
+            }
-	state->state++;
+            state->state++;
-	/* fall through */
+            /* fall through */
 
-    case 2:
+        case 2:
-        // check for exif len + 'APP1' header bytes
+            // check for exif len + 'APP1' header bytes
-        if (context->rawExifLen + 5 >  context->destination.pub.free_in_buffer){
+            if (context->rawExifLen + 5 >  context->destination.pub.free_in_buffer){
-            break;
-        }
-        //add exif header
-        if (context->rawExifLen > 0){
-            jpeg_write_marker(&context->cinfo, JPEG_APP0+1,
-                              (unsigned char*)context->rawExif, context->rawExifLen);
-        }
-
-	state->state++;
-	/* fall through */
-    case 3:
-
-        if (context->extra) {
-            /* copy extra buffer to output buffer */
-            unsigned int n = context->extra_size - context->extra_offset;
-            if (n > context->destination.pub.free_in_buffer)
-                n = context->destination.pub.free_in_buffer;
-            memcpy(context->destination.pub.next_output_byte,
-                   context->extra + context->extra_offset, n);
-            context->destination.pub.next_output_byte += n;
-            context->destination.pub.free_in_buffer -= n;
-            context->extra_offset += n;
-            if (context->extra_offset >= context->extra_size)
-                state->state++;
-            else
                 break;
-        } else
+            }
-	    state->state++;
+            //add exif header
+            if (context->rawExifLen > 0){
+                jpeg_write_marker(&context->cinfo, JPEG_APP0+1,
+                                  (unsigned char*)context->rawExif, context->rawExifLen);
+            }
 
-    case 4:
+            state->state++;
-        if (1024 > context->destination.pub.free_in_buffer){
+            /* fall through */
+        case 3:
+
+            if (context->extra) {
+                /* copy extra buffer to output buffer */
+                unsigned int n = context->extra_size - context->extra_offset;
+                if (n > context->destination.pub.free_in_buffer)
+                    n = context->destination.pub.free_in_buffer;
+                memcpy(context->destination.pub.next_output_byte,
+                       context->extra + context->extra_offset, n);
+                context->destination.pub.next_output_byte += n;
+                context->destination.pub.free_in_buffer -= n;
+                context->extra_offset += n;
+                if (context->extra_offset >= context->extra_size)
+                    state->state++;
+                else
+                    break;
+            } else
+                state->state++;
+
+        case 4:
+            if (1024 > context->destination.pub.free_in_buffer){
+                break;
+            }
+
+            ok = 1;
+            while (state->y < state->ysize) {
+                state->shuffle(state->buffer,
+                       (UINT8*) im->image[state->y + state->yoff] +
+                       state->xoff * im->pixelsize, state->xsize);
+                ok = jpeg_write_scanlines(&context->cinfo, &state->buffer, 1);
+                if (ok != 1)
+                    break;
+                state->y++;
+            }
+
+            if (ok != 1)
+                break;
+            state->state++;
+            /* fall through */
+
+        case 5:
+
+            /* Finish compression */
+            if (context->destination.pub.free_in_buffer < 100)
+                break;
+            jpeg_finish_compress(&context->cinfo);
+
+            /* Clean up */
+            if (context->extra) {
+                free(context->extra);
+                context->extra = NULL;
+            }
+            if (context->rawExif) {
+                free(context->rawExif);
+                context->rawExif = NULL;
+            }
+            if (context->qtables) {
+                free(context->qtables);
+                context->qtables = NULL;
+            }
+
+            jpeg_destroy_compress(&context->cinfo);
+            /* if (jerr.pub.num_warnings) return BROKEN; */
+            state->errcode = IMAGING_CODEC_END;
             break;
-        }
-
-	ok = 1;
-	while (state->y < state->ysize) {
-	    state->shuffle(state->buffer,
-			   (UINT8*) im->image[state->y + state->yoff] +
-			   state->xoff * im->pixelsize, state->xsize);
-	    ok = jpeg_write_scanlines(&context->cinfo, &state->buffer, 1);
-	    if (ok != 1)
-		break;
-	    state->y++;
-	}
-
-	if (ok != 1)
-	    break;
-	state->state++;
-	/* fall through */
-
-    case 5:
-
-	/* Finish compression */
-	if (context->destination.pub.free_in_buffer < 100)
-	    break;
-	jpeg_finish_compress(&context->cinfo);
-
-	/* Clean up */
-        if (context->extra) {
-            free(context->extra);
-            context->extra = NULL;
-        }
-        if (context->rawExif) {
-            free(context->rawExif);
-            context->rawExif = NULL;
-        }
-        if (context->qtables) {
-            free(context->qtables);
-            context->qtables = NULL;
-        }
-
-	jpeg_destroy_compress(&context->cinfo);
-	/* if (jerr.pub.num_warnings) return BROKEN; */
-	state->errcode = IMAGING_CODEC_END;
-	break;
 
     }
 

src/libImaging/Matrix.c

@@ -17,7 +17,7 @@
 #include "Imaging.h"
 
 
-#define	CLIPF(v) ((v <= 0.0) ? 0 : (v >= 255.0F) ? 255 : (UINT8) v)
+#define CLIPF(v) ((v <= 0.0) ? 0 : (v >= 255.0F) ? 255 : (UINT8) v)
 
 
 Imaging
@@ -28,47 +28,47 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[])
 
     /* Assume there's enough data in the buffer */
     if (!im)
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     if (strcmp(mode, "L") == 0 && im->bands == 3) {
 
-	imOut = ImagingNewDirty("L", im->xsize, im->ysize);
+        imOut = ImagingNewDirty("L", im->xsize, im->ysize);
-	if (!imOut)
+        if (!imOut)
-	    return NULL;
+            return NULL;
 
-	for (y = 0; y < im->ysize; y++) {
+        for (y = 0; y < im->ysize; y++) {
-	    UINT8* in = (UINT8*) im->image[y];
+            UINT8* in = (UINT8*) im->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
 
-	    for (x = 0; x < im->xsize; x++) {
+            for (x = 0; x < im->xsize; x++) {
-		float v = m[0]*in[0] + m[1]*in[1] + m[2]*in[2] + m[3] + 0.5;
+                float v = m[0]*in[0] + m[1]*in[1] + m[2]*in[2] + m[3] + 0.5;
-		out[x] = CLIPF(v);
+                out[x] = CLIPF(v);
-		in += 4;
+                in += 4;
-	    }
+            }
-	}
+        }
 
     } else if (strlen(mode) == 3 && im->bands == 3) {
 
-	imOut = ImagingNewDirty(mode, im->xsize, im->ysize);
+        imOut = ImagingNewDirty(mode, im->xsize, im->ysize);
-	if (!imOut)
+        if (!imOut)
-	    return NULL;
+            return NULL;
 
-	for (y = 0; y < im->ysize; y++) {
+        for (y = 0; y < im->ysize; y++) {
-	    UINT8* in = (UINT8*) im->image[y];
+            UINT8* in = (UINT8*) im->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
 
-	    for (x = 0; x < im->xsize; x++) {
+            for (x = 0; x < im->xsize; x++) {
-		float v0 = m[0]*in[0] + m[1]*in[1] +  m[2]*in[2] +  m[3] + 0.5;
+                float v0 = m[0]*in[0] + m[1]*in[1] +  m[2]*in[2] +  m[3] + 0.5;
-		float v1 = m[4]*in[0] + m[5]*in[1] +  m[6]*in[2] +  m[7] + 0.5;
+                float v1 = m[4]*in[0] + m[5]*in[1] +  m[6]*in[2] +  m[7] + 0.5;
-		float v2 = m[8]*in[0] + m[9]*in[1] + m[10]*in[2] + m[11] + 0.5;
+                float v2 = m[8]*in[0] + m[9]*in[1] + m[10]*in[2] + m[11] + 0.5;
-		out[0] = CLIPF(v0);
+                out[0] = CLIPF(v0);
-		out[1] = CLIPF(v1);
+                out[1] = CLIPF(v1);
-		out[2] = CLIPF(v2);
+                out[2] = CLIPF(v2);
-		in += 4; out += 4;
+                in += 4; out += 4;
-	    }
+            }
-	}
+        }
     } else
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     return imOut;
 }

src/libImaging/Negative.c

@@ -8,7 +8,7 @@
  *      FIXME: Maybe this should be implemented using ImagingPoint()
  *
  * history:
- *	95-11-27 fl:	Created
+ * 95-11-27 fl: Created
  *
  * Copyright (c) Fredrik Lundh 1995.
  * Copyright (c) Secret Labs AB 1997.
@@ -27,15 +27,15 @@ ImagingNegative(Imaging im)
     int x, y;
 
     if (!im)
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize);
     if (!imOut)
-	return NULL;
+        return NULL;
 
     for (y = 0; y < im->ysize; y++)
-	for (x = 0; x < im->linesize; x++)
+        for (x = 0; x < im->linesize; x++)
-	     imOut->image[y][x] = ~im->image[y][x];
+            imOut->image[y][x] = ~im->image[y][x];
 
     return imOut;
 }

src/libImaging/Offset.c

@@ -5,7 +5,7 @@
  * offset an image in x and y directions
  *
  * history:
- * 96-07-22 fl:	Created
+ * 96-07-22 fl: Created
  * 98-11-01 cgw@pgt.com: Fixed negative-array index bug
  *
  * Copyright (c) Fredrik Lundh 1996.
@@ -25,11 +25,11 @@ ImagingOffset(Imaging im, int xoffset, int yoffset)
     Imaging imOut;
 
     if (!im)
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize);
     if (!imOut)
-	return NULL;
+        return NULL;
 
     ImagingCopyPalette(imOut, im);
 
@@ -37,25 +37,25 @@ ImagingOffset(Imaging im, int xoffset, int yoffset)
     xoffset %= im->xsize;
     xoffset = im->xsize - xoffset;
     if (xoffset < 0)
-	xoffset += im->xsize;
+        xoffset += im->xsize;
 
     yoffset %= im->ysize;
     yoffset = im->ysize - yoffset;
     if (yoffset < 0)
-	yoffset += im->ysize;
+        yoffset += im->ysize;
 
-#define	OFFSET(image)\
+#define OFFSET(image)\
     for (y = 0; y < im->ysize; y++)\
-	for (x = 0; x < im->xsize; x++) {\
+        for (x = 0; x < im->xsize; x++) {\
-	    int yi = (y + yoffset) % im->ysize;\
+            int yi = (y + yoffset) % im->ysize;\
-	    int xi = (x + xoffset) % im->xsize;\
+            int xi = (x + xoffset) % im->xsize;\
-	    imOut->image[y][x] = im->image[yi][xi];\
+            imOut->image[y][x] = im->image[yi][xi];\
-	}
+    }
 
     if (im->image8)
-	OFFSET(image8)
+        OFFSET(image8)
     else
-	OFFSET(image32)
+        OFFSET(image32)
 
     return imOut;
 }

src/libImaging/PackDecode.c

@@ -5,7 +5,7 @@
  * decoder for PackBits image data.
  *
  * history:
- *	96-04-19 fl	Created
+ * 96-04-19 fl Created
  *
  * Copyright (c) Fredrik Lundh 1996.
  * Copyright (c) Secret Labs AB 1997.
@@ -18,7 +18,7 @@
 
 int
 ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
-		      UINT8* buf, Py_ssize_t bytes)
+              UINT8* buf, Py_ssize_t bytes)
 {
     UINT8 n;
     UINT8* ptr;
@@ -28,65 +28,65 @@ ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
 
     for (;;) {
 
-	if (bytes < 1)
+        if (bytes < 1)
-	    return ptr - buf;
+            return ptr - buf;
 
-	if (ptr[0] & 0x80) {
+        if (ptr[0] & 0x80) {
 
-	    if (ptr[0] == 0x80) {
+            if (ptr[0] == 0x80) {
-		/* Nop */
+                /* Nop */
-		ptr++; bytes--;
+                ptr++; bytes--;
-		continue;
+                continue;
-	    }
+            }
 
-	    /* Run */
+            /* Run */
-	    if (bytes < 2)
+            if (bytes < 2)
-		return ptr - buf;
+                return ptr - buf;
 
-	    for (n = 257 - ptr[0]; n > 0; n--) {
+            for (n = 257 - ptr[0]; n > 0; n--) {
-		if (state->x >= state->bytes) {
+                if (state->x >= state->bytes) {
-		    /* state->errcode = IMAGING_CODEC_OVERRUN; */
+                    /* state->errcode = IMAGING_CODEC_OVERRUN; */
-		    break;
+                    break;
-		}
+                }
-		state->buffer[state->x++] = ptr[1];
+                state->buffer[state->x++] = ptr[1];
-	    }
+            }
 
-	    ptr += 2; bytes -= 2;
+            ptr += 2; bytes -= 2;
 
-	} else {
+        } else {
 
-	    /* Literal */
+            /* Literal */
-	    n = ptr[0]+2;
+            n = ptr[0]+2;
 
-	    if (bytes < n)
+            if (bytes < n)
-		return ptr - buf;
+                return ptr - buf;
 
-	    for (i = 1; i < n; i++) {
+            for (i = 1; i < n; i++) {
-		if (state->x >= state->bytes) {
+                if (state->x >= state->bytes) {
-		    /* state->errcode = IMAGING_CODEC_OVERRUN; */
+                    /* state->errcode = IMAGING_CODEC_OVERRUN; */
-		    break;
+                    break;
-		}
+                }
-		state->buffer[state->x++] = ptr[i];
+                state->buffer[state->x++] = ptr[i];
-	    }
+            }
 
-	    ptr += n; bytes -= n;
+            ptr += n; bytes -= n;
 
-	}
+        }
 
-	if (state->x >= state->bytes) {
+        if (state->x >= state->bytes) {
 
-	    /* Got a full line, unpack it */
+            /* Got a full line, unpack it */
-	    state->shuffle((UINT8*) im->image[state->y + state->yoff] +
+            state->shuffle((UINT8*) im->image[state->y + state->yoff] +
-			   state->xoff * im->pixelsize, state->buffer,
+                   state->xoff * im->pixelsize, state->buffer,
-			   state->xsize);
+                   state->xsize);
 
-	    state->x = 0;
+            state->x = 0;
 
-	    if (++state->y >= state->ysize) {
+            if (++state->y >= state->ysize) {
-		/* End of file (errcode = 0) */
+                /* End of file (errcode = 0) */
-		return -1;
+                return -1;
-	    }
+            }
-	}
+        }
 
     }
 }

src/libImaging/PcdDecode.c

@@ -5,13 +5,13 @@
  * decoder for uncompressed PCD image data.
  *
  * history:
- *	96-05-10 fl	Created
+ * 96-05-10 fl Created
- *	96-05-18 fl	New tables
+ * 96-05-18 fl New tables
- *	97-01-25 fl	Use PhotoYCC unpacker
+ * 97-01-25 fl Use PhotoYCC unpacker
  *
  * notes:
- *	This driver supports uncompressed PCD modes only
+ * This driver supports uncompressed PCD modes only
- *	(resolutions up to 768x512).
+ * (resolutions up to 768x512).
  *
  * Copyright (c) Fredrik Lundh 1996-97.
  * Copyright (c) Secret Labs AB 1997.
@@ -37,42 +37,42 @@ ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     for (;;) {
 
-	/* We need data for two full lines before we can do anything */
+        /* We need data for two full lines before we can do anything */
-	if (bytes < chunk)
+        if (bytes < chunk)
-	    return ptr - buf;
+            return ptr - buf;
 
-	/* Unpack first line */
+        /* Unpack first line */
-	out = state->buffer;
+        out = state->buffer;
-	for (x = 0; x < state->xsize; x++) {
+        for (x = 0; x < state->xsize; x++) {
-	    out[0] = ptr[x];
+            out[0] = ptr[x];
-	    out[1] = ptr[(x+4*state->xsize)/2];
+            out[1] = ptr[(x+4*state->xsize)/2];
-	    out[2] = ptr[(x+5*state->xsize)/2];
+            out[2] = ptr[(x+5*state->xsize)/2];
-	    out += 3;
+            out += 3;
-	}
+        }
 
-	state->shuffle((UINT8*) im->image[state->y],
+        state->shuffle((UINT8*) im->image[state->y],
-		       state->buffer, state->xsize);
+                   state->buffer, state->xsize);
 
-	if (++state->y >= state->ysize)
+        if (++state->y >= state->ysize)
-	    return -1; /* This can hardly happen */
+            return -1; /* This can hardly happen */
 
-	/* Unpack second line */
+        /* Unpack second line */
-	out = state->buffer;
+        out = state->buffer;
-	for (x = 0; x < state->xsize; x++) {
+        for (x = 0; x < state->xsize; x++) {
-	    out[0] = ptr[x+state->xsize];
+            out[0] = ptr[x+state->xsize];
-	    out[1] = ptr[(x+4*state->xsize)/2];
+            out[1] = ptr[(x+4*state->xsize)/2];
-	    out[2] = ptr[(x+5*state->xsize)/2];
+            out[2] = ptr[(x+5*state->xsize)/2];
-	    out += 3;
+            out += 3;
-	}
+        }
 
-	state->shuffle((UINT8*) im->image[state->y],
+        state->shuffle((UINT8*) im->image[state->y],
-		       state->buffer, state->xsize);
+                   state->buffer, state->xsize);
 
-	if (++state->y >= state->ysize)
+        if (++state->y >= state->ysize)
-	    return -1;
+            return -1;
 
-	ptr += chunk;
+        ptr += chunk;
-	bytes -= chunk;
+        bytes -= chunk;
 
     }
 }

src/libImaging/PcxDecode.c

@@ -5,7 +5,7 @@
  * decoder for PCX image data.
  *
  * history:
- *	95-09-14 fl	Created
+ * 95-09-14 fl Created
  *
  * Copyright (c) Fredrik Lundh 1995.
  * Copyright (c) Secret Labs AB 1997.
@@ -31,59 +31,59 @@ ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     for (;;) {
 
-	if (bytes < 1)
+        if (bytes < 1)
-	    return ptr - buf;
+            return ptr - buf;
 
-	if ((*ptr & 0xC0) == 0xC0) {
+        if ((*ptr & 0xC0) == 0xC0) {
 
-	    /* Run */
+            /* Run */
-	    if (bytes < 2)
+            if (bytes < 2)
-		return ptr - buf;
+                return ptr - buf;
 
-	    n = ptr[0] & 0x3F;
+            n = ptr[0] & 0x3F;
 
-	    while (n > 0) {
+            while (n > 0) {
-		if (state->x >= state->bytes) {
+                if (state->x >= state->bytes) {
-		    state->errcode = IMAGING_CODEC_OVERRUN;
+                    state->errcode = IMAGING_CODEC_OVERRUN;
-		    break;
+                    break;
-		}
+                }
-		state->buffer[state->x++] = ptr[1];
+                state->buffer[state->x++] = ptr[1];
-		n--;
+                n--;
-	    }
+            }
 
-	    ptr += 2; bytes -= 2;
+            ptr += 2; bytes -= 2;
 
-	} else {
+        } else {
 
-	    /* Literal */
+            /* Literal */
-	    state->buffer[state->x++] = ptr[0];
+            state->buffer[state->x++] = ptr[0];
-	    ptr++; bytes--;
+            ptr++; bytes--;
 
-	}
+        }
 
-	if (state->x >= state->bytes) {
+        if (state->x >= state->bytes) {
-        if (state->bytes % state->xsize && state->bytes > state->xsize) {
+            if (state->bytes % state->xsize && state->bytes > state->xsize) {
-            int bands = state->bytes / state->xsize;
+                int bands = state->bytes / state->xsize;
-            int stride = state->bytes / bands;
+                int stride = state->bytes / bands;
-            int i;
+                int i;
-            for (i=1; i< bands; i++) {  // note -- skipping first band
+                for (i=1; i< bands; i++) {  // note -- skipping first band
-                memmove(&state->buffer[i*state->xsize],
+                    memmove(&state->buffer[i*state->xsize],
-                        &state->buffer[i*stride],
+                            &state->buffer[i*stride],
-                        state->xsize);
+                            state->xsize);
+                }
+            }
+            /* Got a full line, unpack it */
+            state->shuffle((UINT8*) im->image[state->y + state->yoff] +
+                   state->xoff * im->pixelsize, state->buffer,
+                   state->xsize);
+
+            state->x = 0;
+
+            if (++state->y >= state->ysize) {
+                /* End of file (errcode = 0) */
+                return -1;
             }
         }
-	    /* Got a full line, unpack it */
-	    state->shuffle((UINT8*) im->image[state->y + state->yoff] +
-			   state->xoff * im->pixelsize, state->buffer,
-			   state->xsize);
-
-	    state->x = 0;
-
-	    if (++state->y >= state->ysize) {
-		/* End of file (errcode = 0) */
-		return -1;
-	    }
-	}
 
     }
 }

src/libImaging/Point.c

@@ -139,7 +139,7 @@ ImagingPoint(Imaging imIn, const char* mode, const void* table)
     void (*point)(Imaging imIn, Imaging imOut, im_point_context* context);
 
     if (!imIn)
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     if (!mode)
         mode = imIn->mode;
@@ -152,7 +152,7 @@ ImagingPoint(Imaging imIn, const char* mode, const void* table)
 
     imOut = ImagingNew(mode, imIn->xsize, imIn->ysize);
     if (!imOut)
-	return NULL;
+        return NULL;
 
     /* find appropriate handler */
     if (imIn->type == IMAGING_TYPE_UINT8) {
@@ -210,11 +210,11 @@ ImagingPointTransform(Imaging imIn, double scale, double offset)
     if (!imIn || (strcmp(imIn->mode, "I") != 0 &&
                   strcmp(imIn->mode, "I;16") != 0 &&
                   strcmp(imIn->mode, "F") != 0))
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     imOut = ImagingNew(imIn->mode, imIn->xsize, imIn->ysize);
     if (!imOut)
-	return NULL;
+        return NULL;
 
     switch (imIn->type) {
     case IMAGING_TYPE_INT32:
@@ -254,7 +254,7 @@ ImagingPointTransform(Imaging imIn, double scale, double offset)
             }
             ImagingSectionLeave(&cookie);
             break;
-	}
+        }
         /* FALL THROUGH */
     default:
         ImagingDelete(imOut);

src/libImaging/RawDecode.c

@@ -5,7 +5,7 @@
  * decoder for raw (uncompressed) image data
  *
  * history:
- *	96-03-07 fl	rewritten
+ * 96-03-07 fl rewritten
  *
  * Copyright (c) Fredrik Lundh 1996.
  * Copyright (c) Secret Labs AB 1997.
@@ -29,28 +29,28 @@ ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     if (state->state == 0) {
 
-	/* Initialize context variables */
+        /* Initialize context variables */
 
-	/* get size of image data and padding */
+        /* get size of image data and padding */
-	state->bytes = (state->xsize * state->bits + 7) / 8;
+        state->bytes = (state->xsize * state->bits + 7) / 8;
-	if (rawstate->stride) {
+        if (rawstate->stride) {
-	    rawstate->skip = rawstate->stride - state->bytes;
+            rawstate->skip = rawstate->stride - state->bytes;
-	    if (rawstate->skip < 0) {
+            if (rawstate->skip < 0) {
-	        state->errcode = IMAGING_CODEC_CONFIG;
+                state->errcode = IMAGING_CODEC_CONFIG;
-	        return -1;
+                return -1;
-	    }
+            }
-	} else {
+        } else {
-	    rawstate->skip = 0;
+            rawstate->skip = 0;
-	}
+        }
 
-	/* check image orientation */
+        /* check image orientation */
-	if (state->ystep < 0) {
+        if (state->ystep < 0) {
-	    state->y = state->ysize-1;
+            state->y = state->ysize-1;
-	    state->ystep = -1;
+            state->ystep = -1;
-	} else
+        } else
-	    state->ystep = 1;
+            state->ystep = 1;
 
-	state->state = LINE;
+        state->state = LINE;
 
     }
 
@@ -58,38 +58,38 @@ ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
 
     for (;;) {
 
-	if (state->state == SKIP) {
+        if (state->state == SKIP) {
 
-	    /* Skip padding between lines */
+            /* Skip padding between lines */
 
-	    if (bytes < rawstate->skip)
+            if (bytes < rawstate->skip)
-		return ptr - buf;
+                return ptr - buf;
 
-	    ptr += rawstate->skip;
+            ptr += rawstate->skip;
-	    bytes -= rawstate->skip;
+            bytes -= rawstate->skip;
 
-	    state->state = LINE;
+            state->state = LINE;
 
-	}
+        }
 
-	if (bytes < state->bytes)
+        if (bytes < state->bytes)
-	    return ptr - buf;
+            return ptr - buf;
 
-	/* Unpack data */
+        /* Unpack data */
-	state->shuffle((UINT8*) im->image[state->y + state->yoff] +
+        state->shuffle((UINT8*) im->image[state->y + state->yoff] +
-		       state->xoff * im->pixelsize, ptr, state->xsize);
+                   state->xoff * im->pixelsize, ptr, state->xsize);
 
-	ptr += state->bytes;
+        ptr += state->bytes;
-	bytes -= state->bytes;
+        bytes -= state->bytes;
 
-	state->y += state->ystep;
+        state->y += state->ystep;
 
-	if (state->y < 0 || state->y >= state->ysize) {
+        if (state->y < 0 || state->y >= state->ysize) {
-	    /* End of file (errcode = 0) */
+            /* End of file (errcode = 0) */
-	    return -1;
+            return -1;
-	}
+        }
 
-	state->state = SKIP;
+        state->state = SKIP;
 
     }
 

src/libImaging/RawEncode.c

@@ -9,8 +9,8 @@
  * in ImageFile.py, but it should be solved here instead.
  *
  * history:
- * 96-04-30 fl	created
+ * 96-04-30 fl created
- * 97-01-03 fl	fixed padding
+ * 97-01-03 fl fixed padding
  *
  * Copyright (c) Fredrik Lundh 1996-97.
  * Copyright (c) Secret Labs AB 1997.
@@ -27,60 +27,60 @@ ImagingRawEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
 
     if (!state->state) {
 
-	/* The "count" field holds the stride, if specified.  Fix
+        /* The "count" field holds the stride, if specified.  Fix
-	   things up so "bytes" is the full size, and "count" the
+           things up so "bytes" is the full size, and "count" the
-	   packed size */
+           packed size */
 
-	if (state->count > 0) {
+        if (state->count > 0) {
-	    int bytes = state->count;
+            int bytes = state->count;
 
-	    /* stride must not be less than real size */
+            /* stride must not be less than real size */
-	    if (state->count < state->bytes) {
+            if (state->count < state->bytes) {
-		state->errcode = IMAGING_CODEC_CONFIG;
+                state->errcode = IMAGING_CODEC_CONFIG;
-		return -1;
+                return -1;
-	    }
+            }
-	    state->count = state->bytes;
+            state->count = state->bytes;
-	    state->bytes = bytes;
+            state->bytes = bytes;
-	} else
+        } else
-	    state->count = state->bytes;
+            state->count = state->bytes;
 
-	/* The "ystep" field specifies the orientation */
+        /* The "ystep" field specifies the orientation */
 
-	if (state->ystep < 0) {
+        if (state->ystep < 0) {
-	    state->y = state->ysize-1;
+            state->y = state->ysize-1;
-	    state->ystep = -1;
+            state->ystep = -1;
-	} else
+        } else
-	    state->ystep = 1;
+            state->ystep = 1;
 
-	state->state = 1;
+        state->state = 1;
 
     }
 
     if (bytes < state->bytes) {
-	state->errcode = IMAGING_CODEC_CONFIG;
+        state->errcode = IMAGING_CODEC_CONFIG;
-	return 0;
+        return 0;
     }
 
     ptr = buf;
 
     while (bytes >= state->bytes) {
 
-	state->shuffle(ptr, (UINT8*) im->image[state->y + state->yoff] +
+        state->shuffle(ptr, (UINT8*) im->image[state->y + state->yoff] +
-		       state->xoff * im->pixelsize, state->xsize);
+                   state->xoff * im->pixelsize, state->xsize);
 
-	if (state->bytes > state->count)
+        if (state->bytes > state->count)
-	    /* zero-pad the buffer, if necessary */
+            /* zero-pad the buffer, if necessary */
-	    memset(ptr + state->count, 0, state->bytes - state->count);
+            memset(ptr + state->count, 0, state->bytes - state->count);
 
-	ptr += state->bytes;
+        ptr += state->bytes;
-	bytes -= state->bytes;
+        bytes -= state->bytes;
 
-	state->y += state->ystep;
+        state->y += state->ystep;
 
-	if (state->y < 0 || state->y >= state->ysize) {
+        if (state->y < 0 || state->y >= state->ysize) {
-	    state->errcode = IMAGING_CODEC_END;
+            state->errcode = IMAGING_CODEC_END;
-	    break;
+            break;
-	}
+        }
 
     }
 

src/libImaging/SgiRleDecode.c

@@ -6,7 +6,7 @@
  *
  * history:
  * 2017-07-28 mb    fixed for images larger than 64KB
- * 2017-07-20 mb	created
+ * 2017-07-20 mb    created
  *
  * Copyright (c) Mickael Bonfill 2017.
  *
@@ -101,7 +101,7 @@ static int expandrow2(UINT8* dest, const UINT8* src, int n, int z, int xsize)
 
 int
 ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
-		    UINT8* buf, Py_ssize_t bytes)
+            UINT8* buf, Py_ssize_t bytes)
 {
     UINT8 *ptr;
     SGISTATE *c;

src/libImaging/TgaRleDecode.c

@@ -5,8 +5,8 @@
  * decoder for Targa RLE data.
  *
  * history:
- * 97-01-04 fl	created
+ * 97-01-04 fl created
- * 98-09-11 fl	don't one byte per pixel; take orientation into account
+ * 98-09-11 fl don't one byte per pixel; take orientation into account
  *
  * Copyright (c) Fredrik Lundh 1997.
  * Copyright (c) Secret Labs AB 1997-98.
@@ -20,7 +20,7 @@
 
 int
 ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
-		    UINT8* buf, Py_ssize_t bytes)
+            UINT8* buf, Py_ssize_t bytes)
 {
     int n, depth;
     UINT8* ptr;
@@ -29,14 +29,14 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
 
     if (state->state == 0) {
 
-	/* check image orientation */
+        /* check image orientation */
-	if (state->ystep < 0) {
+        if (state->ystep < 0) {
-	    state->y = state->ysize-1;
+            state->y = state->ysize-1;
-	    state->ystep = -1;
+            state->ystep = -1;
-	} else
+        } else
-	    state->ystep = 1;
+            state->ystep = 1;
 
-	state->state = 1;
+        state->state = 1;
 
     }
 
@@ -44,22 +44,22 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
 
     for (;;) {
 
-	if (bytes < 1)
+        if (bytes < 1)
-	    return ptr - buf;
+            return ptr - buf;
 
-	if (ptr[0] & 0x80) {
+        if (ptr[0] & 0x80) {
 
-	    /* Run (1 + pixelsize bytes) */
+            /* Run (1 + pixelsize bytes) */
 
-	    if (bytes < 1 + depth)
+            if (bytes < 1 + depth)
-		break;
+                break;
 
-	    n = depth * ((ptr[0] & 0x7f) + 1);
+            n = depth * ((ptr[0] & 0x7f) + 1);
 
-	    if (state->x + n > state->bytes) {
+            if (state->x + n > state->bytes) {
-		state->errcode = IMAGING_CODEC_OVERRUN;
+                state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
+                return -1;
-	    }
+            }
 
             if (depth == 1)
                 memset(state->buffer + state->x, ptr[1], n);
@@ -70,38 +70,38 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
             }
 
             ptr += 1 + depth;
-	    bytes -= 1 + depth;
+            bytes -= 1 + depth;
 
-	} else {
+        } else {
 
-	    /* Literal (1+n+1 bytes block) */
+            /* Literal (1+n+1 bytes block) */
-	    n = depth * (ptr[0] + 1);
+            n = depth * (ptr[0] + 1);
 
-	    if (bytes < 1 + n)
+            if (bytes < 1 + n)
-		break;
+                break;
 
-	    if (state->x + n > state->bytes) {
+            if (state->x + n > state->bytes) {
-		state->errcode = IMAGING_CODEC_OVERRUN;
+                state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
+                return -1;
-	    }
+            }
 
-	    memcpy(state->buffer + state->x, ptr + 1, n);
+            memcpy(state->buffer + state->x, ptr + 1, n);
 
-	    ptr += 1 + n;
+            ptr += 1 + n;
-	    bytes -= 1 + n;
+            bytes -= 1 + n;
 
-	}
+        }
 
-	state->x += n;
+        state->x += n;
 
-	if (state->x >= state->bytes) {
+        if (state->x >= state->bytes) {
 
-	    /* Got a full line, unpack it */
+            /* Got a full line, unpack it */
-	    state->shuffle((UINT8*) im->image[state->y + state->yoff] +
+            state->shuffle((UINT8*) im->image[state->y + state->yoff] +
-			   state->xoff * im->pixelsize, state->buffer,
+                   state->xoff * im->pixelsize, state->buffer,
-			   state->xsize);
+                   state->xsize);
 
-	    state->x = 0;
+            state->x = 0;
 
             state->y += state->ystep;
 
@@ -110,7 +110,7 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
                 return -1;
             }
 
-	}
+        }
 
     }
 

src/libImaging/TiffDecode.h

@@ -28,17 +28,17 @@
 #define _PIL_LIBTIFF_
 
 typedef struct {
-	tdata_t data; /* tdata_t == void* */
+    tdata_t data; /* tdata_t == void* */
-	toff_t loc;   /* toff_t == uint32 */
+    toff_t loc;   /* toff_t == uint32 */
-	tsize_t size; /* tsize_t == int32 */
+    tsize_t size; /* tsize_t == int32 */
-	int fp;
+    int fp;
     uint32 ifd;   /* offset of the ifd, used for multipage
                    * Should be uint32 for libtiff 3.9.x
                    * uint64 for libtiff 4.0.x
                    */
-	TIFF *tiff;   /* Used in write */
+    TIFF *tiff;   /* Used in write */
-	toff_t eof;
+    toff_t eof;
-	int flrealloc;/* may we realloc */
+    int flrealloc;/* may we realloc */
 } TIFFSTATE;
 
 
@@ -55,7 +55,7 @@ extern int ImagingLibTiffSetField(ImagingCodecState state, ttag_t tag, ...);
 */
 
 /*
-#define VA_ARGS(...)	__VA_ARGS__
+#define VA_ARGS(...)   __VA_ARGS__
 #define TRACE(args)    fprintf(stderr, VA_ARGS args)
 */
 

src/libImaging/Unpack.c

@@ -998,7 +998,7 @@ unpackI16N_I16B(UINT8* out, const UINT8* in, int pixels){
     UINT8* tmp = (UINT8*) out;
     for (i = 0; i < pixels; i++) {
         C16B;
-		in += 2; tmp += 2;
+        in += 2; tmp += 2;
     }
 
 }
@@ -1008,7 +1008,7 @@ unpackI16N_I16(UINT8* out, const UINT8* in, int pixels){
     UINT8* tmp = (UINT8*) out;
     for (i = 0; i < pixels; i++) {
         C16L;
-		in += 2; tmp += 2;
+        in += 2; tmp += 2;
     }
 }
 
@@ -1053,7 +1053,7 @@ unpackI12_I16(UINT8* out, const UINT8* in, int pixels){
         memcpy(out, &pixel, sizeof(pixel));
 #endif
 
-		in += 3; out+=2;
+        in += 3; out+=2;
     }
     if (i == pixels-1) {
         pixel = (((UINT16) in[0]) << 4 ) + (in[1] >>4);
@@ -1306,7 +1306,7 @@ static struct {
     /* greyscale w. alpha */
     {"LA",      "LA",           16,     unpackLA},
     {"LA",      "LA;L",         16,     unpackLAL},
-    
+
     /* greyscale w. alpha premultiplied */
     {"La",      "La",           16,     unpackLA},
 
@@ -1447,16 +1447,16 @@ static struct {
     {"YCbCr",   "YCbCrK",       32,     copy4},
 
     /* LAB Color */
-    {"LAB",	    "LAB",	        24,	    ImagingUnpackLAB},
+    {"LAB",     "LAB",          24,     ImagingUnpackLAB},
-    {"LAB",  	"L",            8,      band0},
+    {"LAB",     "L",            8,      band0},
-    {"LAB",  	"A",            8,      band1},
+    {"LAB",     "A",            8,      band1},
-    {"LAB",  	"B",            8,      band2},
+    {"LAB",     "B",            8,      band2},
 
     /* HSV Color */
-    {"HSV",	    "HSV",	        24,	    ImagingUnpackRGB},
+    {"HSV",     "HSV",          24,     ImagingUnpackRGB},
-    {"HSV",  	"H",            8,      band0},
+    {"HSV",     "H",            8,      band0},
-    {"HSV",  	"S",            8,      band1},
+    {"HSV",     "S",            8,      band1},
-    {"HSV",  	"V",            8,      band2},
+    {"HSV",     "V",            8,      band2},
 
     /* integer variations */
     {"I",       "I",            32,     copy4},
@@ -1505,11 +1505,11 @@ static struct {
     {"I;16B",   "I;16B",        16,     copy2},
     {"I;16L",   "I;16L",        16,     copy2},
 
-    {"I;16", 	"I;16N",	    16,	    unpackI16N_I16}, // LibTiff native->image endian.
+    {"I;16",    "I;16N",        16,     unpackI16N_I16}, // LibTiff native->image endian.
-    {"I;16L", 	"I;16N",	    16,	    unpackI16N_I16}, // LibTiff native->image endian.
+    {"I;16L",   "I;16N",        16,     unpackI16N_I16}, // LibTiff native->image endian.
-    {"I;16B", 	"I;16N",	    16,	    unpackI16N_I16B},
+    {"I;16B",   "I;16N",        16,     unpackI16N_I16B},
 
-    {"I;16", 	"I;12",	        12,	    unpackI12_I16}, // 12 bit Tiffs stored in 16bits.
+    {"I;16",    "I;12",         12,     unpackI12_I16}, // 12 bit Tiffs stored in 16bits.
 
     {NULL} /* sentinel */
 };

src/libImaging/UnpackYCC.c

@@ -5,7 +5,7 @@
  * code to convert and unpack PhotoYCC data
  *
  * history:
- * 97-01-25 fl	Moved from PcdDecode.c
+ * 97-01-25 fl Moved from PcdDecode.c
  *
  * Copyright (c) Fredrik Lundh 1996-97.
  * Copyright (c) Secret Labs AB 1997.
@@ -116,12 +116,12 @@ static INT16 GR[] = { 127, 126, 125, 124, 123, 122, 121, 121, 120, 119,
 -85, -86, -87, -88, -89, -90, -91, -92, -93, -94, -94, -95, -96, -97,
 -98, -99, -100, -101, -102, -103, -104, -105, -106, -107, -107, -108 };
 
-#define	R 0
+#define R 0
-#define	G 1
+#define G 1
-#define	B 2
+#define B 2
-#define	A 3
+#define A 3
 
-#define	YCC2RGB(rgb, y, cb, cr) {\
+#define YCC2RGB(rgb, y, cb, cr) {\
     int l = L[y];\
     int r = l + CR[cr];\
     int g = l + GR[cr] + GB[cb];\
@@ -137,9 +137,9 @@ ImagingUnpackYCC(UINT8* out, const UINT8* in, int pixels)
     int i;
     /* PhotoYCC triplets */
     for (i = 0; i < pixels; i++) {
-	YCC2RGB(out, in[0], in[1], in[2]);
+        YCC2RGB(out, in[0], in[1], in[2]);
-	out[A] = 255;
+        out[A] = 255;
-	out += 4; in += 3;
+        out += 4; in += 3;
     }
 }
 
@@ -149,14 +149,14 @@ ImagingUnpackYCCA(UINT8* out, const UINT8* in, int pixels)
     int i;
     /* PhotoYCC triplets plus premultiplied alpha */
     for (i = 0; i < pixels; i++) {
-	/* Divide by alpha */
+        /* Divide by alpha */
-	UINT8 rgb[3];
+        UINT8 rgb[3];
-	rgb[0] = (in[3] == 0) ? 0 : (((int) in[0] * 255) / in[3]);
+        rgb[0] = (in[3] == 0) ? 0 : (((int) in[0] * 255) / in[3]);
-	rgb[1] = (in[3] == 0) ? 0 : (((int) in[1] * 255) / in[3]);
+        rgb[1] = (in[3] == 0) ? 0 : (((int) in[1] * 255) / in[3]);
-	rgb[2] = (in[3] == 0) ? 0 : (((int) in[2] * 255) / in[3]);
+        rgb[2] = (in[3] == 0) ? 0 : (((int) in[2] * 255) / in[3]);
-	/* Convert non-multiplied data to RGB */
+        /* Convert non-multiplied data to RGB */
-	YCC2RGB(out, rgb[0], rgb[1], rgb[2]);
+        YCC2RGB(out, rgb[0], rgb[1], rgb[2]);
-	out[A] = in[3];
+        out[A] = in[3];
-	out += 4; in += 4;
+        out += 4; in += 4;
     }
 }

src/libImaging/XbmDecode.c

@@ -5,7 +5,7 @@
  * decoder for XBM hex image data
  *
  * history:
- *	96-04-13 fl	Created
+ * 96-04-13 fl Created
  *
  * Copyright (c) Fredrik Lundh 1996.
  * Copyright (c) Secret Labs AB 1997.
@@ -16,9 +16,9 @@
 
 #include "Imaging.h"
 
-#define	HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
+#define HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
-		(v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
+        (v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
-		(v >= 'A' && v <= 'F') ? v - 'A' + 10 : 0)
+        (v >= 'A' && v <= 'F') ? v - 'A' + 10 : 0)
 
 int
 ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
@@ -28,53 +28,53 @@ ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
     UINT8* ptr;
 
     if (!state->state)
-	state->state = SKIP;
+        state->state = SKIP;
 
     ptr = buf;
 
     for (;;) {
 
-	if (state->state == SKIP) {
+        if (state->state == SKIP) {
 
-	    /* Skip forward until next 'x' */
+            /* Skip forward until next 'x' */
 
-	    while (bytes > 0) {
+            while (bytes > 0) {
-		if (*ptr == 'x')
+                if (*ptr == 'x')
-		    break;
+                    break;
-		ptr++;
+                ptr++;
-		bytes--;
+                bytes--;
-	    }
+            }
 
-	    if (bytes == 0)
+            if (bytes == 0)
-		return ptr - buf;
+                return ptr - buf;
 
-	    state->state = BYTE;
+            state->state = BYTE;
 
-	}
+        }
 
-	if (bytes < 3)
+        if (bytes < 3)
-	    return ptr - buf;
+            return ptr - buf;
 
-	state->buffer[state->x] = (HEX(ptr[1])<<4) + HEX(ptr[2]);
+        state->buffer[state->x] = (HEX(ptr[1])<<4) + HEX(ptr[2]);
 
-	if (++state->x >= state->bytes) {
+        if (++state->x >= state->bytes) {
 
-	    /* Got a full line, unpack it */
+            /* Got a full line, unpack it */
-	    state->shuffle((UINT8*) im->image[state->y], state->buffer,
+            state->shuffle((UINT8*) im->image[state->y], state->buffer,
-			   state->xsize);
+                   state->xsize);
 
-	    state->x = 0;
+            state->x = 0;
 
-	    if (++state->y >= state->ysize) {
+            if (++state->y >= state->ysize) {
-		/* End of file (errcode = 0) */
+                /* End of file (errcode = 0) */
-		return -1;
+                return -1;
-	    }
+            }
-	}
+        }
 
-	ptr += 3;
+        ptr += 3;
-	bytes -= 3;
+        bytes -= 3;
 
-	state->state = SKIP;
+        state->state = SKIP;
 
     }
 

src/libImaging/XbmEncode.c

@@ -5,7 +5,7 @@
  * encoder for Xbm data
  *
  * history:
- *	96-11-01 fl	created
+ * 96-11-01 fl created
  *
  * Copyright (c) Fredrik Lundh 1996.
  * Copyright (c) Secret Labs AB 1997.
@@ -27,79 +27,79 @@ ImagingXbmEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
 
     if (!state->state) {
 
-	/* 8 pixels are stored in no more than 6 bytes */
+        /* 8 pixels are stored in no more than 6 bytes */
-	state->bytes = 6*(state->xsize+7)/8;
+        state->bytes = 6*(state->xsize+7)/8;
 
-	state->state = 1;
+        state->state = 1;
 
     }
 
     if (bytes < state->bytes) {
-	state->errcode = IMAGING_CODEC_MEMORY;
+        state->errcode = IMAGING_CODEC_MEMORY;
-	return 0;
+        return 0;
     }
 
     ptr = buf;
 
     while (bytes >= state->bytes) {
 
-	state->shuffle(state->buffer,
+        state->shuffle(state->buffer,
-		       (UINT8*) im->image[state->y + state->yoff] +
+                   (UINT8*) im->image[state->y + state->yoff] +
-		       state->xoff * im->pixelsize, state->xsize);
+                   state->xoff * im->pixelsize, state->xsize);
 
-	if (state->y < state->ysize-1) {
+        if (state->y < state->ysize-1) {
 
-	    /* any line but the last */
+            /* any line but the last */
-	    for (n = 0; n < state->xsize; n += 8) {
+            for (n = 0; n < state->xsize; n += 8) {
 
-		i = state->buffer[n/8];
+                i = state->buffer[n/8];
 
-		*ptr++ = '0';
+                *ptr++ = '0';
-		*ptr++ = 'x';
+                *ptr++ = 'x';
-		*ptr++ = hex[(i>>4)&15];
+                *ptr++ = hex[(i>>4)&15];
-		*ptr++ = hex[i&15];
+                *ptr++ = hex[i&15];
-		*ptr++ = ',';
+                *ptr++ = ',';
-		bytes -= 5;
+                bytes -= 5;
 
-		if (++state->count >= 79/5) {
+                if (++state->count >= 79/5) {
-		    *ptr++ = '\n';
+                    *ptr++ = '\n';
-		    bytes--;
+                    bytes--;
-		    state->count = 0;
+                    state->count = 0;
-		}
+                }
 
-	    }
+            }
 
-	    state->y++;
+            state->y++;
 
-	} else {
+        } else {
 
-	    /* last line */
+            /* last line */
-	    for (n = 0; n < state->xsize; n += 8) {
+            for (n = 0; n < state->xsize; n += 8) {
 
-		i = state->buffer[n/8];
+                i = state->buffer[n/8];
 
-		*ptr++ = '0';
+                *ptr++ = '0';
-		*ptr++ = 'x';
+                *ptr++ = 'x';
-		*ptr++ = hex[(i>>4)&15];
+                *ptr++ = hex[(i>>4)&15];
-		*ptr++ = hex[i&15];
+                *ptr++ = hex[i&15];
 
-		if (n < state->xsize-8) {
+                if (n < state->xsize-8) {
-		    *ptr++ = ',';
+                    *ptr++ = ',';
-		    if (++state->count >= 79/5) {
+                    if (++state->count >= 79/5) {
-			*ptr++ = '\n';
+                    *ptr++ = '\n';
-			bytes--;
+                    bytes--;
-			state->count = 0;
+                    state->count = 0;
-		    }
+                    }
-		} else
+                } else
-		    *ptr++ = '\n';
+                    *ptr++ = '\n';
 
-		bytes -= 5;
+                bytes -= 5;
 
-	    }
+            }
 
-	    state->errcode = IMAGING_CODEC_END;
+            state->errcode = IMAGING_CODEC_END;
-	    break;
+            break;
-	}
+        }
     }
 
     return ptr - buf;

src/libImaging/Zip.h

@@ -12,10 +12,10 @@
 
 
 /* modes */
-#define	ZIP_PNG	0		/* continuous, filtered image data */
+#define ZIP_PNG 0            /* continuous, filtered image data */
-#define	ZIP_PNG_PALETTE	1	/* non-continuous data, disable filtering */
+#define ZIP_PNG_PALETTE 1    /* non-continuous data, disable filtering */
-#define	ZIP_TIFF_PREDICTOR 2	/* TIFF, with predictor */
+#define ZIP_TIFF_PREDICTOR 2 /* TIFF, with predictor */
-#define	ZIP_TIFF 3		/* TIFF, without predictor */
+#define ZIP_TIFF 3           /* TIFF, without predictor */
 
 
 typedef struct {
@@ -39,24 +39,24 @@ typedef struct {
 
     /* PRIVATE CONTEXT (set by decoder/encoder) */
 
-    z_stream z_stream;		/* (de)compression stream */
+    z_stream z_stream;      /* (de)compression stream */
 
-    UINT8* previous;		/* previous line (allocated) */
+    UINT8* previous;        /* previous line (allocated) */
 
-    int last_output;		/* # bytes last output by inflate */
+    int last_output;        /* # bytes last output by inflate */
 
     /* Compressor specific stuff */
-    UINT8* prior;		/* filter storage (allocated) */
+    UINT8* prior;           /* filter storage (allocated) */
     UINT8* up;
     UINT8* average;
     UINT8* paeth;
 
-    UINT8* output;		/* output data */
+    UINT8* output;          /* output data */
 
-    int prefix;			/* size of filter prefix (0 for TIFF data) */
+    int prefix;             /* size of filter prefix (0 for TIFF data) */
 
-    int interlaced;		/* is the image interlaced? (PNG) */
+    int interlaced;         /* is the image interlaced? (PNG) */
 
-    int pass;			/* current pass of the interlaced image (PNG) */
+    int pass;               /* current pass of the interlaced image (PNG) */
 
 } ZIPSTATE;

src/outline.c

@@ -23,7 +23,7 @@
 
 
 /* -------------------------------------------------------------------- */
-/* Class								*/
+/* Class                                                                */
 
 typedef struct {
     PyObject_HEAD
@@ -44,7 +44,7 @@ _outline_new(void)
 
     self = PyObject_New(OutlineObject, &OutlineType);
     if (self == NULL)
-	return NULL;
+        return NULL;
 
     self->outline = ImagingOutlineNew();
 
@@ -69,7 +69,7 @@ PyOutline_AsOutline(PyObject* outline)
 
 
 /* -------------------------------------------------------------------- */
-/* Factories								*/
+/* Factories                                                            */
 
 PyObject*
 PyOutline_Create(PyObject* self, PyObject* args)
@@ -82,14 +82,14 @@ PyOutline_Create(PyObject* self, PyObject* args)
 
 
 /* -------------------------------------------------------------------- */
-/* Methods								*/
+/* Methods                                                              */
 
 static PyObject*
 _outline_move(OutlineObject* self, PyObject* args)
 {
     float x0, y0;
     if (!PyArg_ParseTuple(args, "ff", &x0, &y0))
-	return NULL;
+        return NULL;
 
     ImagingOutlineMove(self->outline, x0, y0);
 
@@ -102,7 +102,7 @@ _outline_line(OutlineObject* self, PyObject* args)
 {
     float x1, y1;
     if (!PyArg_ParseTuple(args, "ff", &x1, &y1))
-	return NULL;
+        return NULL;
 
     ImagingOutlineLine(self->outline, x1, y1);
 
@@ -115,7 +115,7 @@ _outline_curve(OutlineObject* self, PyObject* args)
 {
     float x1, y1, x2, y2, x3, y3;
     if (!PyArg_ParseTuple(args, "ffffff", &x1, &y1, &x2, &y2, &x3, &y3))
-	return NULL;
+        return NULL;
 
     ImagingOutlineCurve(self->outline, x1, y1, x2, y2, x3, y3);
 
@@ -158,35 +158,35 @@ static struct PyMethodDef _outline_methods[] = {
 };
 
 static PyTypeObject OutlineType = {
-	PyVarObject_HEAD_INIT(NULL, 0)
+    PyVarObject_HEAD_INIT(NULL, 0)
-	"Outline",			/*tp_name*/
+    "Outline",                   /*tp_name*/
-	sizeof(OutlineObject),		/*tp_size*/
+    sizeof(OutlineObject),       /*tp_size*/
-	0,				/*tp_itemsize*/
+    0,                           /*tp_itemsize*/
-	/* methods */
+    /* methods */
-	(destructor)_outline_dealloc,	/*tp_dealloc*/
+    (destructor)_outline_dealloc,/*tp_dealloc*/
-	0,				/*tp_print*/
+    0,                           /*tp_print*/
-    0,                          /*tp_getattr*/
+    0,                           /*tp_getattr*/
-    0,                          /*tp_setattr*/
+    0,                           /*tp_setattr*/
-    0,                          /*tp_compare*/
+    0,                           /*tp_compare*/
-    0,                          /*tp_repr*/
+    0,                           /*tp_repr*/
-    0,                          /*tp_as_number */
+    0,                           /*tp_as_number */
-    0,                          /*tp_as_sequence */
+    0,                           /*tp_as_sequence */
-    0,                          /*tp_as_mapping */
+    0,                           /*tp_as_mapping */
-    0,                          /*tp_hash*/
+    0,                           /*tp_hash*/
-    0,                          /*tp_call*/
+    0,                           /*tp_call*/
-    0,                          /*tp_str*/
+    0,                           /*tp_str*/
-    0,                          /*tp_getattro*/
+    0,                           /*tp_getattro*/
-    0,                          /*tp_setattro*/
+    0,                           /*tp_setattro*/
-    0,                          /*tp_as_buffer*/
+    0,                           /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT,         /*tp_flags*/
+    Py_TPFLAGS_DEFAULT,          /*tp_flags*/
-    0,                          /*tp_doc*/
+    0,                           /*tp_doc*/
-    0,                          /*tp_traverse*/
+    0,                           /*tp_traverse*/
-    0,                          /*tp_clear*/
+    0,                           /*tp_clear*/
-    0,                          /*tp_richcompare*/
+    0,                           /*tp_richcompare*/
-    0,                          /*tp_weaklistoffset*/
+    0,                           /*tp_weaklistoffset*/
-    0,                          /*tp_iter*/
+    0,                           /*tp_iter*/
-    0,                          /*tp_iternext*/
+    0,                           /*tp_iternext*/
-    _outline_methods,           /*tp_methods*/
+    _outline_methods,            /*tp_methods*/
-    0,                          /*tp_members*/
+    0,                           /*tp_members*/
-    0,                          /*tp_getset*/
+    0,                           /*tp_getset*/
 };