Merge pull request #8216 from hugovk/free-threading

hugovk · web-flow · commit 6944e9e1831c · 2024-07-13T16:09:34.000+02:00
diff --git a/src/_imaging.c b/src/_imaging.c
@@ -2251,6 +2251,11 @@ _getcolors(ImagingObject *self, PyObject *args) {
             ImagingColorItem *v = &items[i];
             PyObject *item = Py_BuildValue(
                 "iN", v->count, getpixel(self->image, self->access, v->x, v->y));
+            if (item == NULL) {
+                Py_DECREF(out);
+                free(items);
+                return NULL;
+            }
             PyList_SetItem(out, i, item);
         }
     }
@@ -4448,5 +4453,9 @@ PyInit__imaging(void) {
         return NULL;
     }
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }
diff --git a/src/_imagingcms.c b/src/_imagingcms.c
@@ -1538,5 +1538,9 @@ PyInit__imagingcms(void) {
 
     PyDateTime_IMPORT;
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }
diff --git a/src/_imagingft.c b/src/_imagingft.c
@@ -20,6 +20,7 @@
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
+#include "thirdparty/pythoncapi_compat.h"
 #include "libImaging/Imaging.h"
 
 #include <ft2build.h>
@@ -1209,30 +1210,49 @@ font_getvarnames(FontObject *self) {
         return NULL;
     }
 
+    int *list_names_filled = PyMem_Malloc(num_namedstyles * sizeof(int));
+    if (list_names_filled == NULL) {
+        Py_DECREF(list_names);
+        FT_Done_MM_Var(library, master);
+        return PyErr_NoMemory();
+    }
+
+    for (int i = 0; i < num_namedstyles; i++) {
+        list_names_filled[i] = 0;
+    }
+
     name_count = FT_Get_Sfnt_Name_Count(self->face);
     for (i = 0; i < name_count; i++) {
         error = FT_Get_Sfnt_Name(self->face, i, &name);
         if (error) {
+            PyMem_Free(list_names_filled);
             Py_DECREF(list_names);
             FT_Done_MM_Var(library, master);
             return geterror(error);
         }
 
         for (j = 0; j < num_namedstyles; j++) {
-            if (PyList_GetItem(list_names, j) != NULL) {
+            if (list_names_filled[j]) {
                 continue;
             }
 
             if (master->namedstyle[j].strid == name.name_id) {
                 list_name = Py_BuildValue("y#", name.string, name.string_len);
+                if (list_name == NULL) {
+                    PyMem_Free(list_names_filled);
+                    Py_DECREF(list_names);
+                    FT_Done_MM_Var(library, master);
+                    return NULL;
+                }
                 PyList_SetItem(list_names, j, list_name);
+                list_names_filled[j] = 1;
                 break;
             }
         }
     }
 
+    PyMem_Free(list_names_filled);
     FT_Done_MM_Var(library, master);
-
     return list_names;
 }
 
@@ -1289,9 +1309,15 @@ font_getvaraxes(FontObject *self) {
 
             if (name.name_id == axis.strid) {
                 axis_name = Py_BuildValue("y#", name.string, name.string_len);
+                if (axis_name == NULL) {
+                    Py_DECREF(list_axis);
+                    Py_DECREF(list_axes);
+                    FT_Done_MM_Var(library, master);
+                    return NULL;
+                }
                 PyDict_SetItemString(
                     list_axis, "name", axis_name ? axis_name : Py_None);
-                Py_XDECREF(axis_name);
+                Py_DECREF(axis_name);
                 break;
             }
         }
@@ -1345,18 +1371,25 @@ font_setvaraxes(FontObject *self, PyObject *args) {
         return PyErr_NoMemory();
     }
     for (i = 0; i < num_coords; i++) {
-        item = PyList_GET_ITEM(axes, i);
+        item = PyList_GetItemRef(axes, i);
+        if (item == NULL) {
+            free(coords);
+            return NULL;
+        }
+
         if (PyFloat_Check(item)) {
             coord = PyFloat_AS_DOUBLE(item);
         } else if (PyLong_Check(item)) {
             coord = (float)PyLong_AS_LONG(item);
         } else if (PyNumber_Check(item)) {
             coord = PyFloat_AsDouble(item);
         } else {
+            Py_DECREF(item);
             free(coords);
             PyErr_SetString(PyExc_TypeError, "list must contain numbers");
             return NULL;
         }
+        Py_DECREF(item);
         coords[i] = coord * 65536;
     }
 
