diff --git a/src/_imagingtk.c b/src/_imagingtk.c
index bdf5e68d1..95d977645 100644
--- a/src/_imagingtk.c
+++ b/src/_imagingtk.c
@@ -4,8 +4,8 @@
  * tkinter hooks
  *
  * history:
- * 99-07-26 fl	created
- * 99-08-15 fl	moved to its own support module
+ * 99-07-26 fl created
+ * 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
-	   layout changes */
+        /* Do it the hard way.  This will break if the TkappObject
+        layout changes */
         app = (TkappObject*)PyLong_AsVoidPtr(arg);
         interp = app->interp;
     }
diff --git a/src/_webp.c b/src/_webp.c
index babea60f3..8979118a2 100644
--- a/src/_webp.c
+++ b/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) {
diff --git a/src/display.c b/src/display.c
index eff9de5c4..9a337d1c0 100644
--- a/src/display.c
+++ b/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);
-	return NULL;
+        Py_DECREF(display);
+        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)
-	"ImagingDisplay",		/*tp_name*/
-	sizeof(ImagingDisplayObject),	/*tp_size*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	(destructor)_delete,		/*tp_dealloc*/
-	0,				/*tp_print*/
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "ImagingDisplay",            /*tp_name*/
+    sizeof(ImagingDisplayObject),/*tp_size*/
+    0,                           /*tp_itemsize*/
+    /* methods */
+    (destructor)_delete,        /*tp_dealloc*/
+    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>
diff --git a/src/encode.c b/src/encode.c
index cbf1da3a9..e56498913 100644
--- a/src/encode.c
+++ b/src/encode.c
@@ -1095,7 +1095,7 @@ PyImaging_JpegEncoderNew(PyObject* self, PyObject* args)
 
 
 /* -------------------------------------------------------------------- */
-/* JPEG	2000								*/
+/* JPEG 2000                                                            */
 /* -------------------------------------------------------------------- */
 
 #ifdef HAVE_OPENJPEG
diff --git a/src/libImaging/BcnDecode.c b/src/libImaging/BcnDecode.c
index c2c4f21e7..3e62aa6c9 100644
--- a/src/libImaging/BcnDecode.c
+++ b/src/libImaging/BcnDecode.c
@@ -16,841 +16,842 @@
 
 
 typedef struct {
-	UINT8 r, g, b, a;
+    UINT8 r, g, b, a;
 } rgba;
 
 typedef struct {
-	UINT8 l;
+    UINT8 l;
 } lum;
 
 typedef struct {
-	FLOAT32 r, g, b;
+    FLOAT32 r, g, b;
 } rgb32f;
 
 typedef struct {
-	UINT16 c0, c1;
-	UINT32 lut;
+    UINT16 c0, c1;
+    UINT32 lut;
 } bc1_color;
 
 typedef struct {
-	UINT8 a0, a1;
-	UINT8 lut[6];
+    UINT8 a0, a1;
+    UINT8 lut[6];
 } bc3_alpha;
 
 #define LOAD16(p) \
-	(p)[0] | ((p)[1] << 8)
+    (p)[0] | ((p)[1] << 8)
 
 #define LOAD32(p) \
