python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-07-11 08:42:35 +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): def test_open_tiff_uint16_multiband(self):
"""Test opening multiband TIFFs and reading all channels.""" """Test opening multiband TIFFs and reading all channels."""
base_value = 4660
for i in range(1, 6): def getpixel00(im: Image.Image):
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)])
actual_pixel = im.getpixel((0, 0)) actual_pixel = im.getpixel((0, 0))
if isinstance(actual_pixel, int): if isinstance(actual_pixel, int):
actual_pixel = (actual_pixel,) 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") @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; int bands;
/* FIXME: add primitive to libImaging to avoid extra allocation */ /* FIXME: add primitive to libImaging to avoid extra allocation */
im = ImagingNew(mode, 0, 0, -1, -1); im = ImagingNew(mode, (ImagingNewParams){0, 0});
if (!im) { if (!im) {
return -1; return -1;
} }
@ -697,7 +697,7 @@ _fill(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
im = ImagingNewDirty(mode, xsize, ysize); im = ImagingNewDirty(mode, (ImagingNewParams){xsize, ysize});
if (!im) { if (!im) {
return NULL; return NULL;
} }
@ -724,7 +724,8 @@ _new(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
return PyImagingNew(ImagingNew(mode, xsize, ysize, depth, bands)); return PyImagingNew(
ImagingNew(mode, (ImagingNewParams){xsize, ysize, depth, bands}));
} }
static PyObject * static PyObject *
@ -940,7 +941,8 @@ _color_lut_3d(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
imOut = ImagingNewDirty(mode, self->image->xsize, self->image->ysize); imOut = ImagingNewDirty(
mode, (ImagingNewParams){self->image->xsize, self->image->ysize});
if (!imOut) { if (!imOut) {
free(prepared_table); free(prepared_table);
return NULL; return NULL;
@ -1127,7 +1129,7 @@ _gaussian_blur(ImagingObject *self, PyObject *args) {
} }
imIn = self->image; imIn = self->image;
imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize); imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -1747,8 +1749,8 @@ _quantize(ImagingObject *self, PyObject *args) {
if (!self->image->xsize || !self->image->ysize) { if (!self->image->xsize || !self->image->ysize) {
/* no content; return an empty image */ /* no content; return an empty image */
return PyImagingNew( return PyImagingNew(ImagingNew(
ImagingNew("P", self->image->xsize, self->image->ysize, -1, -1)); "P", (ImagingNewParams){self->image->xsize, self->image->ysize}));
} }
return PyImagingNew(ImagingQuantize(self->image, colours, method, kmeans)); return PyImagingNew(ImagingQuantize(self->image, colours, method, kmeans));
@ -1955,7 +1957,7 @@ _resize(ImagingObject *self, PyObject *args) {
a[2] = box[0]; a[2] = box[0];
a[5] = box[1]; a[5] = box[1];
imOut = ImagingNewDirty(imIn->mode, xsize, ysize); imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){xsize, ysize});
imOut = ImagingTransform( imOut = ImagingTransform(
imOut, imIn, IMAGING_TRANSFORM_AFFINE, 0, 0, xsize, ysize, a, filter, 1); 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 0: /* flip left right */
case 1: /* flip top bottom */ case 1: /* flip top bottom */
case 3: /* rotate 180 */ case 3: /* rotate 180 */
imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize); imOut = ImagingNewDirty(
imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
break; break;
case 2: /* rotate 90 */ case 2: /* rotate 90 */
case 4: /* rotate 270 */ case 4: /* rotate 270 */
case 5: /* transpose */ case 5: /* transpose */
case 6: /* transverse */ case 6: /* transverse */
imOut = ImagingNewDirty(imIn->mode, imIn->ysize, imIn->xsize); imOut = ImagingNewDirty(
imIn->mode, (ImagingNewParams){imIn->ysize, imIn->xsize});
break; break;
default: default:
PyErr_SetString(PyExc_ValueError, "No such transpose operation"); PyErr_SetString(PyExc_ValueError, "No such transpose operation");
@ -2195,7 +2199,7 @@ _unsharp_mask(ImagingObject *self, PyObject *args) {
} }
imIn = self->image; imIn = self->image;
imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize); imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -2220,7 +2224,7 @@ _box_blur(ImagingObject *self, PyObject *args) {
} }
imIn = self->image; imIn = self->image;
imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize); imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -2816,7 +2820,8 @@ _font_getmask(ImagingFontObject *self, PyObject *args) {
return NULL; 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) { if (!im) {
free(text); free(text);
return ImagingError_MemoryError(); return ImagingError_MemoryError();

3
src/libImaging/AlphaComposite.c
View File

@ -36,7 +36,8 @@ ImagingAlphaComposite(Imaging imDst, Imaging imSrc) {
return ImagingError_Mismatch(); return ImagingError_Mismatch();
} }
imOut = ImagingNewDirty(imDst->mode, imDst->xsize, imDst->ysize); imOut =
ImagingNewDirty(imDst->mode, (ImagingNewParams){imDst->xsize, imDst->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }

7
src/libImaging/Bands.c
View File

@ -41,7 +41,7 @@ ImagingGetBand(Imaging imIn, int band) {
band = 3; band = 3;
} }
imOut = ImagingNewDirty("L", imIn->xsize, imIn->ysize); imOut = ImagingNewDirty("L", (ImagingNewParams){imIn->xsize, imIn->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -82,7 +82,7 @@ ImagingSplit(Imaging imIn, Imaging bands[4]) {
} }
for (i = 0; i < imIn->bands; i++) { 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]) { if (!bands[i]) {
for (j = 0; j < i; ++j) { for (j = 0; j < i; ++j) {
ImagingDelete(bands[j]); ImagingDelete(bands[j]);
@ -265,7 +265,8 @@ ImagingMerge(const char *mode, Imaging bands[4]) {
} }
bandsCount = i; bandsCount = i;
imOut = ImagingNewDirty(mode, firstBand->xsize, firstBand->ysize); imOut =
ImagingNewDirty(mode, (ImagingNewParams){firstBand->xsize, firstBand->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }

3
src/libImaging/Blend.c
View File

@ -41,7 +41,8 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha) {
return ImagingCopy(imIn2); return ImagingCopy(imIn2);
} }
imOut = ImagingNewDirty(imIn1->mode, imIn1->xsize, imIn1->ysize); imOut =
ImagingNewDirty(imIn1->mode, (ImagingNewParams){imIn1->xsize, imIn1->ysize});
if (!imOut) { if (!imOut) {
return NULL; 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) { if (yradius != 0) {
imTransposed = ImagingNewDirty(imIn->mode, imIn->ysize, imIn->xsize); imTransposed =
ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->ysize, imIn->xsize});
if (!imTransposed) { if (!imTransposed) {
return NULL; 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; xsize = (im1->xsize < im2->xsize) ? im1->xsize : im2->xsize;
ysize = (im1->ysize < im2->ysize) ? im1->ysize : im2->ysize; ysize = (im1->ysize < im2->ysize) ? im1->ysize : im2->ysize;
return ImagingNewDirty(im1->mode, xsize, ysize); return ImagingNewDirty(im1->mode, (ImagingNewParams){xsize, ysize});
} }
Imaging 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; ysize = 0;
} }
imOut = ImagingNewDirty(imIn->mode, xsize, ysize); imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){xsize, ysize});
if (!imOut) { if (!imOut) {
return NULL; 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); return (Imaging)ImagingError_ValueError(NULL);
} }
im = ImagingNewDirty("L", xsize, ysize); im = ImagingNewDirty("L", (ImagingNewParams){xsize, ysize});
if (!im) { if (!im) {
return NULL; return NULL;
} }
@ -80,7 +80,7 @@ ImagingEffectNoise(int xsize, int ysize, float sigma) {
int nextok; int nextok;
double this, next; double this, next;
imOut = ImagingNewDirty("L", xsize, ysize); imOut = ImagingNewDirty("L", (ImagingNewParams){xsize, ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -120,7 +120,7 @@ ImagingEffectSpread(Imaging imIn, int distance) {
Imaging imOut; Imaging imOut;
int x, y; int x, y;
imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize); imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;

4
src/libImaging/Fill.c
View File

@ -76,7 +76,7 @@ ImagingFillLinearGradient(const char *mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
im = ImagingNewDirty(mode, 256, 256); im = ImagingNewDirty(mode, (ImagingNewParams){256, 256});
if (!im) { if (!im) {
return NULL; return NULL;
} }
@ -111,7 +111,7 @@ ImagingFillRadialGradient(const char *mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
im = ImagingNewDirty(mode, 256, 256); im = ImagingNewDirty(mode, (ImagingNewParams){256, 256});
if (!im) { if (!im) {
return NULL; return NULL;
} }

5
src/libImaging/Filter.c
View File

@ -59,7 +59,8 @@ ImagingExpand(Imaging imIn, int xmargin, int ymargin) {
} }
imOut = ImagingNewDirty( 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) { if (!imOut) {
return NULL; 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"); 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) { if (!imOut) {
return NULL; 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 */ #define IMAGING_MODE_MB "MB" /* multi-band format */
typedef struct {
int xsize;
int ysize;
int depth;
int bands;
} ImagingNewParams;
typedef struct { typedef struct {
char *ptr; char *ptr;
int size; int size;
@ -176,9 +183,9 @@ extern void
ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size); ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size);
extern Imaging extern Imaging
ImagingNew(const char *mode, int xsize, int ysize, int depth, int bands); ImagingNew(const char *mode, ImagingNewParams p);
extern Imaging extern Imaging
ImagingNewDirty(const char *mode, int xsize, int ysize); ImagingNewDirty(const char *mode, ImagingNewParams p);
extern Imaging extern Imaging
ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn); ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn);
extern void extern void
@ -188,10 +195,9 @@ extern Imaging
ImagingNewBlock(const char *mode, int xsize, int ysize); ImagingNewBlock(const char *mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNewPrologue(const char *mode, int xsize, int ysize, int depth, int bands); ImagingNewPrologue(const char *mode, ImagingNewParams p);
extern Imaging extern Imaging
ImagingNewPrologueSubtype( ImagingNewPrologueSubtype(const char *mode, ImagingNewParams p, int structure_size);
const char *mode, int xsize, int ysize, int depth, int bands, int structure_size);
extern void extern void
ImagingCopyPalette(Imaging destination, Imaging source); 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) { if (strcmp(mode, "L") == 0) {
imOut = ImagingNewDirty("L", im->xsize, im->ysize); imOut = ImagingNewDirty("L", (ImagingNewParams){im->xsize, im->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -48,7 +48,7 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[]) {
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (strlen(mode) == 3) { } else if (strlen(mode) == 3) {
imOut = ImagingNewDirty(mode, im->xsize, im->ysize); imOut = ImagingNewDirty(mode, (ImagingNewParams){im->xsize, im->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }

2
src/libImaging/ModeFilter.c
View File

@ -28,7 +28,7 @@ ImagingModeFilter(Imaging im, int size) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize); imOut = ImagingNewDirty(im->mode, (ImagingNewParams){im->xsize, im->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }

2
src/libImaging/Negative.c
View File

@ -27,7 +27,7 @@ ImagingNegative(Imaging im) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize); imOut = ImagingNewDirty(im->mode, (ImagingNewParams){im->xsize, im->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }

2
src/libImaging/Offset.c
View File

@ -25,7 +25,7 @@ ImagingOffset(Imaging im, int xoffset, int yoffset) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
imOut = ImagingNewDirty(im->mode, im->xsize, im->ysize); imOut = ImagingNewDirty(im->mode, (ImagingNewParams){im->xsize, im->ysize});
if (!imOut) { if (!imOut) {
return NULL; 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; goto mode_mismatch;
} }
imOut = ImagingNew(mode, imIn->xsize, imIn->ysize, -1, -1); imOut = ImagingNew(mode, (ImagingNewParams){imIn->xsize, imIn->ysize});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -214,7 +214,7 @@ ImagingPointTransform(Imaging imIn, double scale, double offset) {
return (Imaging)ImagingError_ModeError(); 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) { if (!imOut) {
return NULL; return NULL;
} }

2
src/libImaging/Quant.c
View File

@ -1799,7 +1799,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
if (result > 0) { if (result > 0) {
imOut = ImagingNewDirty("P", im->xsize, im->ysize); imOut = ImagingNewDirty("P", (ImagingNewParams){im->xsize, im->ysize});
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
for (i = y = 0; y < im->ysize; y++) { 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"); return (Imaging)ImagingError_ValueError("bad rank value");
} }
imOut = imOut = ImagingNew(
ImagingNew(im->mode, im->xsize - 2 * margin, im->ysize - 2 * margin, -1, -1); im->mode, (ImagingNewParams){im->xsize - 2 * margin, im->ysize - 2 * margin});
if (!imOut) { if (!imOut) {
return NULL; 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( 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) { if (!imOut) {
return NULL; return NULL;
} }

5
src/libImaging/Resample.c
View File

@ -659,7 +659,8 @@ ImagingResampleInner(
bounds_vert[i * 2] -= ybox_first; 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) { if (imTemp) {
ResampleHorizontal( ResampleHorizontal(
imTemp, imIn, ybox_first, ksize_horiz, bounds_horiz, kk_horiz); imTemp, imIn, ybox_first, ksize_horiz, bounds_horiz, kk_horiz);
@ -680,7 +681,7 @@ ImagingResampleInner(
/* vertical pass */ /* vertical pass */
if (need_vertical) { if (need_vertical) {
imOut = ImagingNewDirty(imIn->mode, imIn->xsize, ysize); imOut = ImagingNewDirty(imIn->mode, (ImagingNewParams){imIn->xsize, ysize});
if (imOut) { if (imOut) {
/* imIn can be the original image or horizontally resampled one */ /* imIn can be the original image or horizontally resampled one */
ResampleVertical(imOut, imIn, 0, ksize_vert, bounds_vert, kk_vert); ResampleVertical(imOut, imIn, 0, ksize_vert, bounds_vert, kk_vert);

90
src/libImaging/Storage.c
View File

@ -42,12 +42,11 @@
*/ */
Imaging Imaging
ImagingNewPrologueSubtype( ImagingNewPrologueSubtype(const char *mode, ImagingNewParams p, int size) {
const char *mode, int xsize, int ysize, int depth, int bands, int size) {
Imaging im; Imaging im;
/* linesize overflow check, roughly the current largest space req'd */ /* 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(); return (Imaging)ImagingError_MemoryError();
} }
@ -57,58 +56,58 @@ ImagingNewPrologueSubtype(
} }
/* Setup image descriptor */ /* Setup image descriptor */
im->xsize = xsize; im->xsize = p.xsize;
im->ysize = ysize; im->ysize = p.ysize;
im->type = IMAGING_TYPE_UINT8; im->type = IMAGING_TYPE_UINT8;
if (strcmp(mode, "1") == 0) { if (strcmp(mode, "1") == 0) {
/* 1-bit images */ /* 1-bit images */
im->bands = im->pixelsize = 1; im->bands = im->pixelsize = 1;
im->linesize = xsize; im->linesize = p.xsize;
} else if (strcmp(mode, "P") == 0) { } else if (strcmp(mode, "P") == 0) {
/* 8-bit palette mapped images */ /* 8-bit palette mapped images */
im->bands = im->pixelsize = 1; im->bands = im->pixelsize = 1;
im->linesize = xsize; im->linesize = p.xsize;
im->palette = ImagingPaletteNew("RGB"); im->palette = ImagingPaletteNew("RGB");
} else if (strcmp(mode, "PA") == 0) { } else if (strcmp(mode, "PA") == 0) {
/* 8-bit palette with alpha */ /* 8-bit palette with alpha */
im->bands = 2; im->bands = 2;
im->pixelsize = 4; /* store in image32 memory */ im->pixelsize = 4; /* store in image32 memory */
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
im->palette = ImagingPaletteNew("RGB"); im->palette = ImagingPaletteNew("RGB");
} else if (strcmp(mode, "L") == 0) { } else if (strcmp(mode, "L") == 0) {
/* 8-bit grayscale (luminance) images */ /* 8-bit grayscale (luminance) images */
im->bands = im->pixelsize = 1; im->bands = im->pixelsize = 1;
im->linesize = xsize; im->linesize = p.xsize;
} else if (strcmp(mode, "LA") == 0) { } else if (strcmp(mode, "LA") == 0) {
/* 8-bit grayscale (luminance) with alpha */ /* 8-bit grayscale (luminance) with alpha */
im->bands = 2; im->bands = 2;
im->pixelsize = 4; /* store in image32 memory */ im->pixelsize = 4; /* store in image32 memory */
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "La") == 0) { } else if (strcmp(mode, "La") == 0) {
/* 8-bit grayscale (luminance) with premultiplied alpha */ /* 8-bit grayscale (luminance) with premultiplied alpha */
im->bands = 2; im->bands = 2;
im->pixelsize = 4; /* store in image32 memory */ im->pixelsize = 4; /* store in image32 memory */
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "F") == 0) { } else if (strcmp(mode, "F") == 0) {
/* 32-bit floating point images */ /* 32-bit floating point images */
im->bands = 1; im->bands = 1;
im->pixelsize = 4; im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
im->type = IMAGING_TYPE_FLOAT32; im->type = IMAGING_TYPE_FLOAT32;
} else if (strcmp(mode, "I") == 0) { } else if (strcmp(mode, "I") == 0) {
/* 32-bit integer images */ /* 32-bit integer images */
im->bands = 1; im->bands = 1;
im->pixelsize = 4; im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
im->type = IMAGING_TYPE_INT32; im->type = IMAGING_TYPE_INT32;
} else if ( } else if (
@ -118,21 +117,21 @@ ImagingNewPrologueSubtype(
/* 16-bit raw integer images */ /* 16-bit raw integer images */
im->bands = 1; im->bands = 1;
im->pixelsize = 2; im->pixelsize = 2;
im->linesize = xsize * 2; im->linesize = p.xsize * 2;
im->type = IMAGING_TYPE_SPECIAL; im->type = IMAGING_TYPE_SPECIAL;
} else if (strcmp(mode, "RGB") == 0) { } else if (strcmp(mode, "RGB") == 0) {
/* 24-bit true colour images */ /* 24-bit true colour images */
im->bands = 3; im->bands = 3;
im->pixelsize = 4; im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "BGR;15") == 0) { } else if (strcmp(mode, "BGR;15") == 0) {
/* EXPERIMENTAL */ /* EXPERIMENTAL */
/* 15-bit reversed true colour */ /* 15-bit reversed true colour */
im->bands = 3; im->bands = 3;
im->pixelsize = 2; im->pixelsize = 2;
im->linesize = (xsize * 2 + 3) & -4; im->linesize = (p.xsize * 2 + 3) & -4;
im->type = IMAGING_TYPE_SPECIAL; im->type = IMAGING_TYPE_SPECIAL;
} else if (strcmp(mode, "BGR;16") == 0) { } else if (strcmp(mode, "BGR;16") == 0) {
@ -140,7 +139,7 @@ ImagingNewPrologueSubtype(
/* 16-bit reversed true colour */ /* 16-bit reversed true colour */
im->bands = 3; im->bands = 3;
im->pixelsize = 2; im->pixelsize = 2;
im->linesize = (xsize * 2 + 3) & -4; im->linesize = (p.xsize * 2 + 3) & -4;
im->type = IMAGING_TYPE_SPECIAL; im->type = IMAGING_TYPE_SPECIAL;
} else if (strcmp(mode, "BGR;24") == 0) { } else if (strcmp(mode, "BGR;24") == 0) {
@ -148,58 +147,58 @@ ImagingNewPrologueSubtype(
/* 24-bit reversed true colour */ /* 24-bit reversed true colour */
im->bands = 3; im->bands = 3;
im->pixelsize = 3; im->pixelsize = 3;
im->linesize = (xsize * 3 + 3) & -4; im->linesize = (p.xsize * 3 + 3) & -4;
im->type = IMAGING_TYPE_SPECIAL; im->type = IMAGING_TYPE_SPECIAL;
} else if (strcmp(mode, "RGBX") == 0) { } else if (strcmp(mode, "RGBX") == 0) {
/* 32-bit true colour images with padding */ /* 32-bit true colour images with padding */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "RGBA") == 0) { } else if (strcmp(mode, "RGBA") == 0) {
/* 32-bit true colour images with alpha */ /* 32-bit true colour images with alpha */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "RGBa") == 0) { } else if (strcmp(mode, "RGBa") == 0) {
/* 32-bit true colour images with premultiplied alpha */ /* 32-bit true colour images with premultiplied alpha */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "CMYK") == 0) { } else if (strcmp(mode, "CMYK") == 0) {
/* 32-bit colour separation */ /* 32-bit colour separation */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "YCbCr") == 0) { } else if (strcmp(mode, "YCbCr") == 0) {
/* 24-bit video format */ /* 24-bit video format */
im->bands = 3; im->bands = 3;
im->pixelsize = 4; im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "LAB") == 0) { } else if (strcmp(mode, "LAB") == 0) {
/* 24-bit color, luminance, + 2 color channels */ /* 24-bit color, luminance, + 2 color channels */
/* L is uint8, a,b are int8 */ /* L is uint8, a,b are int8 */
im->bands = 3; im->bands = 3;
im->pixelsize = 4; im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, "HSV") == 0) { } else if (strcmp(mode, "HSV") == 0) {
/* 24-bit color, luminance, + 2 color channels */ /* 24-bit color, luminance, + 2 color channels */
/* L is uint8, a,b are int8 */ /* L is uint8, a,b are int8 */
im->bands = 3; im->bands = 3;
im->pixelsize = 4; im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = p.xsize * 4;
} else if (strcmp(mode, IMAGING_MODE_MB) == 0) { } else if (strcmp(mode, IMAGING_MODE_MB) == 0) {
if (bands <= 0 || depth <= 0) { if (p.bands <= 0 || p.depth <= 0) {
return (Imaging)ImagingError_ValueError( return (Imaging)ImagingError_ValueError(
"multi-band missing bands and depth"); "multi-band missing bands and depth");
} }
im->bands = bands; im->bands = p.bands;
im->depth = depth; im->depth = p.depth;
im->pixelsize = depth / CHAR_BIT * bands; im->pixelsize = p.depth / CHAR_BIT * p.bands;
im->linesize = xsize * im->pixelsize; im->linesize = p.xsize * im->pixelsize;
im->type = IMAGING_TYPE_MB; im->type = IMAGING_TYPE_MB;
} else { } else {
@ -212,7 +211,7 @@ ImagingNewPrologueSubtype(
/* Pointer array (allocate at least one line, to avoid MemoryError /* Pointer array (allocate at least one line, to avoid MemoryError
exceptions on platforms where calloc(0, x) returns NULL) */ 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) { if (!im->image) {
free(im); free(im);
@ -237,9 +236,8 @@ ImagingNewPrologueSubtype(
} }
Imaging Imaging
ImagingNewPrologue(const char *mode, int xsize, int ysize, int depth, int bands) { ImagingNewPrologue(const char *mode, ImagingNewParams p) {
return ImagingNewPrologueSubtype( return ImagingNewPrologueSubtype(mode, p, sizeof(struct ImagingMemoryInstance));
mode, xsize, ysize, depth, bands, sizeof(struct ImagingMemoryInstance));
} }
void void
@ -498,15 +496,14 @@ ImagingAllocateBlock(Imaging im) {
*/ */
static Imaging static Imaging
ImagingNewInternal( ImagingNewInternal(const char *mode, ImagingNewParams p, int dirty) {
const char *mode, int xsize, int ysize, int depth, int bands, int dirty) {
Imaging im; Imaging im;
if (xsize < 0 || ysize < 0) { if (p.xsize < 0 || p.ysize < 0) {
return (Imaging)ImagingError_ValueError("bad image size"); return (Imaging)ImagingError_ValueError("bad image size");
} }
im = ImagingNewPrologue(mode, xsize, ysize, depth, bands); im = ImagingNewPrologue(mode, p);
if (!im) { if (!im) {
return NULL; return NULL;
} }
@ -527,13 +524,13 @@ ImagingNewInternal(
} }
Imaging Imaging
ImagingNew(const char *mode, int xsize, int ysize, int depth, int bands) { ImagingNew(const char *mode, ImagingNewParams p) {
return ImagingNewInternal(mode, xsize, ysize, depth, bands, 0); return ImagingNewInternal(mode, p, 0);
} }
Imaging Imaging
ImagingNewDirty(const char *mode, int xsize, int ysize) { ImagingNewDirty(const char *mode, ImagingNewParams p) {
return ImagingNewInternal(mode, xsize, ysize, -1, -1, 1); return ImagingNewInternal(mode, p, 1);
} }
Imaging Imaging
@ -544,7 +541,7 @@ ImagingNewBlock(const char *mode, int xsize, int ysize) {
return (Imaging)ImagingError_ValueError("bad image size"); return (Imaging)ImagingError_ValueError("bad image size");
} }
im = ImagingNewPrologue(mode, xsize, ysize, -1, -1); im = ImagingNewPrologue(mode, (ImagingNewParams){xsize, ysize});
if (!im) { if (!im) {
return NULL; return NULL;
} }
@ -564,12 +561,15 @@ ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn) {
if (imOut) { if (imOut) {
/* make sure images match */ /* make sure images match */
if (strcmp(imOut->mode, mode) != 0 || imOut->xsize != imIn->xsize || 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(); return ImagingError_Mismatch();
} }
} else { } else {
/* create new image */ /* create new image */
imOut = ImagingNewDirty(mode, imIn->xsize, imIn->ysize); imOut = ImagingNewDirty(
mode,
(ImagingNewParams){imIn->xsize, imIn->ysize, imIn->depth, imIn->bands});
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }

4
src/map.c
View File

@ -125,7 +125,9 @@ PyImaging_MapBuffer(PyObject *self, PyObject *args) {
} }
im = ImagingNewPrologueSubtype( im = ImagingNewPrologueSubtype(
mode, xsize, ysize, depth, bands, sizeof(ImagingBufferInstance)); mode,
(ImagingNewParams){xsize, ysize, depth, bands},
sizeof(ImagingBufferInstance));
if (!im) { if (!im) {
PyBuffer_Release(&view); PyBuffer_Release(&view);
return NULL; return NULL;