@@ -1576,5 +1609,9 @@ PyInit__imagingft(void) {
         return NULL;
     }
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }
diff --git a/src/_imagingmath.c b/src/_imagingmath.c
@@ -290,5 +290,9 @@ PyInit__imagingmath(void) {
         return NULL;
     }
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }
diff --git a/src/_imagingmorph.c b/src/_imagingmorph.c
@@ -269,5 +269,9 @@ PyInit__imagingmorph(void) {
 
     m = PyModule_Create(&module_def);
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }
diff --git a/src/_imagingtk.c b/src/_imagingtk.c
@@ -62,5 +62,10 @@ PyInit__imagingtk(void) {
         Py_DECREF(m);
         return NULL;
     }
+
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }
diff --git a/src/_webp.c b/src/_webp.c
@@ -1005,5 +1005,9 @@ PyInit__webp(void) {
         return NULL;
     }
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }
diff --git a/src/encode.c b/src/encode.c
@@ -25,6 +25,7 @@
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
 
+#include "thirdparty/pythoncapi_compat.h"
 #include "libImaging/Imaging.h"
 #include "libImaging/Gif.h"
 
@@ -671,11 +672,17 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
         tags_size = PyList_Size(tags);
         TRACE(("tags size: %d\n", (int)tags_size));
         for (pos = 0; pos < tags_size; pos++) {
-            item = PyList_GetItem(tags, pos);
+            item = PyList_GetItemRef(tags, pos);
+            if (item == NULL) {
+                return NULL;
+            }
+
             if (!PyTuple_Check(item) || PyTuple_Size(item) != 2) {
+                Py_DECREF(item);
                 PyErr_SetString(PyExc_ValueError, "Invalid tags list");
                 return NULL;
             }
+            Py_DECREF(item);
         }
         pos = 0;
     }
