python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-07-11 00:32:27 +03:00
Code Issues Packages Projects Releases Wiki Activity

copy() with multi-band format

Browse Source
This commit is contained in:
Junxiao Shi 2024-06-02 12:27:51 +00:00
parent fb7702f638
commit 86e7fc6b82
23 changed files with 128 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Tests/test_file_tiff.py
View File

@ -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")

31
src/_imaging.c
View File

@ -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();

3
src/libImaging/AlphaComposite.c
View File

@ -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;
}

7
src/libImaging/Bands.c
View File

@ -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;
}

3
src/libImaging/Blend.c
View File

@ -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;
}

3
src/libImaging/BoxBlur.c
View File

@ -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;
}

2
src/libImaging/Chops.c
View File

@ -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

2
src/libImaging/Crop.c
View File

@ -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;
}

6
src/libImaging/Effects.c
View File

@ -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;

4
src/libImaging/Fill.c
View File

@ -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;
}

5
src/libImaging/Filter.c
View File

@ -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;
}

16
src/libImaging/Imaging.h
View File

@ -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);

4
src/libImaging/Matrix.c
View File

@ -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;
}

2
src/libImaging/ModeFilter.c
View File

@ -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;
}

2
src/libImaging/Negative.c
View File

@ -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;
}

2
src/libImaging/Offset.c
View File

@ -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;
}

4
src/libImaging/Point.c
View File

@ -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;
}

2
src/libImaging/Quant.c
View File

@ -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++) {

4
src/libImaging/RankFilter.c
View File

@ -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;
}

4
src/libImaging/Reduce.c
View File

@ -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;
}

5
src/libImaging/Resample.c
View File

@ -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);

90
src/libImaging/Storage.c
View File

@ -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;
}

4
src/map.c
View File

@ -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;