-	(p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24)
+    (p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24)
 
 static void bc1_color_load(bc1_color *dst, const UINT8 *src) {
-	dst->c0 = LOAD16(src);
-	dst->c1 = LOAD16(src + 2);
-	dst->lut = LOAD32(src + 4);
+    dst->c0 = LOAD16(src);
+    dst->c1 = LOAD16(src + 2);
+    dst->lut = LOAD32(src + 4);
 }
 
 static void bc3_alpha_load(bc3_alpha *dst, const UINT8 *src) {
-	memcpy(dst, src, sizeof(bc3_alpha));
+    memcpy(dst, src, sizeof(bc3_alpha));
 }
 
 static rgba decode_565(UINT16 x) {
-	rgba c;
-	int r, g, b;
-	r = (x & 0xf800) >> 8;
-	r |= r >> 5;
-	c.r = r;
-	g = (x & 0x7e0) >> 3;
-	g |= g >> 6;
-	c.g = g;
-	b = (x & 0x1f) << 3;
-	b |= b >> 5;
-	c.b = b;
-	c.a = 0xff;
-	return c;
+    rgba c;
+    int r, g, b;
+    r = (x & 0xf800) >> 8;
+    r |= r >> 5;
+    c.r = r;
+    g = (x & 0x7e0) >> 3;
+    g |= g >> 6;
+    c.g = g;
+    b = (x & 0x1f) << 3;
+    b |= b >> 5;
+    c.b = b;
+    c.a = 0xff;
+    return c;
 }
 
 static void decode_bc1_color(rgba *dst, const UINT8 *src) {
-	bc1_color col;
-	rgba p[4];
-	int n, cw;
-	UINT16 r0, g0, b0, r1, g1, b1;
-	bc1_color_load(&col, src);
+    bc1_color col;
+    rgba p[4];
+    int n, cw;
+    UINT16 r0, g0, b0, r1, g1, b1;
+    bc1_color_load(&col, src);
 
-	p[0] = decode_565(col.c0);
-	r0 = p[0].r;
-	g0 = p[0].g;
-	b0 = p[0].b;
-	p[1] = decode_565(col.c1);
-	r1 = p[1].r;
-	g1 = p[1].g;
-	b1 = p[1].b;
-	if (col.c0 > col.c1) {
-		p[2].r = (2*r0 + 1*r1) / 3;
-		p[2].g = (2*g0 + 1*g1) / 3;
-		p[2].b = (2*b0 + 1*b1) / 3;
-		p[2].a = 0xff;
-		p[3].r = (1*r0 + 2*r1) / 3;
-		p[3].g = (1*g0 + 2*g1) / 3;
-		p[3].b = (1*b0 + 2*b1) / 3;
-		p[3].a = 0xff;
-	} else {
-		p[2].r = (r0 + r1) / 2;
-		p[2].g = (g0 + g1) / 2;
-		p[2].b = (b0 + b1) / 2;
-		p[2].a = 0xff;
-		p[3].r = 0;
-		p[3].g = 0;
-		p[3].b = 0;
-		p[3].a = 0;
-	}
-	for (n = 0; n < 16; n++) {
-		cw = 3 & (col.lut >> (2 * n));
-		dst[n] = p[cw];
-	}
+    p[0] = decode_565(col.c0);
+    r0 = p[0].r;
+    g0 = p[0].g;
+    b0 = p[0].b;
+    p[1] = decode_565(col.c1);
+    r1 = p[1].r;
+    g1 = p[1].g;
+    b1 = p[1].b;
+    if (col.c0 > col.c1) {
+        p[2].r = (2*r0 + 1*r1) / 3;
+        p[2].g = (2*g0 + 1*g1) / 3;
+        p[2].b = (2*b0 + 1*b1) / 3;
+        p[2].a = 0xff;
+        p[3].r = (1*r0 + 2*r1) / 3;
+        p[3].g = (1*g0 + 2*g1) / 3;
+        p[3].b = (1*b0 + 2*b1) / 3;
+        p[3].a = 0xff;
+    } else {
+        p[2].r = (r0 + r1) / 2;
+        p[2].g = (g0 + g1) / 2;
+        p[2].b = (b0 + b1) / 2;
+        p[2].a = 0xff;
+        p[3].r = 0;
+        p[3].g = 0;
+        p[3].b = 0;
+        p[3].a = 0;
+    }
+    for (n = 0; n < 16; n++) {
+        cw = 3 & (col.lut >> (2 * n));
+        dst[n] = p[cw];
+    }
 }
 
 static void decode_bc3_alpha(char *dst, const UINT8 *src, int stride, int o) {
-	bc3_alpha b;
-	UINT16 a0, a1;
-	UINT8 a[8];
-	int n, lut, aw;
-	bc3_alpha_load(&b, src);
+    bc3_alpha b;
+    UINT16 a0, a1;
+    UINT8 a[8];
+    int n, lut, aw;
+    bc3_alpha_load(&b, src);
 
-	a0 = b.a0;
-	a1 = b.a1;
-	a[0] = (UINT8)a0;
-	a[1] = (UINT8)a1;
-	if (a0 > a1) {
-		a[2] = (6*a0 + 1*a1) / 7;
-		a[3] = (5*a0 + 2*a1) / 7;
-		a[4] = (4*a0 + 3*a1) / 7;
-		a[5] = (3*a0 + 4*a1) / 7;
-		a[6] = (2*a0 + 5*a1) / 7;
-		a[7] = (1*a0 + 6*a1) / 7;
-	} else {
-		a[2] = (4*a0 + 1*a1) / 5;
-		a[3] = (3*a0 + 2*a1) / 5;
-		a[4] = (2*a0 + 3*a1) / 5;
-		a[5] = (1*a0 + 4*a1) / 5;
-		a[6] = 0;
-		a[7] = 0xff;
-	}
-	lut = b.lut[0] | (b.lut[1] << 8) | (b.lut[2] << 16);
-	for (n = 0; n < 8; n++) {
-		aw = 7 & (lut >> (3 * n));
-		dst[stride * n + o] = a[aw];
-	}
-	lut = b.lut[3] | (b.lut[4] << 8) | (b.lut[5] << 16);
-	for (n = 0; n < 8; n++) {
-		aw = 7 & (lut >> (3 * n));
-		dst[stride * (8+n) + o] = a[aw];
-	}
+    a0 = b.a0;
+    a1 = b.a1;
+    a[0] = (UINT8)a0;
+    a[1] = (UINT8)a1;
+    if (a0 > a1) {
+        a[2] = (6*a0 + 1*a1) / 7;
+        a[3] = (5*a0 + 2*a1) / 7;
+        a[4] = (4*a0 + 3*a1) / 7;
+        a[5] = (3*a0 + 4*a1) / 7;
+        a[6] = (2*a0 + 5*a1) / 7;
+        a[7] = (1*a0 + 6*a1) / 7;
+    } else {
+        a[2] = (4*a0 + 1*a1) / 5;
+        a[3] = (3*a0 + 2*a1) / 5;
+        a[4] = (2*a0 + 3*a1) / 5;
+        a[5] = (1*a0 + 4*a1) / 5;
+        a[6] = 0;
+        a[7] = 0xff;
+    }
+    lut = b.lut[0] | (b.lut[1] << 8) | (b.lut[2] << 16);
+    for (n = 0; n < 8; n++) {
+        aw = 7 & (lut >> (3 * n));
+        dst[stride * n + o] = a[aw];
+    }
+    lut = b.lut[3] | (b.lut[4] << 8) | (b.lut[5] << 16);
+    for (n = 0; n < 8; n++) {
+        aw = 7 & (lut >> (3 * n));
+        dst[stride * (8+n) + o] = a[aw];
+    }
 }
 
 static void decode_bc1_block(rgba *col, const UINT8* src) {
-	decode_bc1_color(col, src);
+    decode_bc1_color(col, src);
 }
 
 static void decode_bc2_block(rgba *col, const UINT8* src) {
-	int n, bitI, byI, av;
-	decode_bc1_color(col, src + 8);
-	for (n = 0; n < 16; n++) {
-		bitI = n * 4;
-		byI = bitI >> 3;
-		av = 0xf & (src[byI] >> (bitI & 7));
-		av = (av << 4) | av;
-		col[n].a = av;
-	}
+    int n, bitI, byI, av;
+    decode_bc1_color(col, src + 8);
+    for (n = 0; n < 16; n++) {
+        bitI = n * 4;
+        byI = bitI >> 3;
+        av = 0xf & (src[byI] >> (bitI & 7));
+        av = (av << 4) | av;
+        col[n].a = av;
+    }
 }
 
 static void decode_bc3_block(rgba *col, const UINT8* src) {
-	decode_bc1_color(col, src + 8);
-	decode_bc3_alpha((char *)col, src, sizeof(col[0]), 3);
+    decode_bc1_color(col, src + 8);
+    decode_bc3_alpha((char *)col, src, sizeof(col[0]), 3);
 }
 
 static void decode_bc4_block(lum *col, const UINT8* src) {
-	decode_bc3_alpha((char *)col, src, sizeof(col[0]), 0);
+    decode_bc3_alpha((char *)col, src, sizeof(col[0]), 0);
 }
 
 static void decode_bc5_block(rgba *col, const UINT8* src) {
-	decode_bc3_alpha((char *)col, src, sizeof(col[0]), 0);
-	decode_bc3_alpha((char *)col, src + 8, sizeof(col[0]), 1);
+    decode_bc3_alpha((char *)col, src, sizeof(col[0]), 0);
+    decode_bc3_alpha((char *)col, src + 8, sizeof(col[0]), 1);
 }
 
 /* BC6 and BC7 are described here:
    https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_texture_compression_bptc.txt */
 
 static UINT8 get_bit(const UINT8* src, int bit) {
-	int by = bit >> 3;
-	bit &= 7;
-	return (src[by] >> bit) & 1;
+    int by = bit >> 3;
+    bit &= 7;
+    return (src[by] >> bit) & 1;
 }
 
 static UINT8 get_bits(const UINT8* src, int bit, int count) {
-	UINT8 v;
-	int x;
-	int by = bit >> 3;
-	bit &= 7;
-	if (!count) {
-		return 0;
-	}
-	if (bit + count <= 8) {
-		v = (src[by] >> bit) & ((1 << count) - 1);
-	} else {
-		x = src[by] | (src[by+1] << 8);
-		v = (x >> bit) & ((1 << count) - 1);
-	}
-	return v;
+    UINT8 v;
+    int x;
+    int by = bit >> 3;
+    bit &= 7;
+    if (!count) {
+        return 0;
+    }
+    if (bit + count <= 8) {
+        v = (src[by] >> bit) & ((1 << count) - 1);
+    } else {
+        x = src[by] | (src[by+1] << 8);
+        v = (x >> bit) & ((1 << count) - 1);
+    }
+    return v;
 }
 
 /* BC7 */
 typedef struct {
-	char ns;
-	char pb;
-	char rb;
-	char isb;
-	char cb;
-	char ab;
-	char epb;
-	char spb;
-	char ib;
-	char ib2;
+    char ns;
+    char pb;
+    char rb;
+    char isb;
+    char cb;
+    char ab;
+    char epb;
+    char spb;
+    char ib;
+    char ib2;
 } bc7_mode_info;
 
 static const bc7_mode_info bc7_modes[] = {
-	{3, 4, 0, 0, 4, 0, 1, 0, 3, 0},
-	{2, 6, 0, 0, 6, 0, 0, 1, 3, 0},
-	{3, 6, 0, 0, 5, 0, 0, 0, 2, 0},
-	{2, 6, 0, 0, 7, 0, 1, 0, 2, 0},
-	{1, 0, 2, 1, 5, 6, 0, 0, 2, 3},
-	{1, 0, 2, 0, 7, 8, 0, 0, 2, 2},
-	{1, 0, 0, 0, 7, 7, 1, 0, 4, 0},
-	{2, 6, 0, 0, 5, 5, 1, 0, 2, 0}
+    {3, 4, 0, 0, 4, 0, 1, 0, 3, 0},
+    {2, 6, 0, 0, 6, 0, 0, 1, 3, 0},
+    {3, 6, 0, 0, 5, 0, 0, 0, 2, 0},
+    {2, 6, 0, 0, 7, 0, 1, 0, 2, 0},
+    {1, 0, 2, 1, 5, 6, 0, 0, 2, 3},
+    {1, 0, 2, 0, 7, 8, 0, 0, 2, 2},
+    {1, 0, 0, 0, 7, 7, 1, 0, 4, 0},
+    {2, 6, 0, 0, 5, 5, 1, 0, 2, 0}
 };
 
 /* Subset indices:
    Table.P2, 1 bit per index */
 static const UINT16 bc7_si2[] = {
-	0xcccc, 0x8888, 0xeeee, 0xecc8, 0xc880, 0xfeec, 0xfec8, 0xec80,
-	0xc800, 0xffec, 0xfe80, 0xe800, 0xffe8, 0xff00, 0xfff0, 0xf000,
-	0xf710, 0x008e, 0x7100, 0x08ce, 0x008c, 0x7310, 0x3100, 0x8cce,
-	0x088c, 0x3110, 0x6666, 0x366c, 0x17e8, 0x0ff0, 0x718e, 0x399c,
-	0xaaaa, 0xf0f0, 0x5a5a, 0x33cc, 0x3c3c, 0x55aa, 0x9696, 0xa55a,
-	0x73ce, 0x13c8, 0x324c, 0x3bdc, 0x6996, 0xc33c, 0x9966, 0x0660,
-	0x0272, 0x04e4, 0x4e40, 0x2720, 0xc936, 0x936c, 0x39c6, 0x639c,
-	0x9336, 0x9cc6, 0x817e, 0xe718, 0xccf0, 0x0fcc, 0x7744, 0xee22};
+    0xcccc, 0x8888, 0xeeee, 0xecc8, 0xc880, 0xfeec, 0xfec8, 0xec80,
+    0xc800, 0xffec, 0xfe80, 0xe800, 0xffe8, 0xff00, 0xfff0, 0xf000,
+    0xf710, 0x008e, 0x7100, 0x08ce, 0x008c, 0x7310, 0x3100, 0x8cce,
+    0x088c, 0x3110, 0x6666, 0x366c, 0x17e8, 0x0ff0, 0x718e, 0x399c,
+    0xaaaa, 0xf0f0, 0x5a5a, 0x33cc, 0x3c3c, 0x55aa, 0x9696, 0xa55a,
+    0x73ce, 0x13c8, 0x324c, 0x3bdc, 0x6996, 0xc33c, 0x9966, 0x0660,
+    0x0272, 0x04e4, 0x4e40, 0x2720, 0xc936, 0x936c, 0x39c6, 0x639c,
+    0x9336, 0x9cc6, 0x817e, 0xe718, 0xccf0, 0x0fcc, 0x7744, 0xee22};
 
 /* Table.P3, 2 bits per index */
 static const UINT32 bc7_si3[] = {
-	0xaa685050, 0x6a5a5040, 0x5a5a4200, 0x5450a0a8,
-	0xa5a50000, 0xa0a05050, 0x5555a0a0, 0x5a5a5050,
-	0xaa550000, 0xaa555500, 0xaaaa5500, 0x90909090,
-	0x94949494, 0xa4a4a4a4, 0xa9a59450, 0x2a0a4250,
-	0xa5945040, 0x0a425054, 0xa5a5a500, 0x55a0a0a0,
-	0xa8a85454, 0x6a6a4040, 0xa4a45000, 0x1a1a0500,
-	0x0050a4a4, 0xaaa59090, 0x14696914, 0x69691400,
-	0xa08585a0, 0xaa821414, 0x50a4a450, 0x6a5a0200,
-	0xa9a58000, 0x5090a0a8, 0xa8a09050, 0x24242424,
-	0x00aa5500, 0x24924924, 0x24499224, 0x50a50a50,
-	0x500aa550, 0xaaaa4444, 0x66660000, 0xa5a0a5a0,
-	0x50a050a0, 0x69286928, 0x44aaaa44, 0x66666600,
-	0xaa444444, 0x54a854a8, 0x95809580, 0x96969600,
-	0xa85454a8, 0x80959580, 0xaa141414, 0x96960000,
-	0xaaaa1414, 0xa05050a0, 0xa0a5a5a0, 0x96000000,
-	0x40804080, 0xa9a8a9a8, 0xaaaaaa44, 0x2a4a5254};
+    0xaa685050, 0x6a5a5040, 0x5a5a4200, 0x5450a0a8,
+    0xa5a50000, 0xa0a05050, 0x5555a0a0, 0x5a5a5050,
+    0xaa550000, 0xaa555500, 0xaaaa5500, 0x90909090,
+    0x94949494, 0xa4a4a4a4, 0xa9a59450, 0x2a0a4250,
+    0xa5945040, 0x0a425054, 0xa5a5a500, 0x55a0a0a0,
+    0xa8a85454, 0x6a6a4040, 0xa4a45000, 0x1a1a0500,
+    0x0050a4a4, 0xaaa59090, 0x14696914, 0x69691400,
+    0xa08585a0, 0xaa821414, 0x50a4a450, 0x6a5a0200,
+    0xa9a58000, 0x5090a0a8, 0xa8a09050, 0x24242424,
+    0x00aa5500, 0x24924924, 0x24499224, 0x50a50a50,
+    0x500aa550, 0xaaaa4444, 0x66660000, 0xa5a0a5a0,
+    0x50a050a0, 0x69286928, 0x44aaaa44, 0x66666600,
+    0xaa444444, 0x54a854a8, 0x95809580, 0x96969600,
+    0xa85454a8, 0x80959580, 0xaa141414, 0x96960000,
+    0xaaaa1414, 0xa05050a0, 0xa0a5a5a0, 0x96000000,
+    0x40804080, 0xa9a8a9a8, 0xaaaaaa44, 0x2a4a5254};
 
 /* Anchor indices:
    Table.A2 */
 static const char bc7_ai0[] = {
-	15,15,15,15,15,15,15,15,
-	15,15,15,15,15,15,15,15,
-	15, 2, 8, 2, 2, 8, 8,15,
-	 2, 8, 2, 2, 8, 8, 2, 2,
-	15,15, 6, 8, 2, 8,15,15,
-	 2, 8, 2, 2, 2,15,15, 6,
-	 6, 2, 6, 8,15,15, 2, 2,
-	15,15,15,15,15, 2, 2,15};
+    15,15,15,15,15,15,15,15,
+    15,15,15,15,15,15,15,15,
+    15, 2, 8, 2, 2, 8, 8,15,
+     2, 8, 2, 2, 8, 8, 2, 2,
+    15,15, 6, 8, 2, 8,15,15,
+     2, 8, 2, 2, 2,15,15, 6,
+     6, 2, 6, 8,15,15, 2, 2,
+    15,15,15,15,15, 2, 2,15};
 
 /* Table.A3a */
 static const char bc7_ai1[] = {
-	 3, 3,15,15, 8, 3,15,15,
-	 8, 8, 6, 6, 6, 5, 3, 3,
-	 3, 3, 8,15, 3, 3, 6,10,
-	 5, 8, 8, 6, 8, 5,15,15,
-	 8,15, 3, 5, 6,10, 8,15,
-	15, 3,15, 5,15,15,15,15,
-	 3,15, 5, 5, 5, 8, 5,10,
-	 5,10, 8,13,15,12, 3, 3};
+     3, 3,15,15, 8, 3,15,15,
+     8, 8, 6, 6, 6, 5, 3, 3,
+     3, 3, 8,15, 3, 3, 6,10,
+     5, 8, 8, 6, 8, 5,15,15,
+     8,15, 3, 5, 6,10, 8,15,
+    15, 3,15, 5,15,15,15,15,
+     3,15, 5, 5, 5, 8, 5,10,
+     5,10, 8,13,15,12, 3, 3};
 
 /* Table.A3b */
 static const char bc7_ai2[] = {
-	15, 8, 8, 3,15,15, 3, 8,
-	15,15,15,15,15,15,15, 8,
-	15, 8,15, 3,15, 8,15, 8,
-	 3,15, 6,10,15,15,10, 8,
-	15, 3,15,10,10, 8, 9,10,
-	 6,15, 8,15, 3, 6, 6, 8,
-	15, 3,15,15,15,15,15,15,
-	15,15,15,15, 3,15,15, 8};
+    15, 8, 8, 3,15,15, 3, 8,
+    15,15,15,15,15,15,15, 8,
+    15, 8,15, 3,15, 8,15, 8,
+     3,15, 6,10,15,15,10, 8,
+    15, 3,15,10,10, 8, 9,10,
+     6,15, 8,15, 3, 6, 6, 8,
+    15, 3,15,15,15,15,15,15,
+    15,15,15,15, 3,15,15, 8};
 
 /* Interpolation weights */
 static const char bc7_weights2[] = {0, 21, 43, 64};
 static const char bc7_weights3[] = {0, 9, 18, 27, 37, 46, 55, 64};
 static const char bc7_weights4[] = {
-	0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64};
+    0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64};
 
 static const char *bc7_get_weights(int n) {
-	if (n == 2) {
-		return bc7_weights2;
-	}
-	if (n == 3) {
-		return bc7_weights3;
-	}
-	return bc7_weights4;
+    if (n == 2) {
+        return bc7_weights2;
+    }
+    if (n == 3) {
+        return bc7_weights3;
+    }
+    return bc7_weights4;
 }
 
 static int bc7_get_subset(int ns, int partition, int n) {
-	if (ns == 2) {
-		return 1 & (bc7_si2[partition] >> n);
-	}
-	if (ns == 3) {
-		return 3 & (bc7_si3[partition] >> (2 * n));
-	}
-	return 0;
+    if (ns == 2) {
+        return 1 & (bc7_si2[partition] >> n);
+    }
+    if (ns == 3) {
+        return 3 & (bc7_si3[partition] >> (2 * n));
+    }
+    return 0;
 }
 
 static UINT8 expand_quantized(UINT8 v, int bits) {
-	v = v << (8 - bits);
-	return v | (v >> bits);
+    v = v << (8 - bits);
+    return v | (v >> bits);
 }
 
 static void bc7_lerp(rgba *dst, const rgba *e, int s0, int s1) {
-	int t0 = 64 - s0;
-	int t1 = 64 - s1;
-	dst->r = (UINT8)((t0 * e[0].r + s0 * e[1].r + 32) >> 6);
-	dst->g = (UINT8)((t0 * e[0].g + s0 * e[1].g + 32) >> 6);
-	dst->b = (UINT8)((t0 * e[0].b + s0 * e[1].b + 32) >> 6);
-	dst->a = (UINT8)((t1 * e[0].a + s1 * e[1].a + 32) >> 6);
+    int t0 = 64 - s0;
+    int t1 = 64 - s1;
+    dst->r = (UINT8)((t0 * e[0].r + s0 * e[1].r + 32) >> 6);
+    dst->g = (UINT8)((t0 * e[0].g + s0 * e[1].g + 32) >> 6);
+    dst->b = (UINT8)((t0 * e[0].b + s0 * e[1].b + 32) >> 6);
+    dst->a = (UINT8)((t1 * e[0].a + s1 * e[1].a + 32) >> 6);
 }
 
 static void decode_bc7_block(rgba *col, const UINT8* src) {
-	rgba endpoints[6];
-	int bit = 0, cibit, aibit;
-	int mode = src[0];
-	int i, j;
-	int numep, cb, ab, ib, ib2, i0, i1, s;
-	UINT8 index_sel, partition, rotation, val;
-	const char *cw, *aw;
-	const bc7_mode_info *info;
+    rgba endpoints[6];
+    int bit = 0, cibit, aibit;
+    int mode = src[0];
+    int i, j;
+    int numep, cb, ab, ib, ib2, i0, i1, s;
+    UINT8 index_sel, partition, rotation, val;
+    const char *cw, *aw;
+    const bc7_mode_info *info;
 
-	/* mode is the number of unset bits before the first set bit: */
-	if (!mode) {
-		/* degenerate case when no bits set */
-		for (i = 0; i < 16; i++) {
-			col[i].r = col[i].g = col[i].b = 0;
-			col[i].a = 255;
-		}
-		return;
-	}
-	while (!(mode & (1 << bit++))) ;
-	mode = bit - 1;
-	info = &bc7_modes[mode];
-	/* color selection bits: {subset}{endpoint} */
-	cb = info->cb;
-	ab = info->ab;
-	cw = bc7_get_weights(info->ib);
-	aw = bc7_get_weights((ab && info->ib2) ? info->ib2 : info->ib);
+    /* mode is the number of unset bits before the first set bit: */
+    if (!mode) {
+        /* degenerate case when no bits set */
+        for (i = 0; i < 16; i++) {
+            col[i].r = col[i].g = col[i].b = 0;
+            col[i].a = 255;
+        }
+        return;
+    }
+    while (!(mode & (1 << bit++))) ;
+    mode = bit - 1;
+    info = &bc7_modes[mode];
+    /* color selection bits: {subset}{endpoint} */
+    cb = info->cb;
+    ab = info->ab;
+    cw = bc7_get_weights(info->ib);
+    aw = bc7_get_weights((ab && info->ib2) ? info->ib2 : info->ib);
 
 #define LOAD(DST, N) \
-	DST = get_bits(src, bit, N); \
-	bit += N;
-	LOAD(partition, info->pb);
-	LOAD(rotation, info->rb);
-	LOAD(index_sel, info->isb);
-	numep = info->ns << 1;
+    DST = get_bits(src, bit, N); \
+    bit += N;
+    LOAD(partition, info->pb);
+    LOAD(rotation, info->rb);
+    LOAD(index_sel, info->isb);
+    numep = info->ns << 1;
 
-	/* red */
-	for (i = 0; i < numep; i++) {
-		LOAD(val, cb);
-		endpoints[i].r = val;
-	}
+    /* red */
+    for (i = 0; i < numep; i++) {
+        LOAD(val, cb);
+        endpoints[i].r = val;
+    }
 
-	/* green */
-	for (i = 0; i < numep; i++) {
-		LOAD(val, cb);
-		endpoints[i].g = val;
-	}
+    /* green */
+    for (i = 0; i < numep; i++) {
+        LOAD(val, cb);
+        endpoints[i].g = val;
+    }
 
-	/* blue */
-	for (i = 0; i < numep; i++) {
-		LOAD(val, cb);
-		endpoints[i].b = val;
-	}
+    /* blue */
+    for (i = 0; i < numep; i++) {
+        LOAD(val, cb);
+        endpoints[i].b = val;
+    }
 
-	/* alpha */
-	for (i = 0; i < numep; i++) {
-		if (ab) {
-			LOAD(val, ab);
-		} else {
-			val = 255;
-		}
-		endpoints[i].a = val;
-	}
+    /* alpha */
+    for (i = 0; i < numep; i++) {
+        if (ab) {
+            LOAD(val, ab);
+        } else {
+            val = 255;
+        }
+        endpoints[i].a = val;
+    }
 
-	/* p-bits */
+    /* p-bits */
 #define ASSIGN_P(x) x = (x << 1) | val
-	if (info->epb) {
-		/* per endpoint */
-		cb++;
-		if (ab) {
-			ab++;
-		}
-		for (i = 0; i < numep; i++) {
-			LOAD(val, 1);
-			ASSIGN_P(endpoints[i].r);
-			ASSIGN_P(endpoints[i].g);
-			ASSIGN_P(endpoints[i].b);
-			if (ab) {
-				ASSIGN_P(endpoints[i].a);
-			}
-		}
-	}
-	if (info->spb) {
-		/* per subset */
-		cb++;
-		if (ab) {
-			ab++;
-		}
-		for (i = 0; i < numep; i+=2) {
-			LOAD(val, 1);
-			for (j = 0; j < 2; j++) {
-				ASSIGN_P(endpoints[i+j].r);
-				ASSIGN_P(endpoints[i+j].g);
-				ASSIGN_P(endpoints[i+j].b);
-				if (ab) {
-					ASSIGN_P(endpoints[i+j].a);
-				}
-			}
-		}
-	}
+    if (info->epb) {
+        /* per endpoint */
+        cb++;
+        if (ab) {
+            ab++;
+        }
+        for (i = 0; i < numep; i++) {
+            LOAD(val, 1);
+            ASSIGN_P(endpoints[i].r);
+            ASSIGN_P(endpoints[i].g);
+            ASSIGN_P(endpoints[i].b);
+            if (ab) {
+                ASSIGN_P(endpoints[i].a);
+            }
+        }
+    }
+    if (info->spb) {
+        /* per subset */
+        cb++;
+        if (ab) {
+            ab++;
+        }
+        for (i = 0; i < numep; i+=2) {
+            LOAD(val, 1);
+            for (j = 0; j < 2; j++) {
+                ASSIGN_P(endpoints[i+j].r);
+                ASSIGN_P(endpoints[i+j].g);
+                ASSIGN_P(endpoints[i+j].b);
+                if (ab) {
+                    ASSIGN_P(endpoints[i+j].a);
+                }
+            }
+        }
+    }
 #undef ASSIGN_P
 #define EXPAND(x, b) x = expand_quantized(x, b)
-	for (i = 0; i < numep; i++) {
-		EXPAND(endpoints[i].r, cb);
-		EXPAND(endpoints[i].g, cb);
-		EXPAND(endpoints[i].b, cb);
-		if (ab) {
-			EXPAND(endpoints[i].a, ab);
-		}
-	}
+    for (i = 0; i < numep; i++) {
+        EXPAND(endpoints[i].r, cb);
+        EXPAND(endpoints[i].g, cb);
+        EXPAND(endpoints[i].b, cb);
+        if (ab) {
+            EXPAND(endpoints[i].a, ab);
+        }
+    }
 #undef EXPAND
 #undef LOAD
-	cibit = bit;
-	aibit = cibit + 16 * info->ib - info->ns;
-	for (i = 0; i < 16; i++) {
-		s = bc7_get_subset(info->ns, partition, i) << 1;
-		ib = info->ib;
-		if (i == 0) {
-			ib--;
-		} else if (info->ns == 2) {
-			if (i == bc7_ai0[partition]) {
-				ib--;
-			}
-		} else if (info->ns == 3) {
-			if (i == bc7_ai1[partition]) {
-				ib--;
-			} else if (i == bc7_ai2[partition]) {
-				ib--;
-			}
-		}
-		i0 = get_bits(src, cibit, ib);
-		cibit += ib;
+    cibit = bit;
+    aibit = cibit + 16 * info->ib - info->ns;
+    for (i = 0; i < 16; i++) {
+        s = bc7_get_subset(info->ns, partition, i) << 1;
+        ib = info->ib;
+        if (i == 0) {
+            ib--;
+        } else if (info->ns == 2) {
+            if (i == bc7_ai0[partition]) {
+                ib--;
+            }
+        } else if (info->ns == 3) {
+            if (i == bc7_ai1[partition]) {
+                ib--;
+            } else if (i == bc7_ai2[partition]) {
+                ib--;
+            }
+        }
+        i0 = get_bits(src, cibit, ib);
+        cibit += ib;
 
-		if (ab && info->ib2) {
-			ib2 = info->ib2;
-			if (ib2 && i == 0) {
-				ib2--;
-			}
-			i1 = get_bits(src, aibit, ib2);
-			aibit += ib2;
-			if (index_sel) {
-				bc7_lerp(&col[i], &endpoints[s], aw[i1], cw[i0]);
-			} else {
-				bc7_lerp(&col[i], &endpoints[s], cw[i0], aw[i1]);
-			}
-		} else {
-			bc7_lerp(&col[i], &endpoints[s], cw[i0], cw[i0]);
-		}
+        if (ab && info->ib2) {
+            ib2 = info->ib2;
+            if (ib2 && i == 0) {
+                ib2--;
+            }
+            i1 = get_bits(src, aibit, ib2);
+            aibit += ib2;
+            if (index_sel) {
+                bc7_lerp(&col[i], &endpoints[s], aw[i1], cw[i0]);
+            } else {
+                bc7_lerp(&col[i], &endpoints[s], cw[i0], aw[i1]);
+            }
+        } else {
+            bc7_lerp(&col[i], &endpoints[s], cw[i0], cw[i0]);
+        }
 #define ROTATE(x, y) \
-		val = x; \
-		x = y; \
-		y = val
-		if (rotation == 1) {
-			ROTATE(col[i].r, col[i].a);
-		} else if (rotation == 2) {
-			ROTATE(col[i].g, col[i].a);
-		} else if (rotation == 3) {
-			ROTATE(col[i].b, col[i].a);
-		}
+        val = x; \
+        x = y; \
+        y = val
+        if (rotation == 1) {
+            ROTATE(col[i].r, col[i].a);
+        } else if (rotation == 2) {
+            ROTATE(col[i].g, col[i].a);
+        } else if (rotation == 3) {
+            ROTATE(col[i].b, col[i].a);
+        }
 #undef ROTATE
-	}
+    }
 }
 
 /* BC6 */
 typedef struct {
-	char ns; /* number of subsets (also called regions) */
-	char tr; /* whether endpoints are delta-compressed */
-	char pb; /* partition bits */
-	char epb; /* endpoint bits */
-	char rb; /* red bits (delta) */
-	char gb; /* green bits (delta) */
-	char bb; /* blue bits (delta) */
+    char ns; /* number of subsets (also called regions) */
+    char tr; /* whether endpoints are delta-compressed */
+    char pb; /* partition bits */
+    char epb; /* endpoint bits */
+    char rb; /* red bits (delta) */
+    char gb; /* green bits (delta) */
+    char bb; /* blue bits (delta) */
 } bc6_mode_info;
 
 static const bc6_mode_info bc6_modes[] = {
-	// 00
-	{2, 1, 5, 10, 5, 5, 5},
-	// 01
-	{2, 1, 5,  7, 6, 6, 6},
-	// 10
-	{2, 1, 5, 11, 5, 4, 4},
-	{2, 1, 5, 11, 4, 5, 4},
-	{2, 1, 5, 11, 4, 4, 5},
-	{2, 1, 5,  9, 5, 5, 5},
-	{2, 1, 5,  8, 6, 5, 5},
-	{2, 1, 5,  8, 5, 6, 5},
-	{2, 1, 5,  8, 5, 5, 6},
-	{2, 0, 5,  6, 6, 6, 6},
-	// 11
-	{1, 0, 0, 10, 10, 10, 10},
-	{1, 1, 0, 11,  9,  9,  9},
-	{1, 1, 0, 12,  8,  8,  8},
-	{1, 1, 0, 16,  4,  4,  4}
+    // 00
+    {2, 1, 5, 10, 5, 5, 5},
+    // 01
+    {2, 1, 5,  7, 6, 6, 6},
+    // 10
+    {2, 1, 5, 11, 5, 4, 4},
+    {2, 1, 5, 11, 4, 5, 4},
+    {2, 1, 5, 11, 4, 4, 5},
+    {2, 1, 5,  9, 5, 5, 5},
+    {2, 1, 5,  8, 6, 5, 5},
+    {2, 1, 5,  8, 5, 6, 5},
+    {2, 1, 5,  8, 5, 5, 6},
+    {2, 0, 5,  6, 6, 6, 6},
+    // 11
+    {1, 0, 0, 10, 10, 10, 10},
+    {1, 1, 0, 11,  9,  9,  9},
+    {1, 1, 0, 12,  8,  8,  8},
+    {1, 1, 0, 16,  4,  4,  4}
 };
 
 /* Table.F, encoded as a sequence of bit indices */
 static const UINT8 bc6_bit_packings[][75] = {
-	{116, 132, 176, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22,
-	 23, 24, 25, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52,
-	 164, 112, 113, 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80,
-	 81, 82, 83, 84, 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144,
-	 145, 146, 147, 148, 175},
-	{117, 164, 165, 0, 1, 2, 3, 4, 5, 6, 172, 173, 132, 16, 17, 18, 19, 20, 21,
-	 22, 133, 174, 116, 32, 33, 34, 35, 36, 37, 38, 175, 177, 176, 48, 49, 50,
-	 51, 52, 53, 112, 113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163,
-	 80, 81, 82, 83, 84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144,
-	 145, 146, 147, 148, 149},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
-	 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 10, 112, 113, 114,
-	 115, 64, 65, 66, 67, 26, 172, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173,
-	 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148,
-	 175},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
-	 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 10, 164, 112, 113, 114,
-	 115, 64, 65, 66, 67, 68, 26, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173,
-	 128, 129, 130, 131, 96, 97, 98, 99, 172, 174, 144, 145, 146, 147, 116,
-	 175},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
-	 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 10, 132, 112, 113, 114,
-	 115, 64, 65, 66, 67, 26, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 42,
-	 128, 129, 130, 131, 96, 97, 98, 99, 173, 174, 144, 145, 146, 147, 176,
-	 175},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 132, 16, 17, 18, 19, 20, 21, 22, 23, 24, 116,
-	 32, 33, 34, 35, 36, 37, 38, 39, 40, 176, 48, 49, 50, 51, 52, 164, 112, 113,
-	 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84,
-	 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148,
-	 175},
-	{0, 1, 2, 3, 4, 5, 6, 7, 164, 132, 16, 17, 18, 19, 20, 21, 22, 23, 174, 116,
-	 32, 33, 34, 35, 36, 37, 38, 39, 175, 176, 48, 49, 50, 51, 52, 53, 112, 113,
-	 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84,
-	 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144, 145, 146, 147, 148,
-	 149},
-	{0, 1, 2, 3, 4, 5, 6, 7, 172, 132, 16, 17, 18, 19, 20, 21, 22, 23, 117, 116,
-	 32, 33, 34, 35, 36, 37, 38, 39, 165, 176, 48, 49, 50, 51, 52, 164, 112,
-	 113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163, 80, 81, 82, 83,
-	 84, 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147,
-	 148, 175},
-	{0, 1, 2, 3, 4, 5, 6, 7, 173, 132, 16, 17, 18, 19, 20, 21, 22, 23, 133, 116,
-	 32, 33, 34, 35, 36, 37, 38, 39, 177, 176, 48, 49, 50, 51, 52, 164, 112,
-	 113, 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83,
-	 84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147,
-	 148, 175},
-	{0, 1, 2, 3, 4, 5, 164, 172, 173, 132, 16, 17, 18, 19, 20, 21, 117, 133,
-	 174, 116, 32, 33, 34, 35, 36, 37, 165, 175, 177, 176, 48, 49, 50, 51, 52,
-	 53, 112, 113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163, 80, 81,
-	 82, 83, 84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144, 145,
-	 146, 147, 148, 149},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
-	 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 80, 81, 82, 83, 84, 85, 86, 87, 88,
-	 89},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
-	 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 10,
-	 64, 65, 66, 67, 68, 69, 70, 71, 72, 26, 80, 81, 82, 83, 84, 85, 86, 87, 88,
-	 42},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
-	 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 11, 10,
-	 64, 65, 66, 67, 68, 69, 70, 71, 27, 26, 80, 81, 82, 83, 84, 85, 86, 87, 43,
-	 42},
-	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
-	 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 15, 14, 13, 12, 11, 10,
-	 64, 65, 66, 67, 31, 30, 29, 28, 27, 26, 80, 81, 82, 83, 47, 46, 45, 44, 43,
-	 42}};
+    {116, 132, 176, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22,
+     23, 24, 25, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52,
+     164, 112, 113, 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80,
+     81, 82, 83, 84, 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144,
+     145, 146, 147, 148, 175},
+    {117, 164, 165, 0, 1, 2, 3, 4, 5, 6, 172, 173, 132, 16, 17, 18, 19, 20, 21,
+     22, 133, 174, 116, 32, 33, 34, 35, 36, 37, 38, 175, 177, 176, 48, 49, 50,
+     51, 52, 53, 112, 113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163,
+     80, 81, 82, 83, 84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144,
+     145, 146, 147, 148, 149},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 10, 112, 113, 114,
+     115, 64, 65, 66, 67, 26, 172, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173,
+     128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148,
+     175},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 10, 164, 112, 113, 114,
+     115, 64, 65, 66, 67, 68, 26, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173,
+     128, 129, 130, 131, 96, 97, 98, 99, 172, 174, 144, 145, 146, 147, 116,
+     175},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 10, 132, 112, 113, 114,
+     115, 64, 65, 66, 67, 26, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 42,
+     128, 129, 130, 131, 96, 97, 98, 99, 173, 174, 144, 145, 146, 147, 176,
+     175},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 132, 16, 17, 18, 19, 20, 21, 22, 23, 24, 116,
+     32, 33, 34, 35, 36, 37, 38, 39, 40, 176, 48, 49, 50, 51, 52, 164, 112, 113,
+     114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84,
+     173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148,
+     175},
+    {0, 1, 2, 3, 4, 5, 6, 7, 164, 132, 16, 17, 18, 19, 20, 21, 22, 23, 174, 116,
+     32, 33, 34, 35, 36, 37, 38, 39, 175, 176, 48, 49, 50, 51, 52, 53, 112, 113,
+     114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84,
+     173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144, 145, 146, 147, 148,
+     149},
+    {0, 1, 2, 3, 4, 5, 6, 7, 172, 132, 16, 17, 18, 19, 20, 21, 22, 23, 117, 116,
+     32, 33, 34, 35, 36, 37, 38, 39, 165, 176, 48, 49, 50, 51, 52, 164, 112,
+     113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163, 80, 81, 82, 83,
+     84, 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147,
+     148, 175},
+    {0, 1, 2, 3, 4, 5, 6, 7, 173, 132, 16, 17, 18, 19, 20, 21, 22, 23, 133, 116,
+     32, 33, 34, 35, 36, 37, 38, 39, 177, 176, 48, 49, 50, 51, 52, 164, 112,
+     113, 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83,
+     84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147,
+     148, 175},
+    {0, 1, 2, 3, 4, 5, 164, 172, 173, 132, 16, 17, 18, 19, 20, 21, 117, 133,
+     174, 116, 32, 33, 34, 35, 36, 37, 165, 175, 177, 176, 48, 49, 50, 51, 52,
+     53, 112, 113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163, 80, 81,
+     82, 83, 84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144, 145,
+     146, 147, 148, 149},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+     64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+     89},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 10,
+     64, 65, 66, 67, 68, 69, 70, 71, 72, 26, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+     42},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 11, 10,
+     64, 65, 66, 67, 68, 69, 70, 71, 27, 26, 80, 81, 82, 83, 84, 85, 86, 87, 43,
+     42},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 15, 14, 13, 12, 11, 10,
+     64, 65, 66, 67, 31, 30, 29, 28, 27, 26, 80, 81, 82, 83, 47, 46, 45, 44, 43,
+     42}};
 
 static void bc6_sign_extend(UINT16 *v, int prec) {
-	int x = *v;
-	if (x & (1 << (prec - 1))) {
-		x |= -1 << prec;
-	}
-	*v = (UINT16)x;
+    int x = *v;
+    if (x & (1 << (prec - 1))) {
+        x |= -1 << prec;
+    }
+    *v = (UINT16)x;
 }
 
 static int bc6_unquantize(UINT16 v, int prec, int sign) {
-	int s = 0;
-	int x;
-	if (!sign) {
-		x = v;
-		if (prec >= 15) return x;
-		if (x == 0) return 0;
-		if (x == ((1 << prec) - 1)) {
-			return 0xffff;
-		}
-		return ((x << 15) + 0x4000) >> (prec - 1);
-	} else {
-		x = (INT16)v;
-		if (prec >= 16) return x;
-		if (x < 0) {
-			s = 1;
-			x = -x;
-		}
+    int s = 0;
+    int x;
+    if (!sign) {
+        x = v;
+        if (prec >= 15) return x;
+        if (x == 0) return 0;
+        if (x == ((1 << prec) - 1)) {
+            return 0xffff;
+        }
+        return ((x << 15) + 0x4000) >> (prec - 1);
+    } else {
+        x = (INT16)v;
+        if (prec >= 16) return x;
+        if (x < 0) {
+            s = 1;
+            x = -x;
+        }
 
-		if (x != 0) {
-			if (x >= ((1 << (prec - 1)) - 1)) {
-				x = 0x7fff;
-			} else {
-				x = ((x << 15) + 0x4000) >> (prec - 1);
-			}
-		}
+        if (x != 0) {
+            if (x >= ((1 << (prec - 1)) - 1)) {
+                x = 0x7fff;
+            } else {
+                x = ((x << 15) + 0x4000) >> (prec - 1);
+            }
+        }
 
-		if (s) {
-			return -x;
-		}
-		return x;
-	}
+        if (s) {
+            return -x;
+        }
+        return x;
+    }
 }
 
 static float half_to_float(UINT16 h) {
-	/* https://gist.github.com/rygorous/2144712 */
-	union {
-		UINT32 u;
-		float f;
-	} o, m;
-	m.u = 0x77800000;
-	o.u = (h & 0x7fff) << 13;
-	o.f *= m.f;
-	m.u = 0x47800000;
-	if (o.f >= m.f) {
-		o.u |= 255 << 23;
-	}
-	o.u |= (h & 0x8000) << 16;
-	return o.f;
+    /* https://gist.github.com/rygorous/2144712 */
+    union {
+        UINT32 u;
+        float f;
+    } o, m;
+    m.u = 0x77800000;
+    o.u = (h & 0x7fff) << 13;
+    o.f *= m.f;
+    m.u = 0x47800000;
+    if (o.f >= m.f) {
+        o.u |= 255 << 23;
+    }
+    o.u |= (h & 0x8000) << 16;
+    return o.f;
 }
 
 static float bc6_finalize(int v, int sign) {
-	if (sign) {
-		if (v < 0) {
-			v = ((-v) * 31) / 32;
-			return half_to_float((UINT16)(0x8000 | v));
-		} else {
-			return half_to_float((UINT16)((v * 31) / 32));
-		}
-	} else {
-		return half_to_float((UINT16)((v * 31) / 64));
-	}
+    if (sign) {
+        if (v < 0) {
+            v = ((-v) * 31) / 32;
+            return half_to_float((UINT16)(0x8000 | v));
+        } else {
+            return half_to_float((UINT16)((v * 31) / 32));
+        }
+    } else {
+        return half_to_float((UINT16)((v * 31) / 64));
+    }
 }
 
 static void bc6_lerp(rgb32f *col, int *e0, int *e1, int s, int sign) {
-	int r, g, b;
-	int t = 64 - s;
-	r = (e0[0] * t + e1[0] * s) >> 6;
-	g = (e0[1] * t + e1[1] * s) >> 6;
-	b = (e0[2] * t + e1[2] * s) >> 6;
-	col->r = bc6_finalize(r, sign);
-	col->g = bc6_finalize(g, sign);
-	col->b = bc6_finalize(b, sign);
+    int r, g, b;
+    int t = 64 - s;
+    r = (e0[0] * t + e1[0] * s) >> 6;
+    g = (e0[1] * t + e1[1] * s) >> 6;
+    b = (e0[2] * t + e1[2] * s) >> 6;
+    col->r = bc6_finalize(r, sign);
+    col->g = bc6_finalize(g, sign);
+    col->b = bc6_finalize(b, sign);
 }
 
 static void decode_bc6_block(rgb32f *col, const UINT8* src, int sign) {
-	UINT16 endpoints[12]; /* storage for r0, g0, b0, r1, ... */
-	int ueps[12];
-	int i, i0, ib2, di, dw, mask, numep, s;
-	UINT8 partition;
-	const bc6_mode_info *info;
-	const char *cw;
-	int bit = 5;
-	int epbits = 75;
-	int ib = 3;
-	int mode = src[0] & 0x1f;
-	if ((mode & 3) == 0 || (mode & 3) == 1) {
-		mode &= 3;
-		bit = 2;
-	} else if ((mode & 3) == 2) {
-		mode = 2 + (mode >> 2);
-		epbits = 72;
-	} else {
-		mode = 10 + (mode >> 2);
-		epbits = 60;
-		ib = 4;
-	}
-	if (mode >= 14) {
-		/* invalid block */
-		memset(col, 0, 16 * sizeof(col[0]));
-		return;
-	}
-	info = &bc6_modes[mode];
-	cw = bc7_get_weights(ib);
-	numep = info->ns == 2 ? 12 : 6;
-	for (i = 0; i < 12; i++) {
-		endpoints[i] = 0;
-	}
-	for (i = 0; i < epbits; i++) {
-		di = bc6_bit_packings[mode][i];
-		dw = di >> 4;
-		di &= 15;
-		endpoints[dw] |= (UINT16)get_bit(src, bit + i) << di;
-	}
-	bit += epbits;
-	partition = get_bits(src, bit, info->pb);
-	bit += info->pb;
-	mask = (1 << info->epb) - 1;
-	if (sign) { /* sign-extend e0 if signed */
-		bc6_sign_extend(&endpoints[0], info->epb);
-		bc6_sign_extend(&endpoints[1], info->epb);
-		bc6_sign_extend(&endpoints[2], info->epb);
-	}
-	if (sign || info->tr) { /* sign-extend e1,2,3 if signed or deltas */
-		for (i = 3; i < numep; i += 3) {
-			bc6_sign_extend(&endpoints[i+0], info->rb);
-			bc6_sign_extend(&endpoints[i+1], info->gb);
-			bc6_sign_extend(&endpoints[i+2], info->bb);
-		}
-	}
-	if (info->tr) { /* apply deltas */
-		for (i = 3; i < numep; i++) {
-			endpoints[i] = (endpoints[i] + endpoints[0]) & mask;
-		}
-		if (sign) {
-			for (i = 3; i < numep; i += 3) {
-				bc6_sign_extend(&endpoints[i+0], info->rb);
-				bc6_sign_extend(&endpoints[i+1], info->gb);
-				bc6_sign_extend(&endpoints[i+2], info->bb);
-			}
-		}
-	}
-	for (i = 0; i < numep; i++) {
-		ueps[i] = bc6_unquantize(endpoints[i], info->epb, sign);
-	}
-	for (i = 0; i < 16; i++) {
-		s = bc7_get_subset(info->ns, partition, i) * 6;
-		ib2 = ib;
-		if (i == 0) {
-			ib2--;
-		} else if (info->ns == 2) {
-			if (i == bc7_ai0[partition]) {
-				ib2--;
-			}
-		}
-		i0 = get_bits(src, bit, ib2);
-		bit += ib2;
+    UINT16 endpoints[12]; /* storage for r0, g0, b0, r1, ... */
+    int ueps[12];
+    int i, i0, ib2, di, dw, mask, numep, s;
+    UINT8 partition;
+    const bc6_mode_info *info;
+    const char *cw;
+    int bit = 5;
+    int epbits = 75;
+    int ib = 3;
+    int mode = src[0] & 0x1f;
+    if ((mode & 3) == 0 || (mode & 3) == 1) {
+        mode &= 3;
+        bit = 2;
+    } else if ((mode & 3) == 2) {
+        mode = 2 + (mode >> 2);
+        epbits = 72;
+    } else {
+        mode = 10 + (mode >> 2);
+        epbits = 60;
+        ib = 4;
+    }
+    if (mode >= 14) {
+        /* invalid block */
+        memset(col, 0, 16 * sizeof(col[0]));
+        return;
+    }
+    info = &bc6_modes[mode];
+    cw = bc7_get_weights(ib);
+    numep = info->ns == 2 ? 12 : 6;
+    for (i = 0; i < 12; i++) {
+        endpoints[i] = 0;
+    }
+    for (i = 0; i < epbits; i++) {
+        di = bc6_bit_packings[mode][i];
+        dw = di >> 4;
+        di &= 15;
+        endpoints[dw] |= (UINT16)get_bit(src, bit + i) << di;
+    }
+    bit += epbits;
+    partition = get_bits(src, bit, info->pb);
+    bit += info->pb;
+    mask = (1 << info->epb) - 1;
+    if (sign) { /* sign-extend e0 if signed */
+        bc6_sign_extend(&endpoints[0], info->epb);
+        bc6_sign_extend(&endpoints[1], info->epb);
+        bc6_sign_extend(&endpoints[2], info->epb);
+    }
+    if (sign || info->tr) { /* sign-extend e1,2,3 if signed or deltas */
+        for (i = 3; i < numep; i += 3) {
+            bc6_sign_extend(&endpoints[i+0], info->rb);
+            bc6_sign_extend(&endpoints[i+1], info->gb);
+            bc6_sign_extend(&endpoints[i+2], info->bb);
+        }
+    }
+    if (info->tr) { /* apply deltas */
+        for (i = 3; i < numep; i++) {
+            endpoints[i] = (endpoints[i] + endpoints[0]) & mask;
+        }
+        if (sign) {
+            for (i = 3; i < numep; i += 3) {
+                bc6_sign_extend(&endpoints[i+0], info->rb);
+                bc6_sign_extend(&endpoints[i+1], info->gb);
+                bc6_sign_extend(&endpoints[i+2], info->bb);
+            }
+        }
+    }
+    for (i = 0; i < numep; i++) {
+        ueps[i] = bc6_unquantize(endpoints[i], info->epb, sign);
+    }
+    for (i = 0; i < 16; i++) {
+        s = bc7_get_subset(info->ns, partition, i) * 6;
+        ib2 = ib;
+        if (i == 0) {
+            ib2--;
+        } else if (info->ns == 2) {
+            if (i == bc7_ai0[partition]) {
+                ib2--;
+            }
+        }
+        i0 = get_bits(src, bit, ib2);
+        bit += ib2;
 
-		bc6_lerp(&col[i], &ueps[s], &ueps[s+3], cw[i0], sign);
-	}
+        bc6_lerp(&col[i], &ueps[s], &ueps[s+3], cw[i0], sign);
+    }
 }
 
 static void put_block(Imaging im, ImagingCodecState state, const char *col, int sz, int C) {
-	int width = state->xsize;
-	int height = state->ysize;
-	int xmax = width + state->xoff;
-	int ymax = height + state->yoff;
-	int j, i, y, x;
-	char *dst;
-	for (j = 0; j < 4; j++) {
-		y = state->y + j;
-		if (C) {
-			if (y >= height) {
-				continue;
-			}
-			if (state->ystep < 0) {
-				y = state->yoff + ymax - y - 1;
-			}
-			dst = im->image[y];
-			for (i = 0; i < 4; i++) {
-				x = state->x + i;
-				if (x >= width) {
-					continue;
-				}
-				memcpy(dst + sz*x, col + sz*(j*4 + i), sz);
-			}
-		} else {
-			if (state->ystep < 0) {
-				y = state->yoff + ymax - y - 1;
-			}
-			x = state->x;
-			dst = im->image[y] + sz*x;
-			memcpy(dst, col + sz*(j*4), 4 * sz);
-		}
-	}
-	state->x += 4;
-	if (state->x >= xmax) {
-		state->y += 4;
-		state->x = state->xoff;
-	}
+    int width = state->xsize;
+    int height = state->ysize;
+    int xmax = width + state->xoff;
+    int ymax = height + state->yoff;
+    int j, i, y, x;
+    char *dst;
+    for (j = 0; j < 4; j++) {
+        y = state->y + j;
+        if (C) {
+            if (y >= height) {
+                continue;
+            }
+            if (state->ystep < 0) {
+                y = state->yoff + ymax - y - 1;
+            }
+            dst = im->image[y];
+            for (i = 0; i < 4; i++) {
+                x = state->x + i;
+                if (x >= width) {
+                    continue;
+                }
+                memcpy(dst + sz*x, col + sz*(j*4 + i), sz);
+            }
+        } else {
+            if (state->ystep < 0) {
+                y = state->yoff + ymax - y - 1;
+            }
+            x = state->x;
+            dst = im->image[y] + sz*x;
+            memcpy(dst, col + sz*(j*4), 4 * sz);
+        }
+    }
+    state->x += 4;
+    if (state->x >= xmax) {
+        state->y += 4;
+        state->x = state->xoff;
+    }
 }
 
 static int decode_bcn(Imaging im, ImagingCodecState state, const UINT8* src, int bytes, int N, int C) {
-	int ymax = state->ysize + state->yoff;
-	const UINT8 *ptr = src;
-	switch (N) {
+    int ymax = state->ysize + state->yoff;
+    const UINT8 *ptr = src;
+    switch (N) {
 #define DECODE_LOOP(NN, SZ, TY, ...) \
-	case NN: \
-		while (bytes >= SZ) { \
-			TY col[16]; \
-			memset(col, 0, 16 * sizeof(col[0])); \
-			decode_bc##NN##_block(col, ptr); \
-			put_block(im, state, (const char *)col, sizeof(col[0]), C); \
-			ptr += SZ; \
-			bytes -= SZ; \
-			if (state->y >= ymax) return -1; \
-		} \
-		break
-	DECODE_LOOP(1, 8, rgba);
-	DECODE_LOOP(2, 16, rgba);
-	DECODE_LOOP(3, 16, rgba);
-	DECODE_LOOP(4, 8, lum);
-	DECODE_LOOP(5, 16, rgba);
-	case 6:
-		while (bytes >= 16) {
-			rgb32f col[16];
-			decode_bc6_block(col, ptr, (state->state >> 4) & 1);
-			put_block(im, state, (const char *)col, sizeof(col[0]), C);
-			ptr += 16;
-			bytes -= 16;
-			if (state->y >= ymax) return -1; \
-		}
-		break;
-	DECODE_LOOP(7, 16, rgba);
+    case NN: \
+        while (bytes >= SZ) { \
+            TY col[16]; \
+            memset(col, 0, 16 * sizeof(col[0])); \
+            decode_bc##NN##_block(col, ptr); \
+            put_block(im, state, (const char *)col, sizeof(col[0]), C); \
+            ptr += SZ; \
+            bytes -= SZ; \
+            if (state->y >= ymax) return -1; \
+        } \
+        break
+
+        DECODE_LOOP(1, 8, rgba);
+        DECODE_LOOP(2, 16, rgba);
+        DECODE_LOOP(3, 16, rgba);
+        DECODE_LOOP(4, 8, lum);
+        DECODE_LOOP(5, 16, rgba);
+        case 6:
+            while (bytes >= 16) {
+                rgb32f col[16];
+                decode_bc6_block(col, ptr, (state->state >> 4) & 1);
+                put_block(im, state, (const char *)col, sizeof(col[0]), C);
+                ptr += 16;
+                bytes -= 16;
+                if (state->y >= ymax) return -1; \
+            }
+            break;
+        DECODE_LOOP(7, 16, rgba);
 #undef DECODE_LOOP
-	}
-	return (int)(ptr - src);
+    }
+    return (int)(ptr - src);
 }
 
 int ImagingBcnDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes) {
-	int N = state->state & 0xf;
-	int width = state->xsize;
-	int height = state->ysize;
-	if ((width & 3) | (height & 3)) {
-		return decode_bcn(im, state, buf, bytes, N, 1);
-	} else {
-		return decode_bcn(im, state, buf, bytes, N, 0);
-	}
+    int N = state->state & 0xf;
+    int width = state->xsize;
+    int height = state->ysize;
+    if ((width & 3) | (height & 3)) {
+        return decode_bcn(im, state, buf, bytes, N, 1);
+    } else {
+        return decode_bcn(im, state, buf, bytes, N, 0);
+    }
 }
