diff --git a/Tests/test_file_tiff.py b/Tests/test_file_tiff.py
index fc98901a4..ccef7a513 100644
--- a/Tests/test_file_tiff.py
+++ b/Tests/test_file_tiff.py
@@ -876,16 +876,24 @@ class TestFileTiff:
 
     def test_open_tiff_uint16_multiband(self):
         """Test opening multiband TIFFs and reading all channels."""
-        base_value = 4660
-        for i in range(1, 6):
-            infile = f"Tests/images/uint16_{i}_{base_value}.tif"
-            im = Image.open(infile)
-            im.load()
-            pixel = tuple([base_value + j for j in range(0, i)])
+
+        def getpixel00(im: Image.Image):
             actual_pixel = im.getpixel((0, 0))
             if isinstance(actual_pixel, int):
                 actual_pixel = (actual_pixel,)
-            assert actual_pixel == pixel
+            return actual_pixel
+
+        base_value = 4660
+        for i in range(1, 6):
+            pixel = tuple([base_value + j for j in range(0, i)])
+            infile = f"Tests/images/uint16_{i}_{base_value}.tif"
+            im = Image.open(infile)
+
+            im.load()
+            assert getpixel00(im) == pixel
+
+            im.copy()
+            assert getpixel00(im) == pixel
 
 
 @pytest.mark.skipif(not is_win32(), reason="Windows only")
diff --git a/src/_imaging.c b/src/_imaging.c
index 617acf503..8e2df33ab 100644
--- a/src/_imaging.c
+++ b/src/_imaging.c
@@ -309,7 +309,7 @@ getbands(const char *mode) {
     int bands;
 
     /* FIXME: add primitive to libImaging to avoid extra allocation */
-    im = ImagingNew(mode, 0, 0, -1, -1);
+    im = ImagingNew(mode, (ImagingNewParams){0, 0});
     if (!im) {
         return -1;
     }
@@ -697,7 +697,7 @@ _fill(PyObject *self, PyObject *args) {
         return NULL;
     }
 
-    im = ImagingNewDirty(mode, xsize, ysize);
+    im = ImagingNewDirty(mode, (ImagingNewParams){xsize, ysize});
     if (!im) {
         return NULL;
     }
@@ -724,7 +724,8 @@ _new(PyObject *self, PyObject *args) {
         return NULL;
     }
 
-    return PyImagingNew(ImagingNew(mode, xsize, ysize, depth, bands));
+    return PyImagingNew(
+        ImagingNew(mode, (ImagingNewParams){xsize, ysize, depth, bands}));
 }
 
 static PyObject *
@@ -940,7 +941,8 @@ _color_lut_3d(ImagingObject *self, PyObject *args) {
         return NULL;
     }
 