@@ -703,11 +710,17 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
 
     num_core_tags = sizeof(core_tags) / sizeof(int);
     for (pos = 0; pos < tags_size; pos++) {
-        item = PyList_GetItem(tags, pos);
+        item = PyList_GetItemRef(tags, pos);
+        if (item == NULL) {
+            return NULL;
+        }
+
         // We already checked that tags is a 2-tuple list.
-        key = PyTuple_GetItem(item, 0);
+        key = PyTuple_GET_ITEM(item, 0);
         key_int = (int)PyLong_AsLong(key);
-        value = PyTuple_GetItem(item, 1);
+        value = PyTuple_GET_ITEM(item, 1);
+        Py_DECREF(item);
+
         status = 0;
         is_core_tag = 0;
         is_var_length = 0;
@@ -721,7 +734,10 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
         }
 
         if (!is_core_tag) {
-            PyObject *tag_type = PyDict_GetItem(types, key);
+            PyObject *tag_type;
+            if (PyDict_GetItemRef(types, key, &tag_type) < 0) {
+                return NULL;  // Exception has been already set
+            }
             if (tag_type) {
                 int type_int = PyLong_AsLong(tag_type);
                 if (type_int >= TIFF_BYTE && type_int <= TIFF_DOUBLE) {
diff --git a/src/path.c b/src/path.c
@@ -26,6 +26,7 @@
  */
 
 #include "Python.h"
+#include "thirdparty/pythoncapi_compat.h"
 #include "libImaging/Imaging.h"
 
 #include <math.h>
@@ -179,14 +180,21 @@ PyPath_Flatten(PyObject *data, double **pxy) {
         }                                                               \
         free(xy);                                                       \
         return -1;                                                      \
+    }                                                                   \
+    if (decref) {                                                       \
+        Py_DECREF(op);                                                  \
     }
 
     /* Copy table to path array */
     if (PyList_Check(data)) {
         for (i = 0; i < n; i++) {
             double x, y;
-            PyObject *op = PyList_GET_ITEM(data, i);
-            assign_item_to_array(op, 0);
+            PyObject *op = PyList_GetItemRef(data, i);
+            if (op == NULL) {
+                free(xy);
+                return -1;
+            }
+            assign_item_to_array(op, 1);
         }
     } else if (PyTuple_Check(data)) {
         for (i = 0; i < n; i++) {
@@ -209,7 +217,6 @@ PyPath_Flatten(PyObject *data, double **pxy) {
                 }
             }
             assign_item_to_array(op, 1);
-            Py_DECREF(op);
         }
     }
 
diff --git a/src/thirdparty/pythoncapi_compat.h b/src/thirdparty/pythoncapi_compat.h

Original file line number	Diff line number	Diff line change
`@@ -2251,6 +2251,11 @@ _getcolors(ImagingObject self, PyObject args) {`
`2251`	`2251`	`ImagingColorItem *v = &items[i];`
`2252`	`2252`	`PyObject *item = Py_BuildValue(`
`2253`	`2253`	`"iN", v->count, getpixel(self->image, self->access, v->x, v->y));`
	`2254`	`+ if (item == NULL) {`
	`2255`	`+ Py_DECREF(out);`
	`2256`	`+ free(items);`
	`2257`	`+ return NULL;`
	`2258`	`+ }`
`2254`	`2259`	`PyList_SetItem(out, i, item);`
`2255`	`2260`	`}`
`2256`	`2261`	`}`
`@@ -4448,5 +4453,9 @@ PyInit__imaging(void) {`
`4448`	`4453`	`return NULL;`
`4449`	`4454`	`}`
`4450`	`4455`
	`4456`	`+#ifdef Py_GIL_DISABLED`
	`4457`	`+ PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);`
	`4458`	`+#endif`
	`4459`	`+`
`4451`	`4460`	`return m;`
`4452`	`4461`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1538,5 +1538,9 @@ PyInit__imagingcms(void) {`
`1538`	`1538`
`1539`	`1539`	`PyDateTime_IMPORT;`
`1540`	`1540`
	`1541`	`+#ifdef Py_GIL_DISABLED`
	`1542`	`+ PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);`
	`1543`	`+#endif`
	`1544`	`+`
`1541`	`1545`	`return m;`
`1542`	`1546`	`}`
Original file line number	Diff line number	Diff line change
`@@ -290,5 +290,9 @@ PyInit__imagingmath(void) {`
`290`	`290`	`return NULL;`
`291`	`291`	`}`
`292`	`292`
	`293`	`+#ifdef Py_GIL_DISABLED`
	`294`	`+ PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);`
	`295`	`+#endif`
	`296`	`+`
`293`	`297`	`return m;`
`294`	`298`	`}`
Original file line number	Diff line number	Diff line change
`@@ -269,5 +269,9 @@ PyInit__imagingmorph(void) {`
`269`	`269`
`270`	`270`	`m = PyModule_Create(&module_def);`
`271`	`271`
	`272`	`+#ifdef Py_GIL_DISABLED`
	`273`	`+ PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);`
	`274`	`+#endif`
	`275`	`+`
`272`	`276`	`return m;`
`273`	`277`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,5 +62,10 @@ PyInit__imagingtk(void) {`
`62`	`62`	`Py_DECREF(m);`
`63`	`63`	`return NULL;`
`64`	`64`	`}`
	`65`	`+`
	`66`	`+#ifdef Py_GIL_DISABLED`
	`67`	`+ PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);`
	`68`	`+#endif`
	`69`	`+`
`65`	`70`	`return m;`
`66`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1005,5 +1005,9 @@ PyInit__webp(void) {`
`1005`	`1005`	`return NULL;`
`1006`	`1006`	`}`
`1007`	`1007`
	`1008`	`+#ifdef Py_GIL_DISABLED`
	`1009`	`+ PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);`
	`1010`	`+#endif`
	`1011`	`+`
`1008`	`1012`	`return m;`
`1009`	`1013`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@`
`26`	`26`	`*/`
`27`	`27`
`28`	`28`	`#include "Python.h"`
	`29`	`+#include "thirdparty/pythoncapi_compat.h"`
`29`	`30`	`#include "libImaging/Imaging.h"`
`30`	`31`
`31`	`32`	`#include <math.h>`
`@@ -179,14 +180,21 @@ PyPath_Flatten(PyObject data, double *pxy) {`
`179`	`180`	`} \`
`180`	`181`	`free(xy); \`
`181`	`182`	`return -1; \`
	`183`	`+ } \`
	`184`	`+ if (decref) { \`
	`185`	`+ Py_DECREF(op); \`
`182`	`186`	`}`
`183`	`187`
`184`	`188`	`/* Copy table to path array */`
`185`	`189`	`if (PyList_Check(data)) {`
`186`	`190`	`for (i = 0; i < n; i++) {`
`187`	`191`	`double x, y;`
`188`		`- PyObject *op = PyList_GET_ITEM(data, i);`
`189`		`- assign_item_to_array(op, 0);`
	`192`	`+ PyObject *op = PyList_GetItemRef(data, i);`
	`193`	`+ if (op == NULL) {`
	`194`	`+ free(xy);`
	`195`	`+ return -1;`
	`196`	`+ }`
	`197`	`+ assign_item_to_array(op, 1);`
`190`	`198`	`}`
`191`	`199`	`} else if (PyTuple_Check(data)) {`
`192`	`200`	`for (i = 0; i < n; i++) {`
`@@ -209,7 +217,6 @@ PyPath_Flatten(PyObject data, double *pxy) {`
`209`	`217`	`}`
`210`	`218`	`}`
`211`	`219`	`assign_item_to_array(op, 1);`
`212`		`- Py_DECREF(op);`
`213`	`220`	`}`
`214`	`221`	`}`
`215`	`222`