diff --git a/src/libImaging/BitDecode.c b/src/libImaging/BitDecode.c
index 7120b3321..97d263c0b 100644
--- a/src/libImaging/BitDecode.c
+++ b/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;
-	    return -1;
+            state->errcode = IMAGING_CODEC_CONFIG;
+            return -1;
         }
 
         /* sanity check */
         if (bitstate->bits < 1 || bitstate->bits >= 32) {
-	    state->errcode = IMAGING_CODEC_CONFIG;
-	    return -1;
+            state->errcode = IMAGING_CODEC_CONFIG;
+            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 */
-	if (state->ystep < 0) {
-	    state->y = state->ysize-1;
-	    state->ystep = -1;
-	} else
-	    state->ystep = 1;
+        /* check image orientation */
+        if (state->ystep < 0) {
+            state->y = state->ysize-1;
+            state->ystep = -1;
+        } else
+            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) {
diff --git a/src/libImaging/Blend.c b/src/libImaging/Blend.c
index 19a080d6d..caaf2ba8b 100644
--- a/src/libImaging/Blend.c
+++ b/src/libImaging/Blend.c
@@ -5,9 +5,9 @@
  * interpolate between two existing images
  *
  * history:
- * 96-03-20 fl	Created
- * 96-05-18 fl	Simplified blend expression
- * 96-10-05 fl	Fixed expression bug, special case for interpolation
+ * 96-03-20 fl Created
+ * 96-05-18 fl Simplified blend expression
+ * 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->xsize != imIn2->xsize ||
-	imIn1->ysize != imIn2->ysize)
-	return ImagingError_Mismatch();
+        imIn1->bands != imIn2->bands ||
+        imIn1->xsize != imIn2->xsize ||
+        imIn1->ysize != imIn2->ysize)
+        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 */
-	for (y = 0; y < imIn1->ysize; y++) {
-	    UINT8* in1 = (UINT8*) imIn1->image[y];
-	    UINT8* in2 = (UINT8*) imIn2->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
-	    for (x = 0; x < imIn1->linesize; x++)
-		out[x] = (UINT8)
-		    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
-	}
+        /* Interpolate between bands */
+        for (y = 0; y < imIn1->ysize; y++) {
+            UINT8* in1 = (UINT8*) imIn1->image[y];
+            UINT8* in2 = (UINT8*) imIn2->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
+            for (x = 0; x < imIn1->linesize; x++)
+                out[x] = (UINT8)
+                    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
+        }
     } else {
-	/* Extrapolation; must make sure to clip resulting values */
-	for (y = 0; y < imIn1->ysize; y++) {
-	    UINT8* in1 = (UINT8*) imIn1->image[y];
-	    UINT8* in2 = (UINT8*) imIn2->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
-	    for (x = 0; x < imIn1->linesize; x++) {
-		float temp = (float)
-		    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
-		if (temp <= 0.0)
-		    out[x] = 0;
-		else if (temp >= 255.0)
-		    out[x] = 255;
-		else
-		    out[x] = (UINT8) temp;
-	    }
-	}
+        /* Extrapolation; must make sure to clip resulting values */
+        for (y = 0; y < imIn1->ysize; y++) {
+            UINT8* in1 = (UINT8*) imIn1->image[y];
+            UINT8* in2 = (UINT8*) imIn2->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
+            for (x = 0; x < imIn1->linesize; x++) {
+                float temp = (float)
+                    ((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
+                if (temp <= 0.0)
+                    out[x] = 0;
+                else if (temp >= 255.0)
+                    out[x] = 255;
+                else
+                    out[x] = (UINT8) temp;
+            }
+        }
     }
 
     return imOut;
diff --git a/src/libImaging/ConvertYCbCr.c b/src/libImaging/ConvertYCbCr.c
index 6ce549111..47de4ff71 100644
--- a/src/libImaging/ConvertYCbCr.c
+++ b/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
  *
diff --git a/src/libImaging/Copy.c b/src/libImaging/Copy.c
index 1bc9b1a70..e0bdaf63e 100644
--- a/src/libImaging/Copy.c
+++ b/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);
diff --git a/src/libImaging/Crop.c b/src/libImaging/Crop.c
index 4407c1b1d..a2b679681 100644
--- a/src/libImaging/Crop.c
+++ b/src/libImaging/Crop.c
@@ -5,9 +5,9 @@
  * cut region from image
  *
  * history:
- * 95-11-27 fl	Created
- * 98-07-10 fl	Fixed "null result" error
- * 99-02-05 fl	Rewritten to use Paste primitive
+ * 95-11-27 fl Created
+ * 98-07-10 fl Fixed "null result" error
+ * 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;
diff --git a/src/libImaging/EpsEncode.c b/src/libImaging/EpsEncode.c
index 45fab0a6e..2a6aad4a3 100644
--- a/src/libImaging/EpsEncode.c
+++ b/src/libImaging/EpsEncode.c
@@ -5,11 +5,11 @@
  * encoder for EPS hex data
  *
  * history:
- *	96-04-19 fl	created
- *	96-06-27 fl	don't drop last block of encoded data
+ * 96-04-19 fl created
+ * 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->xsize *= im->pixelsize; /* Hack! */
+        state->state = HEXBYTE;
+        state->xsize *= im->pixelsize; /* Hack! */
     }
 
     in = (UINT8*) im->image[state->y];
 
     for (;;) {
 
-	if (state->state == NEWLINE) {
-	    if (bytes < 1)
-		break;
-	    *ptr++ = '\n';
-	    bytes--;
-	    state->state = HEXBYTE;
-	}
+        if (state->state == NEWLINE) {
+            if (bytes < 1)
+                break;
+            *ptr++ = '\n';
+            bytes--;
+            state->state = HEXBYTE;
+        }
 
-	if (bytes < 2)
-	    break;
+        if (bytes < 2)
+            break;
 
-	i = in[state->x++];
-	*ptr++ = hex[(i>>4)&15];
-	*ptr++ = hex[i&15];
-	bytes -= 2;
+        i = in[state->x++];
+        *ptr++ = hex[(i>>4)&15];
+        *ptr++ = hex[i&15];
+        bytes -= 2;
 
-	/* Skip junk bytes */
-	if (im->bands == 3 && (state->x & 3) == 3)
-	    state->x++;
+        /* Skip junk bytes */
+        if (im->bands == 3 && (state->x & 3) == 3)
+            state->x++;
 
-	if (++state->count >= 79/2) {
-	    state->state = NEWLINE;
-	    state->count = 0;
-	}
+        if (++state->count >= 79/2) {
+            state->state = NEWLINE;
+            state->count = 0;
+        }
 
-	if (state->x >= state->xsize) {
-	    state->x = 0;
-	    if (++state->y >= state->ysize) {
-		state->errcode = IMAGING_CODEC_END;
-		break;
-	    }
-	    in = (UINT8*) im->image[state->y];
-	}
+        if (state->x >= state->xsize) {
+            state->x = 0;
+            if (++state->y >= state->ysize) {
+                state->errcode = IMAGING_CODEC_END;
+                break;
+            }
+            in = (UINT8*) im->image[state->y];
+        }
 
     }
 
