surface.convert now works in threads

Author: oddbookworm

examples/multithreaded_surface.py

@@ -1,10 +1,11 @@
 import pygame
 import threading
 import random
+import sys
 
 from time import perf_counter
 
-start = perf_counter()
+print(f"GIL Enabled: {sys._is_gil_enabled()}")
 
 pygame.init()
 
@@ -13,7 +14,7 @@
 surface = pygame.Surface((WIDTH, HEIGHT))
 surface.fill("black")
 
-LERP_OFFSET = 0.001
+LERP_OFFSET = 0.01
 
 
 def get_random_color() -> pygame.Color:
@@ -24,8 +25,15 @@ def get_random_color() -> pygame.Color:
     return pygame.Color(r, g, b, a)
 
 
+def get_random_format() -> int:
+    return random.choice([8, 12, 15, 16, 24, 32])
+
+
 def multithreaded_func(
-    surf: pygame.Surface, target_pixel: tuple[int, int], target_color: pygame.Color
+    surf: pygame.Surface,
+    target_pixel: tuple[int, int],
+    target_color: pygame.Color,
+    depth: int,
 ) -> None:
     lerp_distance = 0
 
@@ -35,34 +43,36 @@ def multithreaded_func(
         lerp_distance += LERP_OFFSET
         new_color = original_color.lerp(target_color, lerp_distance)
         surf.set_at(target_pixel, new_color)
+        surf.convert(depth)
 
 
 pixels = [(col, row) for col in range(WIDTH) for row in range(HEIGHT)]
 
 colors = [get_random_color() for _ in range(WIDTH * HEIGHT)]
 
-args = [(pixel, colors[i]) for i, pixel in enumerate(pixels)]
+depths = [get_random_format() for _ in range(WIDTH * HEIGHT)]
+
+args = [(pixel, colors[i], depths[i]) for i, pixel in enumerate(pixels)]
 batches = {
     i: args[i * NUM_THREADS : (i + 1) * NUM_THREADS]
     for i in range(WIDTH * HEIGHT // NUM_THREADS)
 }
 
+start = perf_counter()
 for batch in batches.values():
     threads: list[threading.Thread] = []
-    for pixel, color in batch:
-        new_thread = threading.Thread(
-            target=multithreaded_func, args=(surface, pixel, color)
-        )
+    for arg in batch:
+        new_thread = threading.Thread(target=multithreaded_func, args=(surface, *arg))
         new_thread.start()
         threads.append(new_thread)
 
     while any([t.is_alive() for t in threads]):
         continue
 
-pygame.image.save(pygame.transform.scale_by(surface, 10), "out.png")
-
 end = perf_counter()
 
+pygame.image.save(pygame.transform.scale_by(surface, 10), "out.png")
+
 print(f"time taken: {end - start}")
 
 for pixel, color in zip(pixels, colors):

src_c/_pygame.h

@@ -179,6 +179,7 @@ PG_GetSurfaceFormat(SDL_Surface *surf)
 #define PG_CreateSurfaceFrom(width, height, format, pixels, pitch) \
     SDL_CreateRGBSurfaceWithFormatFrom(pixels, width, height, 0, pitch, format)
 #define PG_ConvertSurface(src, fmt) SDL_ConvertSurface(src, fmt, 0)
+
 #define PG_ConvertSurfaceFormat(src, pixel_format) \
     SDL_ConvertSurfaceFormat(src, pixel_format, 0)
 

src_c/include/_pygame.h

@@ -322,20 +322,55 @@ typedef struct {
     PyObject *dependency;
 #if PY_VERSION_HEX >= 0x030D0000 && Py_GIL_DISABLED
     PyMutex mutex;
+    unsigned int num_locks;
+    uint64_t locking_thread_id;
 #endif
 } pgSurfaceObject;
 #define pgSurface_AsSurface(x) (((pgSurfaceObject *)x)->surf)
 
 #if PY_VERSION_HEX >= 0x030D0000 && Py_GIL_DISABLED
-#define LOCK_pgSurfaceObject(pgSurfacePtr) \
-    PyMutex_Lock(&(((pgSurfaceObject *)pgSurfacePtr)->mutex));
+#define LOCK_pgSurfaceObject(pgSurfacePtr)                          \
+    {                                                               \
+        pgSurfaceObject *surfObj = (pgSurfaceObject *)pgSurfacePtr; \
+        uint64_t thread_id = PyThreadState_Get()->id;               \
+        if (surfObj->num_locks) {                                   \
+            if (thread_id == surfObj->locking_thread_id) {          \
+                ++(surfObj->num_locks);                             \
+            }                                                       \
+            else {                                                  \
+                PyMutex_Lock(&surfObj->mutex);                      \
+                surfObj->num_locks = 1U;                            \
+                surfObj->locking_thread_id = thread_id;             \
+            }                                                       \
+        }                                                           \
+        else {                                                      \
+            PyMutex_Lock(&surfObj->mutex);                          \
+            surfObj->num_locks = 1U;                                \
+            surfObj->locking_thread_id = thread_id;                 \
+        }                                                           \
+    }
 #else
 #define LOCK_pgSurfaceObject(pgSurfacePtr)
 #endif
 
 #if PY_VERSION_HEX >= 0x030D0000 && Py_GIL_DISABLED
-#define UNLOCK_pgSurfaceObject(pgSurfacePtr) \
-    PyMutex_Unlock(&(((pgSurfaceObject *)pgSurfacePtr)->mutex));
+#define UNLOCK_pgSurfaceObject(pgSurfacePtr)                        \
+    {                                                               \
+        pgSurfaceObject *surfObj = (pgSurfaceObject *)pgSurfacePtr; \
+        uint64_t thread_id = PyThreadState_Get()->id;               \
+        if (surfObj->num_locks) {                                   \
+            if (thread_id == surfObj->locking_thread_id) {          \
+                if (surfObj->num_locks > 1U) {                      \
+                    --(surfObj->num_locks);                         \
+                }                                                   \
+                else {                                              \
+                    surfObj->locking_thread_id = 0U;                \
+                    surfObj->num_locks = 0U;                        \
+                    PyMutex_Unlock(&surfObj->mutex);                \
+                }                                                   \
+            }                                                       \
+        }                                                           \
+    }
 #else
 #define UNLOCK_pgSurfaceObject(pgSurfacePtr)
 #endif

src_c/surface.c

@@ -1471,7 +1471,7 @@ surf_convert(pgSurfaceObject *self, PyObject *args)
 
     SURF_INIT_CHECK(surf)
 
-    pgSurface_Prep(self);
+    pgSurface_Lock(self);
 
     if ((has_colorkey = SDL_HasColorKey(surf))) {
         SDL_GetColorKey(surf, &colorkey);
@@ -1513,6 +1513,7 @@ surf_convert(pgSurfaceObject *self, PyObject *args)
                             Amask = 0xFF << 24;
                             break;
                         default:
+                            pgSurface_Unlock(self);
                             return RAISE(PyExc_ValueError,
                                          "no standard masks exist for given "
                                          "bitdepth with alpha");
@@ -1548,6 +1549,7 @@ surf_convert(pgSurfaceObject *self, PyObject *args)
                             Bmask = 0xFF;
                             break;
                         default:
+                            pgSurface_Unlock(self);
                             return RAISE(PyExc_ValueError,
                                          "nonstandard bit depth given");
                     }
@@ -1565,7 +1567,7 @@ surf_convert(pgSurfaceObject *self, PyObject *args)
                     !pg_UintFromObjIndex(argobject, 1, &format.Gmask) ||
                     !pg_UintFromObjIndex(argobject, 2, &format.Bmask) ||
                     !pg_UintFromObjIndex(argobject, 3, &format.Amask)) {
-                    pgSurface_Unprep(self);
+                    pgSurface_Unlock(self);
                     return RAISE(PyExc_ValueError,
                                  "invalid color masks given");
                 }
@@ -1576,7 +1578,7 @@ surf_convert(pgSurfaceObject *self, PyObject *args)
                         break;
             }
             else {
-                pgSurface_Unprep(self);
+                pgSurface_Unlock(self);
                 return RAISE(
                     PyExc_ValueError,
                     "invalid argument specifying new format to convert to");
@@ -1611,7 +1613,9 @@ surf_convert(pgSurfaceObject *self, PyObject *args)
                     SDL_SetPixelFormatPalette(&format, palette);
                 }
             }
+            // pgSurface_Lock(self);
             newsurf = PG_ConvertSurface(surf, &format);
+            // pgSurface_Unlock(self);
             SDL_SetSurfaceBlendMode(newsurf, SDL_BLENDMODE_NONE);
             SDL_FreePalette(palette);
         }
@@ -1623,19 +1627,21 @@ surf_convert(pgSurfaceObject *self, PyObject *args)
     }
 
     if (newsurf == NULL) {
+        pgSurface_Unlock(self);
         return RAISE(pgExc_SDLError, SDL_GetError());
     }
 
     if (has_colorkey) {
         colorkey = SDL_MapRGBA(newsurf->format, key_r, key_g, key_b, key_a);
         if (SDL_SetColorKey(newsurf, SDL_TRUE, colorkey) != 0) {
             PyErr_SetString(pgExc_SDLError, SDL_GetError());
+            pgSurface_Unlock(self);
             SDL_FreeSurface(newsurf);
             return NULL;
         }
     }
 
-    pgSurface_Unprep(self);
+    pgSurface_Unlock(self);
 
     final = surf_subtype_new(Py_TYPE(self), newsurf, 1);
     if (!final)