-    imOut = ImagingNewDirty(mode, self->image->xsize, self->image->ysize);
+    imOut = ImagingNewDirty(
+        mode, (ImagingNewParams){self->image->xsize, self->image->ysize});
     if (!imOut) {
         free(prepared_table);
         return NULL;
@@ -1127,7 +1129,7 @@ _gaussian_blur(ImagingObject *self, PyObject *args) {
     }
 
     imIn = self->image;
-    imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
+    imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
     if (!imOut) {
         return NULL;
     }
@@ -1747,8 +1749,8 @@ _quantize(ImagingObject *self, PyObject *args) {
 
     if (!self->image->xsize || !self->image->ysize) {
         /* no content; return an empty image */
-        return PyImagingNew(
-            ImagingNew("P", self->image->xsize, self->image->ysize, -1, -1));
+        return PyImagingNew(ImagingNew(
+            "P", (ImagingNewParams){self->image->xsize, self->image->ysize}));
     }
 
     return PyImagingNew(ImagingQuantize(self->image, colours, method, kmeans));
@@ -1955,7 +1957,7 @@ _resize(ImagingObject *self, PyObject *args) {
         a[2] = box[0];
         a[5] = box[1];
 
-        imOut = ImagingNewDirty(imIn->mode, xsize, ysize);
+        imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){xsize, ysize});
 
         imOut = ImagingTransform(
             imOut, imIn, IMAGING_TRANSFORM_AFFINE, 0, 0, xsize, ysize, a, filter, 1);
@@ -2140,13 +2142,15 @@ _transpose(ImagingObject *self, PyObject *args) {
         case 0: /* flip left right */
         case 1: /* flip top bottom */
         case 3: /* rotate 180 */
-            imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
+            imOut = ImagingNewDirty(
+                imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
             break;
         case 2: /* rotate 90 */
         case 4: /* rotate 270 */
         case 5: /* transpose */
         case 6: /* transverse */
-            imOut = ImagingNewDirty(imIn->mode, imIn->ysize, imIn->xsize);
+            imOut = ImagingNewDirty(
+                imIn->mode, (ImagingNewParams){imIn->ysize, imIn->xsize});
             break;
         default:
             PyErr_SetString(PyExc_ValueError, "No such transpose operation");
@@ -2195,7 +2199,7 @@ _unsharp_mask(ImagingObject *self, PyObject *args) {
     }
 
     imIn = self->image;
-    imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
+    imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
     if (!imOut) {
         return NULL;
     }
@@ -2220,7 +2224,7 @@ _box_blur(ImagingObject *self, PyObject *args) {
     }
 
     imIn = self->image;
-    imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
+    imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
     if (!imOut) {
         return NULL;
     }
@@ -2816,7 +2820,8 @@ _font_getmask(ImagingFontObject *self, PyObject *args) {
         return NULL;
     }
 
-    im = ImagingNew(self->bitmap->mode, textwidth(self, text), self->ysize, -1, -1);
+    im = ImagingNew(
+        self->bitmap->mode, (ImagingNewParams){textwidth(self, text), self->ysize});
     if (!im) {
         free(text);
         return ImagingError_MemoryError();
diff --git a/src/libImaging/AlphaComposite.c b/src/libImaging/AlphaComposite.c
index 6d728f908..b47441a6a 100644
--- a/src/libImaging/AlphaComposite.c
+++ b/src/libImaging/AlphaComposite.c
@@ -36,7 +36,8 @@ ImagingAlphaComposite(Imaging imDst, Imaging imSrc) {
         return ImagingError_Mismatch();
     }
 
-    imOut = ImagingNewDirty(imDst->mode, imDst->xsize, imDst->ysize);
+    imOut =
+        ImagingNewDirty(imDst->mode, (ImagingNewParams){imDst->xsize, imDst->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Bands.c b/src/libImaging/Bands.c
index e1b16b34a..d9b31ce1d 100644
--- a/src/libImaging/Bands.c
+++ b/src/libImaging/Bands.c
@@ -41,7 +41,7 @@ ImagingGetBand(Imaging imIn, int band) {
         band = 3;
     }
 
-    imOut = ImagingNewDirty("L", imIn->xsize, imIn->ysize);
+    imOut = ImagingNewDirty("L", (ImagingNewParams){imIn->xsize, imIn->ysize});
     if (!imOut) {
         return NULL;
     }
@@ -82,7 +82,7 @@ ImagingSplit(Imaging imIn, Imaging bands[4]) {
     }
 
     for (i = 0; i < imIn->bands; i++) {
-        bands[i] = ImagingNewDirty("L", imIn->xsize, imIn->ysize);
+        bands[i] = ImagingNewDirty("L", (ImagingNewParams){imIn->xsize, imIn->ysize});
         if (!bands[i]) {
             for (j = 0; j < i; ++j) {
                 ImagingDelete(bands[j]);
@@ -265,7 +265,8 @@ ImagingMerge(const char *mode, Imaging bands[4]) {
     }
     bandsCount = i;
 
-    imOut = ImagingNewDirty(mode, firstBand->xsize, firstBand->ysize);
+    imOut =
+        ImagingNewDirty(mode, (ImagingNewParams){firstBand->xsize, firstBand->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Blend.c b/src/libImaging/Blend.c
index a53ae0fad..444bf7f40 100644
--- a/src/libImaging/Blend.c
+++ b/src/libImaging/Blend.c
@@ -41,7 +41,8 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha) {
         return ImagingCopy(imIn2);
     }
 
-    imOut = ImagingNewDirty(imIn1->mode, imIn1->xsize, imIn1->ysize);
+    imOut =
+        ImagingNewDirty(imIn1->mode, (ImagingNewParams){imIn1->xsize, imIn1->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/BoxBlur.c b/src/libImaging/BoxBlur.c
index 4ea9c7717..366e81ee6 100644
--- a/src/libImaging/BoxBlur.c
+++ b/src/libImaging/BoxBlur.c
@@ -269,7 +269,8 @@ ImagingBoxBlur(Imaging imOut, Imaging imIn, float xradius, float yradius, int n)
         }
     }
     if (yradius != 0) {
-        imTransposed = ImagingNewDirty(imIn->mode, imIn->ysize, imIn->xsize);
+        imTransposed =
+            ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->ysize, imIn->xsize});
         if (!imTransposed) {
             return NULL;
         }
diff --git a/src/libImaging/Chops.c b/src/libImaging/Chops.c
index f9c005efe..580568dc1 100644
--- a/src/libImaging/Chops.c
+++ b/src/libImaging/Chops.c
@@ -74,7 +74,7 @@ create(Imaging im1, Imaging im2, char *mode) {
     xsize = (im1->xsize < im2->xsize) ? im1->xsize : im2->xsize;
     ysize = (im1->ysize < im2->ysize) ? im1->ysize : im2->ysize;
 
-    return ImagingNewDirty(im1->mode, xsize, ysize);
+    return ImagingNewDirty(im1->mode, (ImagingNewParams){xsize, ysize});
 }
 
 Imaging
diff --git a/src/libImaging/Crop.c b/src/libImaging/Crop.c
index 2425b4cd5..630028d0e 100644
--- a/src/libImaging/Crop.c
+++ b/src/libImaging/Crop.c
@@ -37,7 +37,7 @@ ImagingCrop(Imaging imIn, int sx0, int sy0, int sx1, int sy1) {
         ysize = 0;
     }
 
-    imOut = ImagingNewDirty(imIn->mode, xsize, ysize);
+    imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){xsize, ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Effects.c b/src/libImaging/Effects.c
index 93e7af0bc..3d8a2e984 100644
--- a/src/libImaging/Effects.c
+++ b/src/libImaging/Effects.c
@@ -36,7 +36,7 @@ ImagingEffectMandelbrot(int xsize, int ysize, double extent[4], int quality) {
         return (Imaging)ImagingError_ValueError(NULL);
     }
 
-    im = ImagingNewDirty("L", xsize, ysize);
+    im = ImagingNewDirty("L", (ImagingNewParams){xsize, ysize});
     if (!im) {
         return NULL;
     }
@@ -80,7 +80,7 @@ ImagingEffectNoise(int xsize, int ysize, float sigma) {
     int nextok;
     double this, next;
 
-    imOut = ImagingNewDirty("L", xsize, ysize);
+    imOut = ImagingNewDirty("L", (ImagingNewParams){xsize, ysize});
     if (!imOut) {
         return NULL;
     }
@@ -120,7 +120,7 @@ ImagingEffectSpread(Imaging imIn, int distance) {
     Imaging imOut;
     int x, y;
 
-    imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
+    imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
 
     if (!imOut) {
         return NULL;
diff --git a/src/libImaging/Fill.c b/src/libImaging/Fill.c
index 5b6bfb89c..0090c23ab 100644
--- a/src/libImaging/Fill.c
+++ b/src/libImaging/Fill.c
@@ -76,7 +76,7 @@ ImagingFillLinearGradient(const char *mode) {
         return (Imaging)ImagingError_ModeError();
     }
 
-    im = ImagingNewDirty(mode, 256, 256);
+    im = ImagingNewDirty(mode, (ImagingNewParams){256, 256});
     if (!im) {
         return NULL;
     }
@@ -111,7 +111,7 @@ ImagingFillRadialGradient(const char *mode) {
         return (Imaging)ImagingError_ModeError();
     }
 
-    im = ImagingNewDirty(mode, 256, 256);
+    im = ImagingNewDirty(mode, (ImagingNewParams){256, 256});
     if (!im) {
         return NULL;
     }
diff --git a/src/libImaging/Filter.c b/src/libImaging/Filter.c
index 85de77fcb..87928acc8 100644
--- a/src/libImaging/Filter.c
+++ b/src/libImaging/Filter.c
@@ -59,7 +59,8 @@ ImagingExpand(Imaging imIn, int xmargin, int ymargin) {
     }
 
     imOut = ImagingNewDirty(
-        imIn->mode, imIn->xsize + 2 * xmargin, imIn->ysize + 2 * ymargin);
+        imIn->mode,
+        (ImagingNewParams){imIn->xsize + 2 * xmargin, imIn->ysize + 2 * ymargin});
     if (!imOut) {
         return NULL;
     }
@@ -393,7 +394,7 @@ ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32 *kernel, FLOAT32 o
         return (Imaging)ImagingError_ValueError("bad kernel size");
     }
 
-    imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize);
+    imOut = ImagingNewDirty(im->mode, (ImagingNewParams){im->xsize, im->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Imaging.h b/src/libImaging/Imaging.h
index ee2f6ea9d..6dc14ee1c 100644
--- a/src/libImaging/Imaging.h
+++ b/src/libImaging/Imaging.h
@@ -75,6 +75,13 @@ typedef struct ImagingPaletteInstance *ImagingPalette;
 
 #define IMAGING_MODE_MB "MB" /* multi-band format */
 
+typedef struct {
+    int xsize;
+    int ysize;
+    int depth;
+    int bands;
+} ImagingNewParams;
+
 typedef struct {
     char *ptr;
     int size;
@@ -176,9 +183,9 @@ extern void
 ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size);
 
 extern Imaging
-ImagingNew(const char *mode, int xsize, int ysize, int depth, int bands);
+ImagingNew(const char *mode, ImagingNewParams p);
 extern Imaging
-ImagingNewDirty(const char *mode, int xsize, int ysize);
+ImagingNewDirty(const char *mode, ImagingNewParams p);
 extern Imaging
 ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn);
 extern void
@@ -188,10 +195,9 @@ extern Imaging
 ImagingNewBlock(const char *mode, int xsize, int ysize);
 
 extern Imaging
-ImagingNewPrologue(const char *mode, int xsize, int ysize, int depth, int bands);
+ImagingNewPrologue(const char *mode, ImagingNewParams p);
 extern Imaging
-ImagingNewPrologueSubtype(
-    const char *mode, int xsize, int ysize, int depth, int bands, int structure_size);
+ImagingNewPrologueSubtype(const char *mode, ImagingNewParams p, int structure_size);
 
 extern void
 ImagingCopyPalette(Imaging destination, Imaging source);
diff --git a/src/libImaging/Matrix.c b/src/libImaging/Matrix.c
index ec7f4d93e..45cc48647 100644
--- a/src/libImaging/Matrix.c
+++ b/src/libImaging/Matrix.c
@@ -29,7 +29,7 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[]) {
     }
 
     if (strcmp(mode, "L") == 0) {
-        imOut = ImagingNewDirty("L", im->xsize, im->ysize);
+        imOut = ImagingNewDirty("L", (ImagingNewParams){im->xsize, im->ysize});
         if (!imOut) {
             return NULL;
         }
@@ -48,7 +48,7 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[]) {
         ImagingSectionLeave(&cookie);
 
     } else if (strlen(mode) == 3) {
-        imOut = ImagingNewDirty(mode, im->xsize, im->ysize);
+        imOut = ImagingNewDirty(mode, (ImagingNewParams){im->xsize, im->ysize});
         if (!imOut) {
             return NULL;
         }
diff --git a/src/libImaging/ModeFilter.c b/src/libImaging/ModeFilter.c
index 757cbc3fb..0178fbef0 100644
--- a/src/libImaging/ModeFilter.c
+++ b/src/libImaging/ModeFilter.c
@@ -28,7 +28,7 @@ ImagingModeFilter(Imaging im, int size) {
         return (Imaging)ImagingError_ModeError();
     }
 
-    imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize);
+    imOut = ImagingNewDirty(im->mode, (ImagingNewParams){im->xsize, im->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Negative.c b/src/libImaging/Negative.c
index 70b96c397..887558130 100644
--- a/src/libImaging/Negative.c
+++ b/src/libImaging/Negative.c
@@ -27,7 +27,7 @@ ImagingNegative(Imaging im) {
         return (Imaging)ImagingError_ModeError();
     }
 
-    imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize);
+    imOut = ImagingNewDirty(im->mode, (ImagingNewParams){im->xsize, im->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Offset.c b/src/libImaging/Offset.c
index 91ee91083..9bc74a4fe 100644
--- a/src/libImaging/Offset.c
+++ b/src/libImaging/Offset.c
@@ -25,7 +25,7 @@ ImagingOffset(Imaging im, int xoffset, int yoffset) {
         return (Imaging)ImagingError_ModeError();
     }
 
-    imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize);
+    imOut = ImagingNewDirty(im->mode, (ImagingNewParams){im->xsize, im->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Point.c b/src/libImaging/Point.c
index 3d54008cb..bf4b6c8ef 100644
--- a/src/libImaging/Point.c
+++ b/src/libImaging/Point.c
@@ -152,7 +152,7 @@ ImagingPoint(Imaging imIn, const char *mode, const void *table) {
         goto mode_mismatch;
     }
 
-    imOut = ImagingNew(mode, imIn->xsize, imIn->ysize, -1, -1);
+    imOut = ImagingNew(mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
     if (!imOut) {
         return NULL;
     }
@@ -214,7 +214,7 @@ ImagingPointTransform(Imaging imIn, double scale, double offset) {
         return (Imaging)ImagingError_ModeError();
     }
 
-    imOut = ImagingNew(imIn->mode, imIn->xsize, imIn->ysize, -1, -1);
+    imOut = ImagingNew(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Quant.c b/src/libImaging/Quant.c
index cdc614536..8912bbd1b 100644
--- a/src/libImaging/Quant.c
+++ b/src/libImaging/Quant.c
@@ -1799,7 +1799,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
     ImagingSectionLeave(&cookie);
 
     if (result > 0) {
-        imOut = ImagingNewDirty("P", im->xsize, im->ysize);
+        imOut = ImagingNewDirty("P", (ImagingNewParams){im->xsize, im->ysize});
         ImagingSectionEnter(&cookie);
 
         for (i = y = 0; y < im->ysize; y++) {
diff --git a/src/libImaging/RankFilter.c b/src/libImaging/RankFilter.c
index da40c892f..9389a7bf5 100644
--- a/src/libImaging/RankFilter.c
+++ b/src/libImaging/RankFilter.c
@@ -84,8 +84,8 @@ MakeRankFunction(UINT8) MakeRankFunction(INT32) MakeRankFunction(FLOAT32)
         return (Imaging)ImagingError_ValueError("bad rank value");
     }
 
-    imOut =
-        ImagingNew(im->mode, im->xsize - 2 * margin, im->ysize - 2 * margin, -1, -1);
+    imOut = ImagingNew(
+        im->mode, (ImagingNewParams){im->xsize - 2 * margin, im->ysize - 2 * margin});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Reduce.c b/src/libImaging/Reduce.c
index 61566f0c5..bb1a86848 100644
--- a/src/libImaging/Reduce.c
+++ b/src/libImaging/Reduce.c
@@ -1427,7 +1427,9 @@ ImagingReduce(Imaging imIn, int xscale, int yscale, int box[4]) {
     }
 
     imOut = ImagingNewDirty(
-        imIn->mode, (box[2] + xscale - 1) / xscale, (box[3] + yscale - 1) / yscale);
+        imIn->mode,
+        (ImagingNewParams){
+            (box[2] + xscale - 1) / xscale, (box[3] + yscale - 1) / yscale});
     if (!imOut) {
         return NULL;
     }
diff --git a/src/libImaging/Resample.c b/src/libImaging/Resample.c
index 59c27b3f4..526c892fb 100644
--- a/src/libImaging/Resample.c
+++ b/src/libImaging/Resample.c
@@ -659,7 +659,8 @@ ImagingResampleInner(
             bounds_vert[i * 2] -= ybox_first;
         }
 
-        imTemp = ImagingNewDirty(imIn->mode, xsize, ybox_last - ybox_first);
+        imTemp = ImagingNewDirty(
+            imIn->mode, (ImagingNewParams){xsize, ybox_last - ybox_first});
         if (imTemp) {
             ResampleHorizontal(
                 imTemp, imIn, ybox_first, ksize_horiz, bounds_horiz, kk_horiz);
@@ -680,7 +681,7 @@ ImagingResampleInner(
 
     /* vertical pass */
     if (need_vertical) {
-        imOut = ImagingNewDirty(imIn->mode, imIn->xsize, ysize);
+        imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, ysize});
         if (imOut) {
             /* imIn can be the original image or horizontally resampled one */
             ResampleVertical(imOut, imIn, 0, ksize_vert, bounds_vert, kk_vert);
diff --git a/src/libImaging/Storage.c b/src/libImaging/Storage.c
index 382dbfa49..788366161 100644
--- a/src/libImaging/Storage.c
+++ b/src/libImaging/Storage.c
@@ -42,12 +42,11 @@
  */
 
 Imaging
-ImagingNewPrologueSubtype(
-    const char *mode, int xsize, int ysize, int depth, int bands, int size) {
+ImagingNewPrologueSubtype(const char *mode, ImagingNewParams p, int size) {
     Imaging im;
 
     /* linesize overflow check, roughly the current largest space req'd */
-    if (xsize > (INT_MAX / 4) - 1) {
+    if (p.xsize > (INT_MAX / 4) - 1) {
         return (Imaging)ImagingError_MemoryError();
     }
 
@@ -57,58 +56,58 @@ ImagingNewPrologueSubtype(
     }
 
     /* Setup image descriptor */
-    im->xsize = xsize;
-    im->ysize = ysize;
+    im->xsize = p.xsize;
+    im->ysize = p.ysize;
 
     im->type = IMAGING_TYPE_UINT8;
 
     if (strcmp(mode, "1") == 0) {
         /* 1-bit images */
         im->bands = im->pixelsize = 1;
-        im->linesize = xsize;
+        im->linesize = p.xsize;
 
     } else if (strcmp(mode, "P") == 0) {
         /* 8-bit palette mapped images */
         im->bands = im->pixelsize = 1;
-        im->linesize = xsize;
+        im->linesize = p.xsize;
         im->palette = ImagingPaletteNew("RGB");
 
     } else if (strcmp(mode, "PA") == 0) {
         /* 8-bit palette with alpha */
         im->bands = 2;
         im->pixelsize = 4; /* store in image32 memory */
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
         im->palette = ImagingPaletteNew("RGB");
 
     } else if (strcmp(mode, "L") == 0) {
         /* 8-bit grayscale (luminance) images */
         im->bands = im->pixelsize = 1;
-        im->linesize = xsize;
+        im->linesize = p.xsize;
 
     } else if (strcmp(mode, "LA") == 0) {
         /* 8-bit grayscale (luminance) with alpha */
         im->bands = 2;
         im->pixelsize = 4; /* store in image32 memory */
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "La") == 0) {
         /* 8-bit grayscale (luminance) with premultiplied alpha */
         im->bands = 2;
         im->pixelsize = 4; /* store in image32 memory */
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "F") == 0) {
         /* 32-bit floating point images */
         im->bands = 1;
         im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
         im->type = IMAGING_TYPE_FLOAT32;
 
     } else if (strcmp(mode, "I") == 0) {
         /* 32-bit integer images */
         im->bands = 1;
         im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
         im->type = IMAGING_TYPE_INT32;
 
     } else if (
@@ -118,21 +117,21 @@ ImagingNewPrologueSubtype(
         /* 16-bit raw integer images */
         im->bands = 1;
         im->pixelsize = 2;
-        im->linesize = xsize * 2;
+        im->linesize = p.xsize * 2;
         im->type = IMAGING_TYPE_SPECIAL;
 
     } else if (strcmp(mode, "RGB") == 0) {
         /* 24-bit true colour images */
         im->bands = 3;
         im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "BGR;15") == 0) {
         /* EXPERIMENTAL */
         /* 15-bit reversed true colour */
         im->bands = 3;
         im->pixelsize = 2;
-        im->linesize = (xsize * 2 + 3) & -4;
+        im->linesize = (p.xsize * 2 + 3) & -4;
         im->type = IMAGING_TYPE_SPECIAL;
 
     } else if (strcmp(mode, "BGR;16") == 0) {
@@ -140,7 +139,7 @@ ImagingNewPrologueSubtype(
         /* 16-bit reversed true colour */
         im->bands = 3;
         im->pixelsize = 2;
-        im->linesize = (xsize * 2 + 3) & -4;
+        im->linesize = (p.xsize * 2 + 3) & -4;
         im->type = IMAGING_TYPE_SPECIAL;
 
     } else if (strcmp(mode, "BGR;24") == 0) {
@@ -148,58 +147,58 @@ ImagingNewPrologueSubtype(
         /* 24-bit reversed true colour */
         im->bands = 3;
         im->pixelsize = 3;
-        im->linesize = (xsize * 3 + 3) & -4;
+        im->linesize = (p.xsize * 3 + 3) & -4;
         im->type = IMAGING_TYPE_SPECIAL;
 
     } else if (strcmp(mode, "RGBX") == 0) {
         /* 32-bit true colour images with padding */
         im->bands = im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "RGBA") == 0) {
         /* 32-bit true colour images with alpha */
         im->bands = im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "RGBa") == 0) {
         /* 32-bit true colour images with premultiplied alpha */
         im->bands = im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "CMYK") == 0) {
         /* 32-bit colour separation */
         im->bands = im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "YCbCr") == 0) {
         /* 24-bit video format */
         im->bands = 3;
         im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "LAB") == 0) {
         /* 24-bit color, luminance, + 2 color channels */
         /* L is uint8, a,b are int8 */
         im->bands = 3;
         im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, "HSV") == 0) {
         /* 24-bit color, luminance, + 2 color channels */
         /* L is uint8, a,b are int8 */
         im->bands = 3;
         im->pixelsize = 4;
-        im->linesize = xsize * 4;
+        im->linesize = p.xsize * 4;
 
     } else if (strcmp(mode, IMAGING_MODE_MB) == 0) {
-        if (bands <= 0 || depth <= 0) {
+        if (p.bands <= 0 || p.depth <= 0) {
             return (Imaging)ImagingError_ValueError(
                 "multi-band missing bands and depth");
         }
-        im->bands = bands;
-        im->depth = depth;
-        im->pixelsize = depth / CHAR_BIT * bands;
-        im->linesize = xsize * im->pixelsize;
+        im->bands = p.bands;
+        im->depth = p.depth;
+        im->pixelsize = p.depth / CHAR_BIT * p.bands;
+        im->linesize = p.xsize * im->pixelsize;
         im->type = IMAGING_TYPE_MB;
 
     } else {
@@ -212,7 +211,7 @@ ImagingNewPrologueSubtype(
 
     /* Pointer array (allocate at least one line, to avoid MemoryError
        exceptions on platforms where calloc(0, x) returns NULL) */
-    im->image = (char **)calloc((ysize > 0) ? ysize : 1, sizeof(void *));
+    im->image = (char **)calloc((p.ysize > 0) ? p.ysize : 1, sizeof(void *));
 
     if (!im->image) {
         free(im);
@@ -237,9 +236,8 @@ ImagingNewPrologueSubtype(
 }
 
 Imaging
-ImagingNewPrologue(const char *mode, int xsize, int ysize, int depth, int bands) {
-    return ImagingNewPrologueSubtype(
-        mode, xsize, ysize, depth, bands, sizeof(struct ImagingMemoryInstance));
+ImagingNewPrologue(const char *mode, ImagingNewParams p) {
+    return ImagingNewPrologueSubtype(mode, p, sizeof(struct ImagingMemoryInstance));
 }
 
 void
@@ -498,15 +496,14 @@ ImagingAllocateBlock(Imaging im) {
  */
 
 static Imaging
-ImagingNewInternal(
-    const char *mode, int xsize, int ysize, int depth, int bands, int dirty) {
+ImagingNewInternal(const char *mode, ImagingNewParams p, int dirty) {
     Imaging im;
 
-    if (xsize < 0 || ysize < 0) {
+    if (p.xsize < 0 || p.ysize < 0) {
         return (Imaging)ImagingError_ValueError("bad image size");
     }
 
-    im = ImagingNewPrologue(mode, xsize, ysize, depth, bands);
+    im = ImagingNewPrologue(mode, p);
     if (!im) {
         return NULL;
     }
@@ -527,13 +524,13 @@ ImagingNewInternal(
 }
 
 Imaging
-ImagingNew(const char *mode, int xsize, int ysize, int depth, int bands) {
-    return ImagingNewInternal(mode, xsize, ysize, depth, bands, 0);
+ImagingNew(const char *mode, ImagingNewParams p) {
+    return ImagingNewInternal(mode, p, 0);
 }
 
 Imaging
-ImagingNewDirty(const char *mode, int xsize, int ysize) {
-    return ImagingNewInternal(mode, xsize, ysize, -1, -1, 1);
+ImagingNewDirty(const char *mode, ImagingNewParams p) {
+    return ImagingNewInternal(mode, p, 1);
 }
 
 Imaging
@@ -544,7 +541,7 @@ ImagingNewBlock(const char *mode, int xsize, int ysize) {
         return (Imaging)ImagingError_ValueError("bad image size");
     }
 
-    im = ImagingNewPrologue(mode, xsize, ysize, -1, -1);
+    im = ImagingNewPrologue(mode, (ImagingNewParams){xsize, ysize});
     if (!im) {
         return NULL;
     }
@@ -564,12 +561,15 @@ ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn) {
     if (imOut) {
         /* make sure images match */
         if (strcmp(imOut->mode, mode) != 0 || imOut->xsize != imIn->xsize ||
-            imOut->ysize != imIn->ysize) {
+            imOut->ysize != imIn->ysize || imOut->depth != imIn->depth ||
+            imOut->bands != imIn->bands) {
             return ImagingError_Mismatch();
         }
     } else {
         /* create new image */
-        imOut = ImagingNewDirty(mode, imIn->xsize, imIn->ysize);
+        imOut = ImagingNewDirty(
+            mode,
+            (ImagingNewParams){imIn->xsize, imIn->ysize, imIn->depth, imIn->bands});
         if (!imOut) {
             return NULL;
         }
diff --git a/src/map.c b/src/map.c
index 46db0aede..acbac1562 100644
--- a/src/map.c
+++ b/src/map.c
@@ -125,7 +125,9 @@ PyImaging_MapBuffer(PyObject *self, PyObject *args) {
     }
 
     im = ImagingNewPrologueSubtype(
-        mode, xsize, ysize, depth, bands, sizeof(ImagingBufferInstance));
+        mode,
+        (ImagingNewParams){xsize, ysize, depth, bands},
+        sizeof(ImagingBufferInstance));
     if (!im) {
         PyBuffer_Release(&view);
         return NULL;