diff --git a/src/libImaging/Except.c b/src/libImaging/Except.c
index d6d2b2186..4850b4f87 100644
--- a/src/libImaging/Except.c
+++ b/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;
 }
diff --git a/src/libImaging/Fill.c b/src/libImaging/Fill.c
index d641a5996..27022bc48 100644
--- a/src/libImaging/Fill.c
+++ b/src/libImaging/Fill.c
@@ -5,9 +5,9 @@
  * fill image with constant pixel value
  *
  * history:
- * 95-11-26 fl	moved from Imaging.c
- * 96-05-17 fl	added radial fill, renamed wedge to linear
- * 98-06-23 fl	changed ImageFill signature
+ * 95-11-26 fl moved from Imaging.c
+ * 96-05-17 fl added radial fill, renamed wedge to linear
+ * 98-06-23 fl changed ImageFill signature
  *
  * Copyright (c) Secret Labs AB 1997-98.  All rights reserved.
  * Copyright (c) Fredrik Lundh 1995-96.
diff --git a/src/libImaging/FliDecode.c b/src/libImaging/FliDecode.c
index 108e1edf9..5351d5664 100644
--- a/src/libImaging/FliDecode.c
+++ b/src/libImaging/FliDecode.c
@@ -5,8 +5,8 @@
  * decoder for Autodesk Animator FLI/FLC animations
  *
  * history:
- *	97-01-03 fl	Created
- *	97-01-17 fl	Added SS2 support (FLC)
+ * 97-01-03 fl Created
+ * 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;
-	return -1;
+        state->errcode = IMAGING_CODEC_UNKNOWN;
+        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;
-	if (bytes < 10) {
-	    state->errcode = IMAGING_CODEC_OVERRUN;
-	    return -1;
-	}
-	data = ptr + 6;
-	switch (I16(ptr+4)) {
-	case 4: case 11:
-	    /* FLI COLOR chunk */
-	    break; /* ignored; handled by Python code */
-	case 7:
-	    /* FLI SS2 chunk (word delta) */
-	    /* OOB ok, we've got 4 bytes min on entry */
-	    lines = I16(data); data += 2;
-	    for (l = y = 0; l < lines && y < state->ysize; l++, y++) {
-		UINT8* local_buf = (UINT8*) im->image[y];
-		int p, packets;
-		ERR_IF_DATA_OOB(2)
-		packets = I16(data); data += 2;
-		while (packets & 0x8000) {
-		    /* flag word */
-		    if (packets & 0x4000) {
-			y += 65536 - packets; /* skip lines */
-			if (y >= state->ysize) {
-			    state->errcode = IMAGING_CODEC_OVERRUN;
-			    return -1;
-			}
-			local_buf = (UINT8*) im->image[y];
-		    } else {
-			/* store last byte (used if line width is odd) */
-			local_buf[state->xsize-1] = (UINT8) packets;
-		    }
-		    ERR_IF_DATA_OOB(2)
-		    packets = I16(data); data += 2;
-		}
-		for (p = x = 0; p < packets; p++) {
-		    ERR_IF_DATA_OOB(2)
-		    x += data[0]; /* pixel skip */
-		    if (data[1] >= 128) {
-			ERR_IF_DATA_OOB(4)
-			i = 256-data[1]; /* run */
-			if (x + i + i > state->xsize)
-			    break;
-			for (j = 0; j < i; j++) {
-			    local_buf[x++] = data[2];
-			    local_buf[x++] = data[3];
-			}
-			data += 2 + 2;
-		    } else {
-			i = 2 * (int) data[1]; /* chunk */
-			if (x + i > state->xsize)
-			    break;
-			ERR_IF_DATA_OOB(2+i)
-			memcpy(local_buf + x, data + 2, i);
-			data += 2 + i;
-			x += i;
-		    }
-		}
-		if (p < packets)
-		    break; /* didn't process all packets */
-	    }
-	    if (l < lines) {
-		/* didn't process all lines */
-		state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
-	    }
-	    break;
-	case 12:
-	    /* FLI LC chunk (byte delta) */
-	    /* OOB Check ok, we have 4 bytes min here */
-	    y = I16(data); ymax = y + I16(data+2); data += 4;
-	    for (; y < ymax && y < state->ysize; y++) {
-		UINT8* out = (UINT8*) im->image[y];
-                ERR_IF_DATA_OOB(1)
-		int p, packets = *data++;
-		for (p = x = 0; p < packets; p++, x += i) {
-		    ERR_IF_DATA_OOB(2)
-		    x += data[0]; /* skip pixels */
-		    if (data[1] & 0x80) {
-			i = 256-data[1]; /* run */
-			if (x + i > state->xsize)
-			    break;
-			ERR_IF_DATA_OOB(3)
-			memset(out + x, data[2], i);
-			data += 3;
-		    } else {
-			i = data[1]; /* chunk */
-			if (x + i > state->xsize)
-			    break;
-			ERR_IF_DATA_OOB(2+i)
-			memcpy(out + x, data + 2, i);
-			data += i + 2;
-		    }
-		}
-		if (p < packets)
-		    break; /* didn't process all packets */
-	    }
-	    if (y < ymax) {
-		/* didn't process all lines */
-		state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
-	    }
-	    break;
-	case 13:
-	    /* FLI BLACK chunk */
-	    for (y = 0; y < state->ysize; y++)
-		memset(im->image[y], 0, state->xsize);
-	    break;
-	case 15:
-	    /* FLI BRUN chunk */
-	    /* OOB, ok, we've got 4 bytes min on entry */
-	    for (y = 0; y < state->ysize; y++) {
-		UINT8* out = (UINT8*) im->image[y];
-		data += 1; /* ignore packetcount byte */
-		for (x = 0; x < state->xsize; x += i) {
-		    ERR_IF_DATA_OOB(2)
-		    if (data[0] & 0x80) {
-			i = 256 - data[0];
-			if (x + i > state->xsize) {
-			    break; /* safety first */
-			}
-			ERR_IF_DATA_OOB(i+1)
-			memcpy(out + x, data + 1, i);
-			data += i + 1;
-		    } else {
-			i = data[0];
-			if (x + i > state->xsize)
-			    break; /* safety first */
-			memset(out + x, data[1], i);
-			data += 2;
-		    }
-		}
-		if (x != state->xsize) {
-		    /* didn't unpack whole line */
-		    state->errcode = IMAGING_CODEC_OVERRUN;
-		    return -1;
-		}
-	    }
-	    break;
-	case 16:
-	    /* COPY chunk */
-	    if (state->xsize > bytes/state->ysize) {
-		/* not enough data for frame */
-		return ptr - buf; /* bytes consumed */
-	    }
-	    for (y = 0; y < state->ysize; y++) {
-		UINT8* local_buf = (UINT8*) im->image[y];
-		memcpy(local_buf, data, state->xsize);
-		data += state->xsize;
-	    }
-	    break;
-	case 18:
-	    /* PSTAMP chunk */
-	    break; /* ignored */
-	default:
-	    /* unknown chunk */
-	    /* printf("unknown FLI/FLC chunk: %d\n", I16(ptr+4)); */
-	    state->errcode = IMAGING_CODEC_UNKNOWN;
-	    return -1;
-	}
-	advance = I32(ptr);
-	if (advance < 0 || advance > bytes) {
-	    state->errcode = IMAGING_CODEC_OVERRUN;
-	    return -1;
-	}
-	ptr += advance;
-	bytes -= advance;
+        UINT8* data;
+        if (bytes < 10) {
+            state->errcode = IMAGING_CODEC_OVERRUN;
+            return -1;
+        }
+        data = ptr + 6;
+        switch (I16(ptr+4)) {
+            case 4: case 11:
+                /* FLI COLOR chunk */
+                break; /* ignored; handled by Python code */
+            case 7:
+                /* FLI SS2 chunk (word delta) */
+                /* OOB ok, we've got 4 bytes min on entry */
+                lines = I16(data); data += 2;
+                for (l = y = 0; l < lines && y < state->ysize; l++, y++) {
+                    UINT8* local_buf = (UINT8*) im->image[y];
+                    int p, packets;
+                    ERR_IF_DATA_OOB(2)
+                    packets = I16(data); data += 2;
+                    while (packets & 0x8000) {
+                        /* flag word */
+                        if (packets & 0x4000) {
+                            y += 65536 - packets; /* skip lines */
+                            if (y >= state->ysize) {
+                                state->errcode = IMAGING_CODEC_OVERRUN;
+                                return -1;
+                            }
+                            local_buf = (UINT8*) im->image[y];
+                        } else {
+                            /* store last byte (used if line width is odd) */
+                            local_buf[state->xsize-1] = (UINT8) packets;
+                        }
+                        ERR_IF_DATA_OOB(2)
+                        packets = I16(data); data += 2;
+                    }
+                    for (p = x = 0; p < packets; p++) {
+                        ERR_IF_DATA_OOB(2)
+                        x += data[0]; /* pixel skip */
+                        if (data[1] >= 128) {
+                            ERR_IF_DATA_OOB(4)
+                            i = 256-data[1]; /* run */
+                            if (x + i + i > state->xsize)
+                                break;
+                            for (j = 0; j < i; j++) {
+                                local_buf[x++] = data[2];
+                                local_buf[x++] = data[3];
+                            }
+                            data += 2 + 2;
+                        } else {
+                            i = 2 * (int) data[1]; /* chunk */
+                            if (x + i > state->xsize)
+                                break;
+                            ERR_IF_DATA_OOB(2+i)
+                            memcpy(local_buf + x, data + 2, i);
+                            data += 2 + i;
+                            x += i;
+                        }
+                    }
+                    if (p < packets)
+                        break; /* didn't process all packets */
+                }
+                if (l < lines) {
+                    /* didn't process all lines */
+                    state->errcode = IMAGING_CODEC_OVERRUN;
+                    return -1;
+                }
+                break;
+            case 12:
+                /* FLI LC chunk (byte delta) */
+                /* OOB Check ok, we have 4 bytes min here */
+                y = I16(data); ymax = y + I16(data+2); data += 4;
+                for (; y < ymax && y < state->ysize; y++) {
+                    UINT8* out = (UINT8*) im->image[y];
+                            ERR_IF_DATA_OOB(1)
+                    int p, packets = *data++;
+                    for (p = x = 0; p < packets; p++, x += i) {
+                        ERR_IF_DATA_OOB(2)
+                        x += data[0]; /* skip pixels */
+                        if (data[1] & 0x80) {
+                            i = 256-data[1]; /* run */
+                            if (x + i > state->xsize)
+                                break;
+                            ERR_IF_DATA_OOB(3)
+                            memset(out + x, data[2], i);
+                            data += 3;
+                        } else {
+                            i = data[1]; /* chunk */
+                            if (x + i > state->xsize)
+                                break;
+                            ERR_IF_DATA_OOB(2+i)
+                            memcpy(out + x, data + 2, i);
+                            data += i + 2;
+                        }
+                    }
+                    if (p < packets)
+                        break; /* didn't process all packets */
+                }
+                if (y < ymax) {
+                    /* didn't process all lines */
+                    state->errcode = IMAGING_CODEC_OVERRUN;
+                    return -1;
+                }
+                break;
+            case 13:
+                /* FLI BLACK chunk */
+                for (y = 0; y < state->ysize; y++)
+                    memset(im->image[y], 0, state->xsize);
+                break;
+            case 15:
+                /* FLI BRUN chunk */
+                /* OOB, ok, we've got 4 bytes min on entry */
+                for (y = 0; y < state->ysize; y++) {
+                    UINT8* out = (UINT8*) im->image[y];
+                    data += 1; /* ignore packetcount byte */
+                    for (x = 0; x < state->xsize; x += i) {
+                        ERR_IF_DATA_OOB(2)
+                        if (data[0] & 0x80) {
+                            i = 256 - data[0];
+                            if (x + i > state->xsize) {
+                                break; /* safety first */
+                            }
+                            ERR_IF_DATA_OOB(i+1)
+                            memcpy(out + x, data + 1, i);
+                            data += i + 1;
+                        } else {
+                            i = data[0];
+                            if (x + i > state->xsize)
+                                break; /* safety first */
+                            memset(out + x, data[1], i);
+                            data += 2;
+                        }
+                    }
+                    if (x != state->xsize) {
+                        /* didn't unpack whole line */
+                        state->errcode = IMAGING_CODEC_OVERRUN;
+                        return -1;
+                    }
+                }
+                break;
+            case 16:
+                /* COPY chunk */
+                if (state->xsize > bytes/state->ysize) {
+                    /* not enough data for frame */
+                    return ptr - buf; /* bytes consumed */
+                }
+                for (y = 0; y < state->ysize; y++) {
+                    UINT8* local_buf = (UINT8*) im->image[y];
+                    memcpy(local_buf, data, state->xsize);
+                    data += state->xsize;
+                }
+                break;
+            case 18:
+                /* PSTAMP chunk */
+                break; /* ignored */
+            default:
+                /* unknown chunk */
+                /* printf("unknown FLI/FLC chunk: %d\n", I16(ptr+4)); */
+                state->errcode = IMAGING_CODEC_UNKNOWN;
+                return -1;
+        }
+        advance = I32(ptr);
+        if (advance < 0 || advance > bytes) {
+            state->errcode = IMAGING_CODEC_OVERRUN;
+            return -1;
+        }
+        ptr += advance;
+        bytes -= advance;
     }
 
     return -1; /* end of frame */
diff --git a/src/libImaging/GetBBox.c b/src/libImaging/GetBBox.c
index ea7a35e48..acb50fd95 100644
--- a/src/libImaging/GetBBox.c
+++ b/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;\
-	for (x = 0; x < im->xsize; x++)\
-	    if (im->image[y][x] & mask) {\
-		has_data = 1;\
-		if (x < bbox[0])\
-		    bbox[0] = x;\
-		if (x >= bbox[2])\
-		    bbox[2] = x+1;\
-	    }\
-	if (has_data) {\
-	    if (bbox[1] < 0)\
-		bbox[1] = y;\
-	    bbox[3] = y+1;\
-	}\
+        has_data = 0;\
+        for (x = 0; x < im->xsize; x++)\
+            if (im->image[y][x] & mask) {\
+                has_data = 1;\
+                if (x < bbox[0])\
+                    bbox[0] = x;\
+                if (x >= bbox[2])\
+                    bbox[2] = x+1;\
+            }\
+        if (has_data) {\
+            if (bbox[1] < 0)\
+            bbox[1] = y;\
+            bbox[3] = y+1;\
+        }\
     }
 
     if (im->image8) {
-	GETBBOX(image8, 0xff);
+        GETBBOX(image8, 0xff);
     } else {
-	INT32 mask = 0xffffffff;
-	if (im->bands == 3) {
-	    ((UINT8*) &mask)[3] = 0;
-	} else if (strcmp(im->mode, "RGBa") == 0 ||
-	           strcmp(im->mode, "RGBA") == 0 ||
-	           strcmp(im->mode, "La") == 0 ||
-	           strcmp(im->mode, "LA") == 0 ||
-	           strcmp(im->mode, "PA") == 0) {
+        INT32 mask = 0xffffffff;
+        if (im->bands == 3) {
+            ((UINT8*) &mask)[3] = 0;
+        } else if (strcmp(im->mode, "RGBa") == 0 ||
+                   strcmp(im->mode, "RGBA") == 0 ||
+                   strcmp(im->mode, "La") == 0 ||
+                   strcmp(im->mode, "LA") == 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)\
-    for (y = 0; y < im->ysize; y++) {\
-	has_data = 0;\
-	for (x = 0; x < im->xsize; x++)\
-	    if (im->image[y][x] & mask) {\
-		has_data = 1;\
-		xproj[x] = 1;\
-	    }\
-	if (has_data)\
-	    yproj[y] = 1;\
-    }
+    #define GETPROJ(image, mask)\
+        for (y = 0; y < im->ysize; y++) {\
+            has_data = 0;\
+            for (x = 0; x < im->xsize; x++)\
+                if (im->image[y][x] & mask) {\
+                    has_data = 1;\
+                    xproj[x] = 1;\
+                }\
+                if (has_data)\
+                    yproj[y] = 1;\
+                }
 
     if (im->image8) {
-	GETPROJ(image8, 0xff);
+        GETPROJ(image8, 0xff);
     } else {
-	INT32 mask = 0xffffffff;
-	if (im->bands == 3)
-	    ((UINT8*) &mask)[3] = 0;
-	GETPROJ(image32, mask);
+        INT32 mask = 0xffffffff;
+        if (im->bands == 3)
+            ((UINT8*) &mask)[3] = 0;
+        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)
diff --git a/src/libImaging/Gif.h b/src/libImaging/Gif.h
index 2cb95efd2..bb118396c 100644
--- a/src/libImaging/Gif.h
+++ b/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	GIFBUFFER   (1<<GIFBITS)
+#define GIFTABLE    (1<<GIFBITS)
+#define GIFBUFFER   (1<<GIFBITS)
 
 
 typedef struct {
diff --git a/src/libImaging/GifDecode.c b/src/libImaging/GifDecode.c
index 68429ab26..8598cb6a9 100644
--- a/src/libImaging/GifDecode.c
+++ b/src/libImaging/GifDecode.c
@@ -5,15 +5,15 @@
  * a fast, suspendable GIF decoder
  *
  * history:
- * 95-09-03 fl	Created
- * 95-09-05 fl	Fixed sign problem on 16-bit platforms
- * 95-09-13 fl	Added some storage shortcuts
- * 96-03-28 fl	Revised API, integrated with PIL
- * 96-12-10 fl	Added interlace support
- * 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-17 fl	Don't mess up on very small, interlaced files
- * 99-02-07 fl	Minor speedups
+ * 95-09-03 fl Created
+ * 95-09-05 fl Fixed sign problem on 16-bit platforms
+ * 95-09-13 fl Added some storage shortcuts
+ * 96-03-28 fl Revised API, integrated with PIL
+ * 96-12-10 fl Added interlace support
+ * 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-17 fl Don't mess up on very small, interlaced files
+ * 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) {\
-	case 1:\
-	    context->repeat = state->y = 4;\
-	    context->interlace = 2;\
-	    break;\
-	case 2:\
-	    context->step = 4;\
-	    context->repeat = state->y = 2;\
-	    context->interlace = 3;\
-	    break;\
-	case 3:\
-	    context->step = 2;\
-	    context->repeat = state->y = 1;\
-	    context->interlace = 0;\
-	    break;\
-	default:\
-	    return -1;\
+        switch (context->interlace) {\
+            case 1:\
+                context->repeat = state->y = 4;\
+                context->interlace = 2;\
+                break;\
+            case 2:\
+                context->step = 4;\
+                context->repeat = state->y = 2;\
+                context->interlace = 3;\
+                break;\
+            case 3:\
+                context->step = 2;\
+                context->repeat = state->y = 1;\
+                context->interlace = 0;\
+                break;\
+            default:\
+                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 */
-	if (context->bits < 0 || context->bits > 12) {
-	    state->errcode = IMAGING_CODEC_CONFIG;
-	    return -1;
-	}
+    /* Initialise state */
+    if (context->bits < 0 || context->bits > 12) {
+        state->errcode = IMAGING_CODEC_CONFIG;
+        return -1;
+    }
 
-	/* Clear code */
-	context->clear = 1 << context->bits;
+    /* Clear code */
+    context->clear = 1 << context->bits;
 
-	/* End code */
-	context->end = context->clear + 1;
+    /* End code */
+    context->end = context->clear + 1;
 
-	/* Interlace */
-	if (context->interlace) {
-	    context->interlace = 1;
-	    context->step = context->repeat = 8;
-	} else
-	    context->step = 1;
+    /* Interlace */
+    if (context->interlace) {
+        context->interlace = 1;
+        context->step = context->repeat = 8;
+    } else
+        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 */
-	    context->next = context->clear + 2;
+            /* First free entry in table */
+            context->next = context->clear + 2;
 
-	    /* Initial code size */
-	    context->codesize = context->bits + 1;
-	    context->codemask = (1 << context->codesize) - 1;
+            /* Initial code size */
+            context->codesize = context->bits + 1;
+            context->codemask = (1 << context->codesize) - 1;
 
-	    /* Buffer pointer.  We fill the buffer from right, which
-	       allows us to return all of it in one operation. */
-	    context->bufferindex = GIFBUFFER;
+            /* Buffer pointer.  We fill the buffer from right, which
+               allows us to return all of it in one operation. */
+            context->bufferindex = GIFBUFFER;
 
-	    state->state = 2;
-	}
+            state->state = 2;
+        }
 
-	if (context->bufferindex < GIFBUFFER) {
+        if (context->bufferindex < GIFBUFFER) {
 
-	    /* Return whole buffer in one chunk */
-	    i = GIFBUFFER - context->bufferindex;
-	    p = &context->buffer[context->bufferindex];
+            /* Return whole buffer in one chunk */
+            i = GIFBUFFER - 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 */
-		    c = *ptr++; bytes--;
+                    /* Read next byte */
+                    c = *ptr++; bytes--;
 
-		    context->blocksize--;
+                    context->blocksize--;
 
-		    /* New bits are shifted in from from the left. */
-		    context->bitbuffer |= (INT32) c << context->bitcount;
-		    context->bitcount += 8;
+                    /* New bits are shifted in from from the left. */
+                    context->bitbuffer |= (INT32) c << context->bitcount;
+                    context->bitcount += 8;
 
-		} else {
+                } else {
 
-		    /* New GIF block */
+                    /* New GIF block */
 
-		    /* We don't start decoding unless we have a full block */
-		    if (bytes < 1)
-			return ptr - buffer;
-		    c = *ptr;
-		    if (bytes < c+1)
-			return ptr - buffer;
+                    /* We don't start decoding unless we have a full block */
+                    if (bytes < 1)
+                        return ptr - buffer;
+                    c = *ptr;
+                    if (bytes < c+1)
+                        return ptr - buffer;
 
-		    context->blocksize = c;
+                    context->blocksize = c;
 
-		    ptr++; bytes--;
+                    ptr++; bytes--;
 
-		}
-	    }
+                }
+            }
 
-	    /* Extract current symbol from bit buffer. */
-	    c = (int) context->bitbuffer & context->codemask;
+            /* Extract current symbol from bit buffer. */
+            c = (int) context->bitbuffer & context->codemask;
 
-	    /* Adjust buffer */
-	    context->bitbuffer >>= context->codesize;
-	    context->bitcount -= context->codesize;
+            /* Adjust buffer */
+            context->bitbuffer >>= context->codesize;
+            context->bitcount -= context->codesize;
 
-	    /* If c is less than "clear", it's a data byte.  Otherwise,
-	       it's either clear/end or a code symbol which should be
-	       expanded. */
+            /* If c is less than "clear", it's a data byte.  Otherwise,
+               it's either clear/end or a code symbol which should be
+               expanded. */
 
-	    if (c == context->clear) {
-		if (state->state != 2)
-		    state->state = 1;
-		continue;
-	    }
+            if (c == context->clear) {
+                if (state->state != 2)
+                    state->state = 1;
+                continue;
+            }
 
-	    if (c == context->end)
-		break;
+            if (c == context->end)
+                break;
 
-	    i = 1;
-	    p = &context->lastdata;
+            i = 1;
+            p = &context->lastdata;
 
-	    if (state->state == 2) {
+            if (state->state == 2) {
 
-		/* First valid symbol after clear; use as is */
-		if (c > context->clear) {
-		    state->errcode = IMAGING_CODEC_BROKEN;
-		    return -1;
-		}
+                /* First valid symbol after clear; use as is */
+                if (c > context->clear) {
+                    state->errcode = IMAGING_CODEC_BROKEN;
+                    return -1;
+                }
 
-		context->lastdata = context->lastcode = c;
-		state->state = 3;
+                context->lastdata = context->lastcode = c;
+                state->state = 3;
 
-	    } else {
+            } else {
 
-		thiscode = c;
+                thiscode = c;
 
-		if (c > context->next) {
-		    state->errcode = IMAGING_CODEC_BROKEN;
-		    return -1;
-		}
+                if (c > context->next) {
+                    state->errcode = IMAGING_CODEC_BROKEN;
+                    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) {
-			state->errcode = IMAGING_CODEC_BROKEN;
-			return -1;
-		    }
+                    if (context->bufferindex <= 0) {
+                        state->errcode = IMAGING_CODEC_BROKEN;
+                        return -1;
+                    }
 
-		    context->buffer[--context->bufferindex] =
-			context->lastdata;
+                    context->buffer[--context->bufferindex] =
+                    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) {
-			state->errcode = IMAGING_CODEC_BROKEN;
-			return -1;
-		    }
+                    if (context->bufferindex <= 0 || c >= GIFTABLE) {
+                        state->errcode = IMAGING_CODEC_BROKEN;
+                        return -1;
+                    }
 
-		    context->buffer[--context->bufferindex] =
-			context->data[c];
+                    context->buffer[--context->bufferindex] =
+                    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
-		       for it (take advise, Netscape!) */
-		    context->data[context->next] = c;
-		    context->link[context->next] = context->lastcode;
+                    /* We'll only add this symbol if we have room
+                       for it (take advise, Netscape!) */
+                    context->data[context->next] = c;
+                    context->link[context->next] = context->lastcode;
 
-		    if (context->next == context->codemask &&
-			context->codesize < GIFBITS) {
+                    if (context->next == context->codemask &&
+                    context->codesize < GIFBITS) {
 
-			/* Expand code size */
-			context->codesize++;
-			context->codemask = (1 << context->codesize) - 1;
-		    }
+                        /* Expand code size */
+                        context->codesize++;
+                        context->codemask = (1 << context->codesize) - 1;
+                    }
 
-		    context->next++;
+                    context->next++;
 
-		}
+                }
 
-		context->lastcode = thiscode;
+                context->lastcode = thiscode;
 
-	    }
-	}
+            }
+        }
 
-	/* Copy the bytes into the image */
-	if (state->y >= state->ysize) {
-	    state->errcode = IMAGING_CODEC_OVERRUN;
-	    return -1;
-	}
+        /* Copy the bytes into the image */
+        if (state->y >= state->ysize) {
+            state->errcode = IMAGING_CODEC_OVERRUN;
+            return -1;
+        }
 
-	/* To squeeze some extra pixels out of this loop, we test for
-	   some common cases and handle them separately. */
+        /* To squeeze some extra pixels out of this loop, we test for
+           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 (state->x < state->xsize-1) {
-		/* Single pixel, not at the end of the line. */
-		*out++ = p[0];
-		state->x++;
-		continue;
-	    }
-	} else if (state->x + i <= state->xsize) {
-	    /* This string fits into current line. */
-	    memcpy(out, p, i);
-            out += i;
-	    state->x += i;
-	    if (state->x == state->xsize) {
-		NEWLINE(state, context);
-	    }
-	    continue;
-	}
+        if (i == 1) {
+            if (state->x < state->xsize-1) {
+                /* Single pixel, not at the end of the line. */
+                *out++ = p[0];
+                state->x++;
+                continue;
+            }
+        } else if (state->x + i <= state->xsize) {
+            /* This string fits into current line. */
+            memcpy(out, p, i);
+                out += i;
+            state->x += i;
+            if (state->x == state->xsize) {
+                NEWLINE(state, context);
+            }
+            continue;
+        }
 
-	/* No shortcut, copy pixel by pixel */
-	for (c = 0; c < i; c++) {
-	    *out++ = p[c];
-	    if (++state->x >= state->xsize) {
-		NEWLINE(state, context);
-	    }
-	}
+        /* No shortcut, copy pixel by pixel */
+        for (c = 0; c < i; c++) {
+            *out++ = p[c];
+            if (++state->x >= state->xsize) {
+                NEWLINE(state, context);
+            }
+        }
     }
 
     return ptr - buffer;
diff --git a/src/libImaging/GifEncode.c b/src/libImaging/GifEncode.c
index f211814ed..90441d184 100644
--- a/src/libImaging/GifEncode.c
+++ b/src/libImaging/GifEncode.c
@@ -5,11 +5,11 @@
  * encoder for uncompressed GIF data
  *
  * history:
- * 97-01-05 fl	created (writes uncompressed data)
- * 97-08-27 fl	fixed off-by-one error in buffer size test
- * 98-07-09 fl	added interlace write support
- * 99-02-07 fl	rewritten, now uses a run-length encoding strategy
- * 99-02-08 fl	improved run-length encoding for long runs
+ * 97-01-05 fl created (writes uncompressed data)
+ * 97-08-27 fl fixed off-by-one error in buffer size test
+ * 98-07-09 fl added interlace write support
+ * 99-02-07 fl rewritten, now uses a run-length encoding strategy
+ * 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 */
-	context->bitbuffer = CLEAR_CODE;
-	context->bitcount = 9;
+        /* place a clear code in the output buffer */
+        context->bitbuffer = CLEAR_CODE;
+        context->bitcount = 9;
 
-	state->count = FIRST_CODE;
+        state->count = FIRST_CODE;
 
-	if (context->interlace) {
-	    context->interlace = 1;
-	    context->step = 8;
-	} else
-	    context->step = 1;
+        if (context->interlace) {
+            context->interlace = 1;
+            context->step = 8;
+        } else
+            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 ENCODE:
+            case INIT:
+            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) {
-                    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;
+                    if (!context->interlace && state->y >= state->ysize) {
+                        state->state = ENCODE_EOF;
                         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)
-                context->count++;
-            else {
-                EMIT_RUN(label1);
-                context->last = this;
-                context->count = 1;
-            }
-	    break;
+                    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;
+                    }
 
-        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 */
-            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;
-            }
+                this = state->buffer[state->x++];
 
-            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 FLUSH:
+            case ENCODE_EOF:
 
-            while (context->flush) {
+                /* write the final run */
+                EMIT_RUN(label2);
 
-                /* get a block from the flush queue */
-                block = context->flush;
+                /* write an end of image marker */
+                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 */
-                    if (bytes < block->size+1)
+                /* flush the last block, and exit */
+                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;
-                    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;
-            }
-
-            state->state = ENCODE;
-	    break;
-        }
+                    state->state = ENCODE;
+                    break;
+    }
 }
diff --git a/src/libImaging/HexDecode.c b/src/libImaging/HexDecode.c
index 8bd9bf67f..9b20bc2ac 100644
--- a/src/libImaging/HexDecode.c
+++ b/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' :\
-		(v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
-		(v >= 'A' && v <= 'F') ? v - 'A' + 10 : -1)
+#define HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
+        (v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
+        (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)
-	    return ptr - buf;
+        if (bytes < 2)
+            return ptr - buf;
 
-	a = HEX(ptr[0]);
-	b = HEX(ptr[1]);
+        a = HEX(ptr[0]);
+        b = HEX(ptr[1]);
 
-	if (a < 0 || b < 0) {
+        if (a < 0 || b < 0) {
 
-	    ptr++;
-	    bytes--;
+            ptr++;
+            bytes--;
 
-	} else {
+        } else {
 
-	    ptr += 2;
-	    bytes -= 2;
+            ptr += 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 */
-		state->shuffle((UINT8*) im->image[state->y], state->buffer,
-			       state->xsize);
+                /* Got a full line, unpack it */
+                state->shuffle((UINT8*) im->image[state->y], state->buffer,
+                           state->xsize);
 
-		state->x = 0;
+                state->x = 0;
 
-		if (++state->y >= state->ysize) {
-		    /* End of file (errcode = 0) */
-		    return -1;
-		}
-	    }
+                if (++state->y >= state->ysize) {
+                    /* End of file (errcode = 0) */
+                    return -1;
+                }
+            }
 
-	}
+        }
     }
 }
diff --git a/src/libImaging/Histo.c b/src/libImaging/Histo.c
index 5c2824ab0..0d08e9f08 100644
--- a/src/libImaging/Histo.c
+++ b/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 */
-	if (im->xsize != imMask->xsize || im->ysize != imMask->ysize)
-	    return ImagingError_Mismatch();
-	if (strcmp(imMask->mode, "1") != 0 && strcmp(imMask->mode, "L") != 0)
-	    return ImagingError_ValueError("bad transparency mask");
+        /* Validate mask */
+        if (im->xsize != imMask->xsize || im->ysize != imMask->ysize)
+            return ImagingError_Mismatch();
+        if (strcmp(imMask->mode, "1") != 0 && strcmp(imMask->mode, "L") != 0)
+            return ImagingError_ValueError("bad transparency mask");
     }
 
     h = ImagingHistogramNew(im);
 
     if (imMask) {
-	/* mask */
-	if (im->image8) {
-            ImagingSectionEnter(&cookie);
-	    for (y = 0; y < im->ysize; y++)
-		for (x = 0; x < im->xsize; x++)
-		    if (imMask->image8[y][x] != 0)
-			h->histogram[im->image8[y][x]]++;
-            ImagingSectionLeave(&cookie);
-	} else { /* yes, we need the braces. C isn't Python! */
+        /* mask */
+        if (im->image8) {
+                ImagingSectionEnter(&cookie);
+            for (y = 0; y < im->ysize; y++)
+                for (x = 0; x < im->xsize; x++)
+                    if (imMask->image8[y][x] != 0)
+                    h->histogram[im->image8[y][x]]++;
+                    ImagingSectionLeave(&cookie);
+        } 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++) {
-		UINT8* in = (UINT8*) im->image32[y];
-		for (x = 0; x < im->xsize; x++)
-		    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++) {
+            for (y = 0; y < im->ysize; y++) {
+                UINT8* in = (UINT8*) im->image32[y];
+                for (x = 0; x < im->xsize; x++)
+                    if (imMask->image8[y][x] != 0) {
                         h->histogram[(*in++)]++;
                         h->histogram[(*in++)+256]++;
                         h->histogram[(*in++)+512]++;
                         h->histogram[(*in++)+768]++;
-                    }
-                }
-                ImagingSectionLeave(&cookie);
-                break;
-            case IMAGING_TYPE_INT32:
-                if (!minmax) {
-                    ImagingHistogramDelete(h);
-                    return ImagingError_ValueError("min/max not given");
-                }
-                if (!im->xsize || !im->ysize)
-                    break;
-                memcpy(&imin, minmax, sizeof(imin));
-                memcpy(&imax, ((char*)minmax) + sizeof(imin), sizeof(imax));
-                if (imin >= imax)
-                    break;
+                    } else
+                        in += 4;
+            }
+            ImagingSectionLeave(&cookie);
+        }
+    } else {
+        /* mask not given; process pixels in image */
+        if (im->image8) {
                 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]++;
+            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]++;
+                        }
                     }
-                }
-                ImagingSectionLeave(&cookie);
-                break;
-            case IMAGING_TYPE_FLOAT32:
-                if (!minmax) {
-                    ImagingHistogramDelete(h);
-                    return ImagingError_ValueError("min/max not given");
-                }
-                if (!im->xsize || !im->ysize)
+                    ImagingSectionLeave(&cookie);
                     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]++;
+                case IMAGING_TYPE_INT32:
+                    if (!minmax) {
+                        ImagingHistogramDelete(h);
+                        return ImagingError_ValueError("min/max not given");
                     }
-                }
-                ImagingSectionLeave(&cookie);
-                break;
+                    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++) {
+                        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;
             }
         }
     }
diff --git a/src/libImaging/ImPlatform.h b/src/libImaging/ImPlatform.h
index b2d4db785..576ceaa58 100644
--- a/src/libImaging/ImPlatform.h
+++ b/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	UINT8 unsigned char
+#define INT8  signed char
+#define UINT8 unsigned char
 
-#define	UINT16 unsigned INT16
-#define	UINT32 unsigned INT32
+#define UINT16 unsigned INT16
+#define UINT32 unsigned INT32
 
 #endif
 
 /* assume IEEE; tweak if necessary (patches are welcome) */
-#define	FLOAT16 UINT16
-#define	FLOAT32 float
-#define	FLOAT64 double
+#define FLOAT16 UINT16
+#define FLOAT32 float
+#define FLOAT64 double
 
 #ifdef _MSC_VER
 typedef signed __int64       int64_t;
diff --git a/src/libImaging/Jpeg.h b/src/libImaging/Jpeg.h
index 7ff658c32..df6d8a903 100644
--- a/src/libImaging/Jpeg.h
+++ b/src/libImaging/Jpeg.h
@@ -14,13 +14,13 @@
 
 
 typedef struct {
-    struct jpeg_error_mgr pub;	/* "public" fields */
-    jmp_buf setjmp_buffer;	/* for return to caller */
+    struct jpeg_error_mgr pub;    /* "public" fields */
+    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;
diff --git a/src/libImaging/Jpeg2K.h b/src/libImaging/Jpeg2K.h
index 7bb14eb2c..7645b9326 100644
--- a/src/libImaging/Jpeg2K.h
+++ b/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 {
diff --git a/src/libImaging/JpegDecode.c b/src/libImaging/JpegDecode.c
index 39d96de53..ce0c2ca7c 100644
--- a/src/libImaging/JpegDecode.c
+++ b/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
-	   due to a corrupt or truncated image
-	*/
+    /* called to free the decompression engine when the decode terminates
+       due to a corrupt or truncated image
+    */
     JPEGSTATE* context = (JPEGSTATE*) state->context;
 
-	/* Clean up */
-	jpeg_destroy_decompress(&context->cinfo);
-	return -1;
+    /* Clean up */
+    jpeg_destroy_decompress(&context->cinfo);
+    return -1;
 }
 
 #endif
diff --git a/src/libImaging/JpegEncode.c b/src/libImaging/JpegEncode.c
index 9d8382791..2eb35d6bf 100644
--- a/src/libImaging/JpegEncode.c
+++ b/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_destroy_compress(&context->cinfo);
-	state->errcode = IMAGING_CODEC_BROKEN;
-	return -1;
+        /* JPEG error handler */
+        jpeg_destroy_compress(&context->cinfo);
+        state->errcode = IMAGING_CODEC_BROKEN;
+        return -1;
     }
 
     if (!state->state) {
 
-	/* Setup compression context (very similar to the decoder) */
-	context->cinfo.err = jpeg_std_error(&context->error.pub);
-	context->error.pub.error_exit = error;
-	jpeg_create_compress(&context->cinfo);
-	jpeg_buffer_dest(&context->cinfo, &context->destination);
+        /* Setup compression context (very similar to the decoder) */
+        context->cinfo.err = jpeg_std_error(&context->error.pub);
+        context->error.pub.error_exit = error;
+        jpeg_create_compress(&context->cinfo);
+        jpeg_buffer_dest(&context->cinfo, &context->destination);
 
         context->extra_offset = 0;
 
-	/* Ready to encode */
-	state->state = 1;
+        /* Ready to encode */
+        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_height = state->ysize;
+            context->cinfo.image_width = state->xsize;
+            context->cinfo.image_height = state->ysize;
 
-	switch (state->bits) {
-        case 8:
-            context->cinfo.input_components = 1;
-            context->cinfo.in_color_space = JCS_GRAYSCALE;
-            break;
-        case 24:
-            context->cinfo.input_components = 3;
-            if (strcmp(im->mode, "YCbCr") == 0)
-                context->cinfo.in_color_space = JCS_YCbCr;
-            else
-                context->cinfo.in_color_space = JCS_RGB;
-            break;
-        case 32:
-            context->cinfo.input_components = 4;
-            context->cinfo.in_color_space = JCS_CMYK;
-        #ifdef JCS_EXTENSIONS
-            if (strcmp(context->rawmode, "RGBX") == 0)
-                context->cinfo.in_color_space = JCS_EXT_RGBX;
-        #endif
-            break;
-        default:
-            state->errcode = IMAGING_CODEC_CONFIG;
-            return -1;
-	}
+            switch (state->bits) {
+                case 8:
+                    context->cinfo.input_components = 1;
+                    context->cinfo.in_color_space = JCS_GRAYSCALE;
+                    break;
+                case 24:
+                    context->cinfo.input_components = 3;
+                    if (strcmp(im->mode, "YCbCr") == 0)
+                        context->cinfo.in_color_space = JCS_YCbCr;
+                    else
+                        context->cinfo.in_color_space = JCS_RGB;
+                    break;
+                case 32:
+                    context->cinfo.input_components = 4;
+                    context->cinfo.in_color_space = JCS_CMYK;
+                #ifdef JCS_EXTENSIONS
+                    if (strcmp(context->rawmode, "RGBX") == 0)
+                        context->cinfo.in_color_space = JCS_EXT_RGBX;
+                #endif
+                    break;
+                default:
+                    state->errcode = IMAGING_CODEC_CONFIG;
+                    return -1;
+            }
 
-	/* Compressor configuration */
-	jpeg_set_defaults(&context->cinfo);
+            /* Compressor configuration */
+            jpeg_set_defaults(&context->cinfo);
 
-	/* Use custom quantization tables */
-	if (context->qtables) {
-	    int i;
-	    int quality = 100;
-	    int last_q = 0;
-	    if (context->quality != -1) {
-		quality = context->quality;
-	    }
-        for (i = 0; i < context->qtablesLen; i++) {
-            // TODO: Should add support for none baseline
-            jpeg_add_quant_table(&context->cinfo, i, &context->qtables[i * DCTSIZE2],
-                                 quality, TRUE);
-            context->cinfo.comp_info[i].quant_tbl_no = i;
-            last_q = i;
-        }
-        if (context->qtablesLen == 1) {
-            // jpeg_set_defaults created two qtables internally, but we only wanted one.
-            jpeg_add_quant_table(&context->cinfo, 1, &context->qtables[0],
-                                 quality, TRUE);
-        }
-        for (i = last_q; i < context->cinfo.num_components; i++) {
-            context->cinfo.comp_info[i].quant_tbl_no = last_q;
-        }
-	} else if (context->quality != -1) {
-	    jpeg_set_quality(&context->cinfo, context->quality, 1);
-	}
+            /* Use custom quantization tables */
+            if (context->qtables) {
+                int i;
+                int quality = 100;
+                int last_q = 0;
+                if (context->quality != -1) {
+                    quality = context->quality;
+                }
+                for (i = 0; i < context->qtablesLen; i++) {
+                    // TODO: Should add support for none baseline
+                    jpeg_add_quant_table(&context->cinfo, i, &context->qtables[i * DCTSIZE2],
+                                         quality, TRUE);
+                    context->cinfo.comp_info[i].quant_tbl_no = i;
+                    last_q = i;
+                }
+                if (context->qtablesLen == 1) {
+                    // jpeg_set_defaults created two qtables internally, but we only wanted one.
+                    jpeg_add_quant_table(&context->cinfo, 1, &context->qtables[0],
+                                         quality, TRUE);
+                }
+                for (i = last_q; i < context->cinfo.num_components; i++) {
+                    context->cinfo.comp_info[i].quant_tbl_no = last_q;
+                }
+            } else if (context->quality != -1) {
+                jpeg_set_quality(&context->cinfo, context->quality, 1);
+            }
 
-	/* Set subsampling options */
-	switch (context->subsampling)
-	    {
-	    case 0:  /* 1x1 1x1 1x1 (4:4:4) : None */
-		{
-		    context->cinfo.comp_info[0].h_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].v_samp_factor = 1;
-		    context->cinfo.comp_info[2].h_samp_factor = 1;
-		    context->cinfo.comp_info[2].v_samp_factor = 1;
-		    break;
-		}
-	    case 1:  /* 2x1, 1x1, 1x1 (4:2:2) : Medium */
-		{
-		    context->cinfo.comp_info[0].h_samp_factor = 2;
-		    context->cinfo.comp_info[0].v_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[2].h_samp_factor = 1;
-		    context->cinfo.comp_info[2].v_samp_factor = 1;
-		    break;
-		}
-	    case 2:  /* 2x2, 1x1, 1x1 (4:2:0) : High */
-		{
-		    context->cinfo.comp_info[0].h_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].v_samp_factor = 1;
-		    context->cinfo.comp_info[2].h_samp_factor = 1;
-		    context->cinfo.comp_info[2].v_samp_factor = 1;
-		    break;
-		}
-	    default:
-		{
-		    /* Use the lib's default */
-		    break;
-		}
-	    }
-	if (context->progressive)
-	    jpeg_simple_progression(&context->cinfo);
-	context->cinfo.smoothing_factor = context->smooth;
-	context->cinfo.optimize_coding = (boolean) context->optimize;
-        if (context->xdpi > 0 && context->ydpi > 0) {
-            context->cinfo.density_unit = 1; /* dots per inch */
-            context->cinfo.X_density = context->xdpi;
-            context->cinfo.Y_density = context->ydpi;
-        }
-	switch (context->streamtype) {
-	case 1:
-	    /* tables only -- not yet implemented */
-	    state->errcode = IMAGING_CODEC_CONFIG;
-	    return -1;
-	case 2:
-	    /* image only */
-	    jpeg_suppress_tables(&context->cinfo, TRUE);
-	    jpeg_start_compress(&context->cinfo, FALSE);
-            /* suppress extra section */
-            context->extra_offset = context->extra_size;
-	    break;
-	default:
-	    /* interchange stream */
-	    jpeg_start_compress(&context->cinfo, TRUE);
-	    break;
-	}
-	state->state++;
-	/* fall through */
+            /* Set subsampling options */
+            switch (context->subsampling)
+                {
+                case 0:  /* 1x1 1x1 1x1 (4:4:4) : None */
+                {
+                    context->cinfo.comp_info[0].h_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].v_samp_factor = 1;
+                    context->cinfo.comp_info[2].h_samp_factor = 1;
+                    context->cinfo.comp_info[2].v_samp_factor = 1;
+                    break;
+                }
+                case 1:  /* 2x1, 1x1, 1x1 (4:2:2) : Medium */
+                {
+                    context->cinfo.comp_info[0].h_samp_factor = 2;
+                    context->cinfo.comp_info[0].v_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[2].h_samp_factor = 1;
+                    context->cinfo.comp_info[2].v_samp_factor = 1;
+                    break;
+                }
+                case 2:  /* 2x2, 1x1, 1x1 (4:2:0) : High */
+                {
+                    context->cinfo.comp_info[0].h_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].v_samp_factor = 1;
+                    context->cinfo.comp_info[2].h_samp_factor = 1;
+                    context->cinfo.comp_info[2].v_samp_factor = 1;
+                    break;
+                }
+                default:
+                {
+                    /* Use the lib's default */
+                    break;
+                }
+                }
+            if (context->progressive)
+                jpeg_simple_progression(&context->cinfo);
+                context->cinfo.smoothing_factor = context->smooth;
+                context->cinfo.optimize_coding = (boolean) context->optimize;
+                if (context->xdpi > 0 && context->ydpi > 0) {
+                    context->cinfo.density_unit = 1; /* dots per inch */
+                    context->cinfo.X_density = context->xdpi;
+                    context->cinfo.Y_density = context->ydpi;
+                }
+            switch (context->streamtype) {
+                case 1:
+                    /* tables only -- not yet implemented */
+                    state->errcode = IMAGING_CODEC_CONFIG;
+                    return -1;
+                case 2:
+                    /* image only */
+                    jpeg_suppress_tables(&context->cinfo, TRUE);
+                    jpeg_start_compress(&context->cinfo, FALSE);
+                    /* suppress extra section */
+                    context->extra_offset = context->extra_size;
+                    break;
+                default:
+                    /* interchange stream */
+                    jpeg_start_compress(&context->cinfo, TRUE);
+                    break;
+            }
+            state->state++;
+            /* fall through */
 
-    case 2:
-        // check for exif len + 'APP1' header bytes
-        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
+        case 2:
+            // check for exif len + 'APP1' header bytes
+            if (context->rawExifLen + 5 >  context->destination.pub.free_in_buffer){
                 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:
-        if (1024 > context->destination.pub.free_in_buffer){
+            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++;
+
+        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;
 
     }
 
diff --git a/src/libImaging/Matrix.c b/src/libImaging/Matrix.c
index 5cc7795a4..22d5d642c 100644
--- a/src/libImaging/Matrix.c
+++ b/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);
-	if (!imOut)
-	    return NULL;
+        imOut = ImagingNewDirty("L", im->xsize, im->ysize);
+        if (!imOut)
+            return NULL;
 
-	for (y = 0; y < im->ysize; y++) {
-	    UINT8* in = (UINT8*) im->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
+        for (y = 0; y < im->ysize; y++) {
+            UINT8* in = (UINT8*) im->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
 
-	    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;
-		out[x] = CLIPF(v);
-		in += 4;
-	    }
-	}
+            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;
+                out[x] = CLIPF(v);
+                in += 4;
+            }
+        }
 
     } else if (strlen(mode) == 3 && im->bands == 3) {
 
-	imOut = ImagingNewDirty(mode, im->xsize, im->ysize);
-	if (!imOut)
-	    return NULL;
+        imOut = ImagingNewDirty(mode, im->xsize, im->ysize);
+        if (!imOut)
+            return NULL;
 
-	for (y = 0; y < im->ysize; y++) {
-	    UINT8* in = (UINT8*) im->image[y];
-	    UINT8* out = (UINT8*) imOut->image[y];
+        for (y = 0; y < im->ysize; y++) {
+            UINT8* in = (UINT8*) im->image[y];
+            UINT8* out = (UINT8*) imOut->image[y];
 
-	    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 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;
-		out[0] = CLIPF(v0);
-		out[1] = CLIPF(v1);
-		out[2] = CLIPF(v2);
-		in += 4; out += 4;
-	    }
-	}
+            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 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;
+                out[0] = CLIPF(v0);
+                out[1] = CLIPF(v1);
+                out[2] = CLIPF(v2);
+                in += 4; out += 4;
+            }
+        }
     } else
-	return (Imaging) ImagingError_ModeError();
+        return (Imaging) ImagingError_ModeError();
 
     return imOut;
 }
diff --git a/src/libImaging/Negative.c b/src/libImaging/Negative.c
index 4dedcb245..fe08e4753 100644
--- a/src/libImaging/Negative.c
+++ b/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++)
-	     imOut->image[y][x] = ~im->image[y][x];
+        for (x = 0; x < im->linesize; x++)
+            imOut->image[y][x] = ~im->image[y][x];
 
     return imOut;
 }
diff --git a/src/libImaging/Offset.c b/src/libImaging/Offset.c
index b3d9425fb..0f9793c3c 100644
--- a/src/libImaging/Offset.c
+++ b/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++) {\
-	    int yi = (y + yoffset) % im->ysize;\
-	    int xi = (x + xoffset) % im->xsize;\
-	    imOut->image[y][x] = im->image[yi][xi];\
-	}
+        for (x = 0; x < im->xsize; x++) {\
+            int yi = (y + yoffset) % im->ysize;\
+            int xi = (x + xoffset) % im->xsize;\
+            imOut->image[y][x] = im->image[yi][xi];\
+    }
 
     if (im->image8)
-	OFFSET(image8)
+        OFFSET(image8)
     else
-	OFFSET(image32)
+        OFFSET(image32)
 
     return imOut;
 }
diff --git a/src/libImaging/PackDecode.c b/src/libImaging/PackDecode.c
index ef54f3c9a..b9c846f4b 100644
--- a/src/libImaging/PackDecode.c
+++ b/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)
-	    return ptr - buf;
+        if (bytes < 1)
+            return ptr - buf;
 
-	if (ptr[0] & 0x80) {
+        if (ptr[0] & 0x80) {
 
-	    if (ptr[0] == 0x80) {
-		/* Nop */
-		ptr++; bytes--;
-		continue;
-	    }
+            if (ptr[0] == 0x80) {
+                /* Nop */
+                ptr++; bytes--;
+                continue;
+            }
 
-	    /* Run */
-	    if (bytes < 2)
-		return ptr - buf;
+            /* Run */
+            if (bytes < 2)
+                return ptr - buf;
 
-	    for (n = 257 - ptr[0]; n > 0; n--) {
-		if (state->x >= state->bytes) {
-		    /* state->errcode = IMAGING_CODEC_OVERRUN; */
-		    break;
-		}
-		state->buffer[state->x++] = ptr[1];
-	    }
+            for (n = 257 - ptr[0]; n > 0; n--) {
+                if (state->x >= state->bytes) {
+                    /* state->errcode = IMAGING_CODEC_OVERRUN; */
+                    break;
+                }
+                state->buffer[state->x++] = ptr[1];
+            }
 
-	    ptr += 2; bytes -= 2;
+            ptr += 2; bytes -= 2;
 
-	} else {
+        } else {
 
-	    /* Literal */
-	    n = ptr[0]+2;
+            /* Literal */
+            n = ptr[0]+2;
 
-	    if (bytes < n)
-		return ptr - buf;
+            if (bytes < n)
+                return ptr - buf;
 
-	    for (i = 1; i < n; i++) {
-		if (state->x >= state->bytes) {
-		    /* state->errcode = IMAGING_CODEC_OVERRUN; */
-		    break;
-		}
-		state->buffer[state->x++] = ptr[i];
-	    }
+            for (i = 1; i < n; i++) {
+                if (state->x >= state->bytes) {
+                    /* state->errcode = IMAGING_CODEC_OVERRUN; */
+                    break;
+                }
+                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 */
-	    state->shuffle((UINT8*) im->image[state->y + state->yoff] +
-			   state->xoff * im->pixelsize, state->buffer,
-			   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;
+            state->x = 0;
 
-	    if (++state->y >= state->ysize) {
-		/* End of file (errcode = 0) */
-		return -1;
-	    }
-	}
+            if (++state->y >= state->ysize) {
+                /* End of file (errcode = 0) */
+                return -1;
+            }
+        }
 
     }
 }
diff --git a/src/libImaging/PcdDecode.c b/src/libImaging/PcdDecode.c
index 8ff264edf..6f86dc96b 100644
--- a/src/libImaging/PcdDecode.c
+++ b/src/libImaging/PcdDecode.c
@@ -5,13 +5,13 @@
  * decoder for uncompressed PCD image data.
  *
  * history:
- *	96-05-10 fl	Created
- *	96-05-18 fl	New tables
- *	97-01-25 fl	Use PhotoYCC unpacker
+ * 96-05-10 fl Created
+ * 96-05-18 fl New tables
+ * 97-01-25 fl Use PhotoYCC unpacker
  *
  * notes:
- *	This driver supports uncompressed PCD modes only
- *	(resolutions up to 768x512).
+ * This driver supports uncompressed PCD modes only
+ * (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 */
-	if (bytes < chunk)
-	    return ptr - buf;
+        /* We need data for two full lines before we can do anything */
+        if (bytes < chunk)
+            return ptr - buf;
 
-	/* Unpack first line */
-	out = state->buffer;
-	for (x = 0; x < state->xsize; x++) {
-	    out[0] = ptr[x];
-	    out[1] = ptr[(x+4*state->xsize)/2];
-	    out[2] = ptr[(x+5*state->xsize)/2];
-	    out += 3;
-	}
+        /* Unpack first line */
+        out = state->buffer;
+        for (x = 0; x < state->xsize; x++) {
+            out[0] = ptr[x];
+            out[1] = ptr[(x+4*state->xsize)/2];
+            out[2] = ptr[(x+5*state->xsize)/2];
+            out += 3;
+        }
 
-	state->shuffle((UINT8*) im->image[state->y],
-		       state->buffer, state->xsize);
+        state->shuffle((UINT8*) im->image[state->y],
+                   state->buffer, state->xsize);
 
-	if (++state->y >= state->ysize)
-	    return -1; /* This can hardly happen */
+        if (++state->y >= state->ysize)
+            return -1; /* This can hardly happen */
 
-	/* Unpack second line */
-	out = state->buffer;
-	for (x = 0; x < state->xsize; x++) {
-	    out[0] = ptr[x+state->xsize];
-	    out[1] = ptr[(x+4*state->xsize)/2];
-	    out[2] = ptr[(x+5*state->xsize)/2];
-	    out += 3;
-	}
+        /* Unpack second line */
+        out = state->buffer;
+        for (x = 0; x < state->xsize; x++) {
+            out[0] = ptr[x+state->xsize];
+            out[1] = ptr[(x+4*state->xsize)/2];
+            out[2] = ptr[(x+5*state->xsize)/2];
+            out += 3;
+        }
 
-	state->shuffle((UINT8*) im->image[state->y],
-		       state->buffer, state->xsize);
+        state->shuffle((UINT8*) im->image[state->y],
+                   state->buffer, state->xsize);
 
-	if (++state->y >= state->ysize)
-	    return -1;
+        if (++state->y >= state->ysize)
+            return -1;
 
-	ptr += chunk;
-	bytes -= chunk;
+        ptr += chunk;
+        bytes -= chunk;
 
     }
 }
diff --git a/src/libImaging/PcxDecode.c b/src/libImaging/PcxDecode.c
index e5a38f4be..a4e40864b 100644
--- a/src/libImaging/PcxDecode.c
+++ b/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)
-	    return ptr - buf;
+        if (bytes < 1)
+            return ptr - buf;
 
-	if ((*ptr & 0xC0) == 0xC0) {
+        if ((*ptr & 0xC0) == 0xC0) {
 
-	    /* Run */
-	    if (bytes < 2)
-		return ptr - buf;
+            /* Run */
+            if (bytes < 2)
+                return ptr - buf;
 
-	    n = ptr[0] & 0x3F;
+            n = ptr[0] & 0x3F;
 
-	    while (n > 0) {
-		if (state->x >= state->bytes) {
-		    state->errcode = IMAGING_CODEC_OVERRUN;
-		    break;
-		}
-		state->buffer[state->x++] = ptr[1];
-		n--;
-	    }
+            while (n > 0) {
+                if (state->x >= state->bytes) {
+                    state->errcode = IMAGING_CODEC_OVERRUN;
+                    break;
+                }
+                state->buffer[state->x++] = ptr[1];
+                n--;
+            }
 
-	    ptr += 2; bytes -= 2;
+            ptr += 2; bytes -= 2;
 
-	} else {
+        } else {
 
-	    /* Literal */
-	    state->buffer[state->x++] = ptr[0];
-	    ptr++; bytes--;
+            /* Literal */
+            state->buffer[state->x++] = ptr[0];
+            ptr++; bytes--;
 
-	}
+        }
 
-	if (state->x >= state->bytes) {
-        if (state->bytes % state->xsize && state->bytes > state->xsize) {
-            int bands = state->bytes / state->xsize;
-            int stride = state->bytes / bands;
-            int i;
-            for (i=1; i< bands; i++) {  // note -- skipping first band
-                memmove(&state->buffer[i*state->xsize],
-                        &state->buffer[i*stride],
-                        state->xsize);
+        if (state->x >= state->bytes) {
+            if (state->bytes % state->xsize && state->bytes > state->xsize) {
+                int bands = state->bytes / state->xsize;
+                int stride = state->bytes / bands;
+                int i;
+                for (i=1; i< bands; i++) {  // note -- skipping first band
+                    memmove(&state->buffer[i*state->xsize],
+                            &state->buffer[i*stride],
+                            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;
-	    }
-	}
 
     }
 }
diff --git a/src/libImaging/Point.c b/src/libImaging/Point.c
index 9b4bf6b75..a80b9e7d2 100644
--- a/src/libImaging/Point.c
+++ b/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);
diff --git a/src/libImaging/RawDecode.c b/src/libImaging/RawDecode.c
index c069bdb88..5e95905cc 100644
--- a/src/libImaging/RawDecode.c
+++ b/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 */
-	state->bytes = (state->xsize * state->bits + 7) / 8;
-	if (rawstate->stride) {
-	    rawstate->skip = rawstate->stride - state->bytes;
-	    if (rawstate->skip < 0) {
-	        state->errcode = IMAGING_CODEC_CONFIG;
-	        return -1;
-	    }
-	} else {
-	    rawstate->skip = 0;
-	}
+        /* get size of image data and padding */
+        state->bytes = (state->xsize * state->bits + 7) / 8;
+        if (rawstate->stride) {
+            rawstate->skip = rawstate->stride - state->bytes;
+            if (rawstate->skip < 0) {
+                state->errcode = IMAGING_CODEC_CONFIG;
+                return -1;
+            }
+        } else {
+            rawstate->skip = 0;
+        }
 
-	/* check image orientation */
-	if (state->ystep < 0) {
-	    state->y = state->ysize-1;
-	    state->ystep = -1;
-	} else
-	    state->ystep = 1;
+        /* check image orientation */
+        if (state->ystep < 0) {
+            state->y = state->ysize-1;
+            state->ystep = -1;
+        } else
+            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)
-		return ptr - buf;
+            if (bytes < rawstate->skip)
+                return ptr - buf;
 
-	    ptr += rawstate->skip;
-	    bytes -= rawstate->skip;
+            ptr += rawstate->skip;
+            bytes -= rawstate->skip;
 
-	    state->state = LINE;
+            state->state = LINE;
 
-	}
+        }
 
-	if (bytes < state->bytes)
-	    return ptr - buf;
+        if (bytes < state->bytes)
+            return ptr - buf;
 
-	/* Unpack data */
-	state->shuffle((UINT8*) im->image[state->y + state->yoff] +
-		       state->xoff * im->pixelsize, ptr, state->xsize);
+        /* Unpack data */
+        state->shuffle((UINT8*) im->image[state->y + state->yoff] +
+                   state->xoff * im->pixelsize, ptr, state->xsize);
 
-	ptr += state->bytes;
-	bytes -= state->bytes;
+        ptr += state->bytes;
+        bytes -= state->bytes;
 
-	state->y += state->ystep;
+        state->y += state->ystep;
 
-	if (state->y < 0 || state->y >= state->ysize) {
-	    /* End of file (errcode = 0) */
-	    return -1;
-	}
+        if (state->y < 0 || state->y >= state->ysize) {
+            /* End of file (errcode = 0) */
+            return -1;
+        }
 
-	state->state = SKIP;
+        state->state = SKIP;
 
     }
 
diff --git a/src/libImaging/RawEncode.c b/src/libImaging/RawEncode.c
index a3b74b8cf..da614a24b 100644
--- a/src/libImaging/RawEncode.c
+++ b/src/libImaging/RawEncode.c
@@ -9,8 +9,8 @@
  * in ImageFile.py, but it should be solved here instead.
  *
  * history:
- * 96-04-30 fl	created
- * 97-01-03 fl	fixed padding
+ * 96-04-30 fl created
+ * 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
-	   things up so "bytes" is the full size, and "count" the
-	   packed size */
+        /* The "count" field holds the stride, if specified.  Fix
+           things up so "bytes" is the full size, and "count" the
+           packed size */
 
-	if (state->count > 0) {
-	    int bytes = state->count;
+        if (state->count > 0) {
+            int bytes = state->count;
 
-	    /* stride must not be less than real size */
-	    if (state->count < state->bytes) {
-		state->errcode = IMAGING_CODEC_CONFIG;
-		return -1;
-	    }
-	    state->count = state->bytes;
-	    state->bytes = bytes;
-	} else
-	    state->count = state->bytes;
+            /* stride must not be less than real size */
+            if (state->count < state->bytes) {
+                state->errcode = IMAGING_CODEC_CONFIG;
+                return -1;
+            }
+            state->count = state->bytes;
+            state->bytes = bytes;
+        } else
+            state->count = state->bytes;
 
-	/* The "ystep" field specifies the orientation */
+        /* The "ystep" field specifies the orientation */
 
-	if (state->ystep < 0) {
-	    state->y = state->ysize-1;
-	    state->ystep = -1;
-	} else
-	    state->ystep = 1;
+        if (state->ystep < 0) {
+            state->y = state->ysize-1;
+            state->ystep = -1;
+        } else
+            state->ystep = 1;
 
-	state->state = 1;
+        state->state = 1;
 
     }
 
     if (bytes < state->bytes) {
-	state->errcode = IMAGING_CODEC_CONFIG;
-	return 0;
+        state->errcode = IMAGING_CODEC_CONFIG;
+        return 0;
     }
 
     ptr = buf;
 
     while (bytes >= state->bytes) {
 
-	state->shuffle(ptr, (UINT8*) im->image[state->y + state->yoff] +
-		       state->xoff * im->pixelsize, state->xsize);
+        state->shuffle(ptr, (UINT8*) im->image[state->y + state->yoff] +
+                   state->xoff * im->pixelsize, state->xsize);
 
-	if (state->bytes > state->count)
-	    /* zero-pad the buffer, if necessary */
-	    memset(ptr + state->count, 0, state->bytes - state->count);
+        if (state->bytes > state->count)
+            /* zero-pad the buffer, if necessary */
+            memset(ptr + state->count, 0, state->bytes - state->count);
 
-	ptr += state->bytes;
-	bytes -= state->bytes;
+        ptr += state->bytes;
+        bytes -= state->bytes;
 
-	state->y += state->ystep;
+        state->y += state->ystep;
 
-	if (state->y < 0 || state->y >= state->ysize) {
-	    state->errcode = IMAGING_CODEC_END;
-	    break;
-	}
+        if (state->y < 0 || state->y >= state->ysize) {
+            state->errcode = IMAGING_CODEC_END;
+            break;
+        }
 
     }
 
diff --git a/src/libImaging/SgiRleDecode.c b/src/libImaging/SgiRleDecode.c
index 3f9400a5b..2d903cc04 100644
--- a/src/libImaging/SgiRleDecode.c
+++ b/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;
diff --git a/src/libImaging/TgaRleDecode.c b/src/libImaging/TgaRleDecode.c
index d1971e546..bdbf27a14 100644
--- a/src/libImaging/TgaRleDecode.c
+++ b/src/libImaging/TgaRleDecode.c
@@ -5,8 +5,8 @@
  * decoder for Targa RLE data.
  *
  * history:
- * 97-01-04 fl	created
- * 98-09-11 fl	don't one byte per pixel; take orientation into account
+ * 97-01-04 fl created
+ * 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 */
-	if (state->ystep < 0) {
-	    state->y = state->ysize-1;
-	    state->ystep = -1;
-	} else
-	    state->ystep = 1;
+        /* check image orientation */
+        if (state->ystep < 0) {
+            state->y = state->ysize-1;
+            state->ystep = -1;
+        } else
+            state->ystep = 1;
 
-	state->state = 1;
+        state->state = 1;
 
     }
 
@@ -44,22 +44,22 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
 
     for (;;) {
 
-	if (bytes < 1)
-	    return ptr - buf;
+        if (bytes < 1)
+            return ptr - buf;
 
-	if (ptr[0] & 0x80) {
+        if (ptr[0] & 0x80) {
 
-	    /* Run (1 + pixelsize bytes) */
+            /* Run (1 + pixelsize bytes) */
 
-	    if (bytes < 1 + depth)
-		break;
+            if (bytes < 1 + depth)
+                break;
 
-	    n = depth * ((ptr[0] & 0x7f) + 1);
+            n = depth * ((ptr[0] & 0x7f) + 1);
 
-	    if (state->x + n > state->bytes) {
-		state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
-	    }
+            if (state->x + n > state->bytes) {
+                state->errcode = IMAGING_CODEC_OVERRUN;
+                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) */
-	    n = depth * (ptr[0] + 1);
+            /* Literal (1+n+1 bytes block) */
+            n = depth * (ptr[0] + 1);
 
-	    if (bytes < 1 + n)
-		break;
+            if (bytes < 1 + n)
+                break;
 
-	    if (state->x + n > state->bytes) {
-		state->errcode = IMAGING_CODEC_OVERRUN;
-		return -1;
-	    }
+            if (state->x + n > state->bytes) {
+                state->errcode = IMAGING_CODEC_OVERRUN;
+                return -1;
+            }
 
-	    memcpy(state->buffer + state->x, ptr + 1, n);
+            memcpy(state->buffer + state->x, ptr + 1, n);
 
-	    ptr += 1 + n;
-	    bytes -= 1 + n;
+            ptr += 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 */
-	    state->shuffle((UINT8*) im->image[state->y + state->yoff] +
-			   state->xoff * im->pixelsize, state->buffer,
-			   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;
+            state->x = 0;
 
             state->y += state->ystep;
 
@@ -110,7 +110,7 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
                 return -1;
             }
 
-	}
+        }
 
     }
 
diff --git a/src/libImaging/TiffDecode.h b/src/libImaging/TiffDecode.h
index 08ef35cfd..3d27e65b6 100644
--- a/src/libImaging/TiffDecode.h
+++ b/src/libImaging/TiffDecode.h
@@ -28,17 +28,17 @@
 #define _PIL_LIBTIFF_
 
 typedef struct {
-	tdata_t data; /* tdata_t == void* */
-	toff_t loc;   /* toff_t == uint32 */
-	tsize_t size; /* tsize_t == int32 */
-	int fp;
+    tdata_t data; /* tdata_t == void* */
+    toff_t loc;   /* toff_t == uint32 */
+    tsize_t size; /* tsize_t == int32 */
+    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 */
-	toff_t eof;
-	int flrealloc;/* may we realloc */
+    TIFF *tiff;   /* Used in write */
+    toff_t eof;
+    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)
 */
 
diff --git a/src/libImaging/Unpack.c b/src/libImaging/Unpack.c
index adf2dd277..6235937d1 100644
--- a/src/libImaging/Unpack.c
+++ b/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",  	"L",            8,      band0},
-    {"LAB",  	"A",            8,      band1},
-    {"LAB",  	"B",            8,      band2},
+    {"LAB",     "LAB",          24,     ImagingUnpackLAB},
+    {"LAB",     "L",            8,      band0},
+    {"LAB",     "A",            8,      band1},
+    {"LAB",     "B",            8,      band2},
 
     /* HSV Color */
-    {"HSV",	    "HSV",	        24,	    ImagingUnpackRGB},
-    {"HSV",  	"H",            8,      band0},
-    {"HSV",  	"S",            8,      band1},
-    {"HSV",  	"V",            8,      band2},
+    {"HSV",     "HSV",          24,     ImagingUnpackRGB},
+    {"HSV",     "H",            8,      band0},
+    {"HSV",     "S",            8,      band1},
+    {"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;16L", 	"I;16N",	    16,	    unpackI16N_I16}, // LibTiff native->image endian.
-    {"I;16B", 	"I;16N",	    16,	    unpackI16N_I16B},
+    {"I;16",    "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;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 */
 };
diff --git a/src/libImaging/UnpackYCC.c b/src/libImaging/UnpackYCC.c
index 19da1f654..d6bce17ad 100644
--- a/src/libImaging/UnpackYCC.c
+++ b/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	G 1
-#define	B 2
-#define	A 3
+#define R 0
+#define G 1
+#define B 2
+#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]);
-	out[A] = 255;
-	out += 4; in += 3;
+        YCC2RGB(out, in[0], in[1], in[2]);
+        out[A] = 255;
+        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 */
-	UINT8 rgb[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[2] = (in[3] == 0) ? 0 : (((int) in[2] * 255) / in[3]);
-	/* Convert non-multiplied data to RGB */
-	YCC2RGB(out, rgb[0], rgb[1], rgb[2]);
-	out[A] = in[3];
-	out += 4; in += 4;
+        /* Divide by alpha */
+        UINT8 rgb[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[2] = (in[3] == 0) ? 0 : (((int) in[2] * 255) / in[3]);
+        /* Convert non-multiplied data to RGB */
+        YCC2RGB(out, rgb[0], rgb[1], rgb[2]);
+        out[A] = in[3];
+        out += 4; in += 4;
     }
 }
diff --git a/src/libImaging/XbmDecode.c b/src/libImaging/XbmDecode.c
index 75b4961ab..088c71df3 100644
--- a/src/libImaging/XbmDecode.c
+++ b/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' :\
-		(v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
-		(v >= 'A' && v <= 'F') ? v - 'A' + 10 : 0)
+#define HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
+        (v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
+        (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) {
-		if (*ptr == 'x')
-		    break;
-		ptr++;
-		bytes--;
-	    }
+            while (bytes > 0) {
+                if (*ptr == 'x')
+                    break;
+                ptr++;
+                bytes--;
+            }
 
-	    if (bytes == 0)
-		return ptr - buf;
+            if (bytes == 0)
+                return ptr - buf;
 
-	    state->state = BYTE;
+            state->state = BYTE;
 
-	}
+        }
 
-	if (bytes < 3)
-	    return ptr - buf;
+        if (bytes < 3)
+            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 */
-	    state->shuffle((UINT8*) im->image[state->y], state->buffer,
-			   state->xsize);
+            /* Got a full line, unpack it */
+            state->shuffle((UINT8*) im->image[state->y], state->buffer,
+                   state->xsize);
 
-	    state->x = 0;
+            state->x = 0;
 
-	    if (++state->y >= state->ysize) {
-		/* End of file (errcode = 0) */
-		return -1;
-	    }
-	}
+            if (++state->y >= state->ysize) {
+                /* End of file (errcode = 0) */
+                return -1;
+            }
+        }
 
-	ptr += 3;
-	bytes -= 3;
+        ptr += 3;
+        bytes -= 3;
 
-	state->state = SKIP;
+        state->state = SKIP;
 
     }
 
diff --git a/src/libImaging/XbmEncode.c b/src/libImaging/XbmEncode.c
index e066fd6b5..cf72da619 100644
--- a/src/libImaging/XbmEncode.c
+++ b/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 */
-	state->bytes = 6*(state->xsize+7)/8;
+        /* 8 pixels are stored in no more than 6 bytes */
+        state->bytes = 6*(state->xsize+7)/8;
 
-	state->state = 1;
+        state->state = 1;
 
     }
 
     if (bytes < state->bytes) {
-	state->errcode = IMAGING_CODEC_MEMORY;
-	return 0;
+        state->errcode = IMAGING_CODEC_MEMORY;
+        return 0;
     }
 
     ptr = buf;
 
     while (bytes >= state->bytes) {
 
-	state->shuffle(state->buffer,
-		       (UINT8*) im->image[state->y + state->yoff] +
-		       state->xoff * im->pixelsize, state->xsize);
+        state->shuffle(state->buffer,
+                   (UINT8*) im->image[state->y + state->yoff] +
+                   state->xoff * im->pixelsize, state->xsize);
 
-	if (state->y < state->ysize-1) {
+        if (state->y < state->ysize-1) {
 
-	    /* any line but the last */
-	    for (n = 0; n < state->xsize; n += 8) {
+            /* any line but the last */
+            for (n = 0; n < state->xsize; n += 8) {
 
-		i = state->buffer[n/8];
+                i = state->buffer[n/8];
 
-		*ptr++ = '0';
-		*ptr++ = 'x';
-		*ptr++ = hex[(i>>4)&15];
-		*ptr++ = hex[i&15];
-		*ptr++ = ',';
-		bytes -= 5;
+                *ptr++ = '0';
+                *ptr++ = 'x';
+                *ptr++ = hex[(i>>4)&15];
+                *ptr++ = hex[i&15];
+                *ptr++ = ',';
+                bytes -= 5;
 
-		if (++state->count >= 79/5) {
-		    *ptr++ = '\n';
-		    bytes--;
-		    state->count = 0;
-		}
+                if (++state->count >= 79/5) {
+                    *ptr++ = '\n';
+                    bytes--;
+                    state->count = 0;
+                }
 
-	    }
+            }
 
-	    state->y++;
+            state->y++;
 
-	} else {
+        } else {
 
-	    /* last line */
-	    for (n = 0; n < state->xsize; n += 8) {
+            /* last line */
+            for (n = 0; n < state->xsize; n += 8) {
 
-		i = state->buffer[n/8];
+                i = state->buffer[n/8];
 
-		*ptr++ = '0';
-		*ptr++ = 'x';
-		*ptr++ = hex[(i>>4)&15];
-		*ptr++ = hex[i&15];
+                *ptr++ = '0';
+                *ptr++ = 'x';
+                *ptr++ = hex[(i>>4)&15];
+                *ptr++ = hex[i&15];
 
-		if (n < state->xsize-8) {
-		    *ptr++ = ',';
-		    if (++state->count >= 79/5) {
-			*ptr++ = '\n';
-			bytes--;
-			state->count = 0;
-		    }
-		} else
-		    *ptr++ = '\n';
+                if (n < state->xsize-8) {
+                    *ptr++ = ',';
+                    if (++state->count >= 79/5) {
+                    *ptr++ = '\n';
+                    bytes--;
+                    state->count = 0;
+                    }
+                } else
+                    *ptr++ = '\n';
 
-		bytes -= 5;
+                bytes -= 5;
 
-	    }
+            }
 
-	    state->errcode = IMAGING_CODEC_END;
-	    break;
-	}
+            state->errcode = IMAGING_CODEC_END;
+            break;
+        }
     }
 
     return ptr - buf;
diff --git a/src/libImaging/Zip.h b/src/libImaging/Zip.h
index 21a336f90..b05c93bb4 100644
--- a/src/libImaging/Zip.h
+++ b/src/libImaging/Zip.h
@@ -12,10 +12,10 @@
 
 
 /* modes */
-#define	ZIP_PNG	0		/* continuous, filtered image data */
-#define	ZIP_PNG_PALETTE	1	/* non-continuous data, disable filtering */
-#define	ZIP_TIFF_PREDICTOR 2	/* TIFF, with predictor */
-#define	ZIP_TIFF 3		/* TIFF, without predictor */
+#define ZIP_PNG 0            /* continuous, filtered image data */
+#define ZIP_PNG_PALETTE 1    /* non-continuous data, disable filtering */
+#define ZIP_TIFF_PREDICTOR 2 /* TIFF, with 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;
diff --git a/src/outline.c b/src/outline.c
index 25e63aeaf..8a7cc32ad 100644
--- a/src/outline.c
+++ b/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)
-	"Outline",			/*tp_name*/
-	sizeof(OutlineObject),		/*tp_size*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	(destructor)_outline_dealloc,	/*tp_dealloc*/
-	0,				/*tp_print*/
-    0,                          /*tp_getattr*/
-    0,                          /*tp_setattr*/
-    0,                          /*tp_compare*/
-    0,                          /*tp_repr*/
-    0,                          /*tp_as_number */
-    0,                          /*tp_as_sequence */
-    0,                          /*tp_as_mapping */
-    0,                          /*tp_hash*/
-    0,                          /*tp_call*/
-    0,                          /*tp_str*/
-    0,                          /*tp_getattro*/
-    0,                          /*tp_setattro*/
-    0,                          /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT,         /*tp_flags*/
-    0,                          /*tp_doc*/
-    0,                          /*tp_traverse*/
-    0,                          /*tp_clear*/
-    0,                          /*tp_richcompare*/
-    0,                          /*tp_weaklistoffset*/
-    0,                          /*tp_iter*/
-    0,                          /*tp_iternext*/
-    _outline_methods,           /*tp_methods*/
-    0,                          /*tp_members*/
-    0,                          /*tp_getset*/
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "Outline",                   /*tp_name*/
+    sizeof(OutlineObject),       /*tp_size*/
+    0,                           /*tp_itemsize*/
+    /* methods */
+    (destructor)_outline_dealloc,/*tp_dealloc*/
+    0,                           /*tp_print*/
+    0,                           /*tp_getattr*/
+    0,                           /*tp_setattr*/
+    0,                           /*tp_compare*/
+    0,                           /*tp_repr*/
+    0,                           /*tp_as_number */
+    0,                           /*tp_as_sequence */
+    0,                           /*tp_as_mapping */
+    0,                           /*tp_hash*/
+    0,                           /*tp_call*/
+    0,                           /*tp_str*/
+    0,                           /*tp_getattro*/
+    0,                           /*tp_setattro*/
+    0,                           /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT,          /*tp_flags*/
+    0,                           /*tp_doc*/
+    0,                           /*tp_traverse*/
+    0,                           /*tp_clear*/
+    0,                           /*tp_richcompare*/
+    0,                           /*tp_weaklistoffset*/
+    0,                           /*tp_iter*/
+    0,                           /*tp_iternext*/
+    _outline_methods,            /*tp_methods*/
+    0,                           /*tp_members*/
+    0,                           /*tp_getset*/
 };