Removed memset and ignoreAlpha (#20)

python-pillow · hugovk · Apr 1, 2025 · Jan 3, 2021 · Oct 16, 2024 · Oct 16, 2024
commit e1509ee88b1cc1bc126b3e2530db8cabdaf956f3
diff --git a/src/PIL/AvifImagePlugin.py b/src/PIL/AvifImagePlugin.py
@@ -16,6 +16,7 @@
 # Decoder options as module globals, until there is a way to pass parameters
 # to Image.open (see https://github.com/python-pillow/Pillow/issues/569)
 DECODE_CODEC_CHOICE = "auto"
+# Decoding is only affected by this for libavif **0.8.4** or greater.
 DEFAULT_MAX_THREADS = 0
 
 
@@ -47,9 +48,9 @@

 def _get_default_max_threads() -> int:
    if DEFAULT_MAX_THREADS:
        return DEFAULT_MAX_THREADS
    if hasattr(os, "sched_getaffinity"):
        return len(os.sched_getaffinity(0))
    else:
        return os.cpu_count() or 1

@@ -61,10 +62,7 @@
 
     def _open(self) -> None:
         if not SUPPORTED:
-            msg = (
-                "image file could not be identified because AVIF "
-                "support not installed"
-            )
+            msg = "image file could not be opened because AVIF support not installed"
             raise SyntaxError(msg)
 
         if DECODE_CODEC_CHOICE != "auto" and not _avif.decoder_codec_available(
@@ -116,11 +114,11 @@
     def load(self) -> Image.core.PixelAccess | None:
         if self.tile:
             # We need to load the image data for this frame
-            data, timescale, tsp_in_ts, dur_in_ts = self._decoder.get_frame(
-                self.__frame
+            data, timescale, pts_in_timescales, dur_in_timescales = (
+                self._decoder.get_frame(self.__frame)
             )
-            self.info["timestamp"] = round(1000 * (tsp_in_ts / timescale))
-            self.info["duration"] = round(1000 * (dur_in_ts / timescale))
+            self.info["timestamp"] = round(1000 * (pts_in_timescales / timescale))
+            self.info["duration"] = round(1000 * (dur_in_timescales / timescale))
 
             # Set tile
             if self.fp and self._exclusive_fp:
@@ -212,8 +210,7 @@
 
     # Setup the AVIF encoder
     enc = _avif.AvifEncoder(
-        im.size[0],
-        im.size[1],
+        im.size,
         subsampling,
         quality,
         speed,
@@ -233,7 +230,7 @@
 
     # Add each frame
     frame_idx = 0
-    frame_dur = 0
+    frame_duration = 0
     cur_idx = im.tell()
     try:
         for ims in [im] + append_images:
@@ -252,16 +249,15 @@
 
                 # Update frame duration
                 if isinstance(duration, (list, tuple)):
-                    frame_dur = duration[frame_idx]
+                    frame_duration = duration[frame_idx]
                 else:
-                    frame_dur = duration
+                    frame_duration = duration
 
                 # Append the frame to the animation encoder
                 enc.add(
                     frame.tobytes("raw", rawmode),
-                    frame_dur,
-                    frame.size[0],
-                    frame.size[1],
+                    frame_duration,
+                    frame.size,
                     rawmode,
                     is_single_frame,
                 )

diff --git a/src/_avif.c b/src/_avif.c
@@ -7,7 +7,7 @@
 typedef struct {
     PyObject_HEAD avifEncoder *encoder;
     avifImage *image;
-    int frame_index;
+    int first_frame;
 } AvifEncoderObject;
 
 static PyTypeObject AvifEncoder_Type;
@@ -16,7 +16,6 @@
 typedef struct {
     PyObject_HEAD avifDecoder *decoder;
     Py_buffer buffer;
-    char *mode;
 } AvifDecoderObject;
 
 static PyTypeObject AvifDecoder_Type;
@@ -37,9 +36,9 @@
 static int
 normalize_tiles_log2(int value) {
    if (value < 0) {
        return 0;
    } else if (value > 6) {
        return 6;
    } else {
        return value;
    }
@@ -56,8 +55,8 @@
        case AVIF_RESULT_TRUNCATED_DATA:
        case AVIF_RESULT_NO_CONTENT:
            return PyExc_SyntaxError;
        default:
            return PyExc_RuntimeError;
    }
 }

@@ -78,15 +77,15 @@
                return axis ? 7   // 90 degrees anti-clockwise then swap left and right.
                            : 5;  // 90 degrees anti-clockwise then swap top and bottom.
            }
            return 6;  // 90 degrees anti-clockwise.
        }
        if (angle == 2) {
            if (imir) {
                return axis
                           ? 4   // 180 degrees anti-clockwise then swap left and right.
                           : 2;  // 180 degrees anti-clockwise then swap top and bottom.
            }
            return 3;  // 180 degrees anti-clockwise.
        }
        if (angle == 3) {
            if (imir) {
@@ -94,7 +93,7 @@
                           ? 5   // 270 degrees anti-clockwise then swap left and right.
                           : 7;  // 270 degrees anti-clockwise then swap top and bottom.
            }
            return 8;  // 270 degrees anti-clockwise.
        }
    }
    if (imir) {
@@ -119,11 +118,11 @@
            image->imir.mode = 1;
 #endif
            break;
        case 3:  // The 0th row is at the visual bottom of the image, and the 0th column
                 // is the visual right-hand side.
            image->transformFlags |= AVIF_TRANSFORM_IROT;
            image->irot.angle = 2;
            break;
        case 4:  // The 0th row is at the visual bottom of the image, and the 0th column
                 // is the visual left-hand side.
            image->transformFlags |= AVIF_TRANSFORM_IMIR;
@@ -134,27 +133,27 @@
            image->irot.angle = 1;  // applied before imir according to MIAF spec
                                    // ISO/IEC 28002-12:2021 - section 7.3.6.7
            break;
        case 6:  // The 0th row is the visual right-hand side of the image, and the 0th
                 // column is the visual top.
            image->transformFlags |= AVIF_TRANSFORM_IROT;
            image->irot.angle = 3;
            break;
        case 7:  // The 0th row is the visual right-hand side of the image, and the 0th
                 // column is the visual bottom.
            image->transformFlags |= AVIF_TRANSFORM_IROT | AVIF_TRANSFORM_IMIR;
            image->irot.angle = 3;  // applied before imir according to MIAF spec
                                    // ISO/IEC 28002-12:2021 - section 7.3.6.7
            break;
        case 8:  // The 0th row is the visual left-hand side of the image, and the 0th
                 // column is the visual bottom.
            image->transformFlags |= AVIF_TRANSFORM_IROT;
            image->irot.angle = 1;
            break;
    }
 }
 
 static int
-_codec_available(const char *name, uint32_t flags) {
+_codec_available(const char *name, avifCodecFlags flags) {
     avifCodecChoice codec = avifCodecChoiceFromName(name);
     if (codec == AVIF_CODEC_CHOICE_AUTO) {
         return 0;
@@ -188,38 +187,38 @@
    Py_ssize_t i, size;
    PyObject *keyval, *py_key, *py_val;
    if (!PyTuple_Check(opts)) {
        PyErr_SetString(PyExc_ValueError, "Invalid advanced codec options");
        return 1;
    }
    size = PyTuple_GET_SIZE(opts);

    for (i = 0; i < size; i++) {
        keyval = PyTuple_GetItem(opts, i);
        if (!PyTuple_Check(keyval) || PyTuple_GET_SIZE(keyval) != 2) {
            PyErr_SetString(PyExc_ValueError, "Invalid advanced codec options");
            return 1;
        }
        py_key = PyTuple_GetItem(keyval, 0);
        py_val = PyTuple_GetItem(keyval, 1);
        if (!PyUnicode_Check(py_key) || !PyUnicode_Check(py_val)) {
            PyErr_SetString(PyExc_ValueError, "Invalid advanced codec options");
            return 1;
        }
        const char *key = PyUnicode_AsUTF8(py_key);
        const char *val = PyUnicode_AsUTF8(py_val);
        if (key == NULL || val == NULL) {
            PyErr_SetString(PyExc_ValueError, "Invalid advanced codec options");
            return 1;
        }

        avifResult result = avifEncoderSetCodecSpecificOption(encoder, key, val);
        if (result != AVIF_RESULT_OK) {
            PyErr_Format(
                exc_type_for_avif_result(result),
                "Setting advanced codec options failed: %s",
                avifResultToString(result)
            );
            return 1;
        }
    }
    return 0;
@@ -252,7 +251,7 @@
 
     if (!PyArg_ParseTuple(
             args,
-            "IIsiiissiiOOy*y*iy*O",
+            "(II)siiissiiOOy*y*iy*O",
             &width,
             &height,
             &subsampling,
@@ -303,9 +302,9 @@

    // Validate canvas dimensions
    if (width <= 0 || height <= 0) {
        PyErr_SetString(PyExc_ValueError, "invalid canvas dimensions");
        avifImageDestroy(image);
        return NULL;
    }
    image->width = width;
    image->height = height;
@@ -351,9 +350,9 @@
    if (advanced != Py_None) {
 #if AVIF_VERSION >= 80200
        if (_add_codec_specific_options(encoder, advanced)) {
            avifImageDestroy(image);
            avifEncoderDestroy(encoder);
            return NULL;
        }
 #else
        PyErr_SetString(
@@ -367,29 +366,29 @@

    self = PyObject_New(AvifEncoderObject, &AvifEncoder_Type);
    if (!self) {
        PyErr_SetString(PyExc_RuntimeError, "could not create encoder object");
        avifImageDestroy(image);
         avifEncoderDestroy(encoder);
         return NULL;
     }
-    self->frame_index = -1;
+    self->first_frame = 1;
 
     avifResult result;
     if (icc_buffer.len) {
        result = avifImageSetProfileICC(image, icc_buffer.buf, icc_buffer.len);
        if (result != AVIF_RESULT_OK) {
            PyErr_Format(
                exc_type_for_avif_result(result),
                "Setting ICC profile failed: %s",
                avifResultToString(result)
            );
            avifImageDestroy(image);
            avifEncoderDestroy(encoder);
            PyBuffer_Release(&icc_buffer);
            PyBuffer_Release(&exif_buffer);
            PyBuffer_Release(&xmp_buffer);
            PyObject_Del(self);
            return NULL;
        }
        // colorPrimaries and transferCharacteristics are ignored when an ICC
        // profile is present, so set them to UNSPECIFIED.
@@ -405,17 +404,17 @@
    if (exif_buffer.len) {
        result = avifImageSetMetadataExif(image, exif_buffer.buf, exif_buffer.len);
        if (result != AVIF_RESULT_OK) {
            PyErr_Format(
                exc_type_for_avif_result(result),
                "Setting EXIF data failed: %s",
                avifResultToString(result)
            );
            avifImageDestroy(image);
            avifEncoderDestroy(encoder);
            PyBuffer_Release(&exif_buffer);
            PyBuffer_Release(&xmp_buffer);
            PyObject_Del(self);
            return NULL;
        }
    }
    PyBuffer_Release(&exif_buffer);
@@ -423,16 +422,16 @@
    if (xmp_buffer.len) {
        result = avifImageSetMetadataXMP(image, xmp_buffer.buf, xmp_buffer.len);
        if (result != AVIF_RESULT_OK) {
            PyErr_Format(
                exc_type_for_avif_result(result),
                "Setting XMP data failed: %s",
                avifResultToString(result)
            );
            avifImageDestroy(image);
            avifEncoderDestroy(encoder);
            PyBuffer_Release(&xmp_buffer);
            PyObject_Del(self);
            return NULL;
        }
    }
    PyBuffer_Release(&xmp_buffer);
@@ -466,10 +465,9 @@
     unsigned int width;
     unsigned int height;
     char *mode;
-    PyObject *is_single_frame = NULL;
+    unsigned int is_single_frame;
     PyObject *ret = Py_None;
 
-    int is_first_frame;
     avifRGBImage rgb;
     avifResult result;
 
@@ -479,7 +477,7 @@
 
     if (!PyArg_ParseTuple(
             args,
-            "z#IIIsO",
+            "y#I(II)sp",
             (char **)&rgb_bytes,
             &size,
             &duration,
@@ -488,11 +486,9 @@
            &mode,
            &is_single_frame
        )) {
         return NULL;
     }
 
-    is_first_frame = self->frame_index == -1;
-
     if (image->width != width || image->height != height) {
         PyErr_Format(
             PyExc_ValueError,
@@ -505,7 +501,7 @@
         return NULL;
     }
 
-    if (is_first_frame) {
+    if (self->first_frame) {
         // If we don't have an image populated with yuv planes, this is the first frame
         frame = image;
     } else {
@@ -538,25 +534,25 @@

    result = avifRGBImageAllocatePixels(&rgb);
    if (result != AVIF_RESULT_OK) {
        PyErr_Format(
            exc_type_for_avif_result(result),
            "Pixel allocation failed: %s",
            avifResultToString(result)
        );
        return NULL;
    }

    if (rgb.rowBytes * rgb.height != size) {
        PyErr_Format(
            PyExc_RuntimeError,
            "rgb data is incorrect size: %u * %u (%u) != %u",
            rgb.rowBytes,
            rgb.height,
            rgb.rowBytes * rgb.height,
            size
        );
        ret = NULL;
        goto end;
    }

    // rgb.pixels is safe for writes
@@ -567,17 +563,17 @@
    Py_END_ALLOW_THREADS;

    if (result != AVIF_RESULT_OK) {
        PyErr_Format(
            exc_type_for_avif_result(result),
            "Conversion to YUV failed: %s",
            avifResultToString(result)
        );
        ret = NULL;
        goto end;
     }
 
     uint32_t addImageFlags = AVIF_ADD_IMAGE_FLAG_NONE;
-    if (PyObject_IsTrue(is_single_frame)) {
+    if (is_single_frame) {
         addImageFlags |= AVIF_ADD_IMAGE_FLAG_SINGLE;
     }
 
@@ -597,12 +593,12 @@
 
 end:
     avifRGBImageFreePixels(&rgb);
-    if (!is_first_frame) {
+    if (!self->first_frame) {
         avifImageDestroy(frame);
     }
 
     if (ret == Py_None) {
-        self->frame_index++;
+        self->first_frame = 0;
         Py_RETURN_NONE;
     } else {
         return ret;
@@ -622,13 +618,13 @@
    Py_END_ALLOW_THREADS;

    if (result != AVIF_RESULT_OK) {
        PyErr_Format(
            exc_type_for_avif_result(result),
            "Failed to finish encoding: %s",
            avifResultToString(result)
        );
        avifRWDataFree(&raw);
        return NULL;
    }

    ret = PyBytes_FromStringAndSize((char *)raw.data, raw.size);
@@ -663,9 +659,9 @@

    self = PyObject_New(AvifDecoderObject, &AvifDecoder_Type);
    if (!self) {
        PyErr_SetString(PyExc_RuntimeError, "could not create decoder object");
        PyBuffer_Release(&buffer);
        return NULL;
    }

    decoder = avifDecoderCreate();
@@ -684,15 +680,15 @@

    result = avifDecoderSetIOMemory(decoder, buffer.buf, buffer.len);
    if (result != AVIF_RESULT_OK) {
        PyErr_Format(
            exc_type_for_avif_result(result),
            "Setting IO memory failed: %s",
            avifResultToString(result)
        );
        avifDecoderDestroy(decoder);
        PyBuffer_Release(&buffer);
        PyObject_Del(self);
        return NULL;
    }

    result = avifDecoderParse(decoder);
@@ -708,12 +704,6 @@
         return NULL;
     }
 
-    if (decoder->alphaPresent) {
-        self->mode = "RGBA";
-    } else {
-        self->mode = "RGB";
-    }
-
     self->decoder = decoder;
     self->buffer = buffer;
 
@@ -757,7 +747,7 @@
         image->width,
         image->height,
         decoder->imageCount,
-        self->mode,
+        decoder->alphaPresent == AVIF_TRUE ? "RGBA" : "RGB",
         NULL == icc ? Py_None : icc,
         NULL == exif ? Py_None : exif,
         irot_imir_to_exif_orientation(image),
@@ -785,42 +775,36 @@
    decoder = self->decoder;

    if (!PyArg_ParseTuple(args, "I", &frame_index)) {
        return NULL;
    }

    result = avifDecoderNthImage(decoder, frame_index);
    if (result != AVIF_RESULT_OK) {
         PyErr_Format(
             exc_type_for_avif_result(result),
             "Failed to decode frame %u: %s",
-            decoder->imageIndex + 1,
+            frame_index,
             avifResultToString(result)
         );
         return NULL;
     }
 
     image = decoder->image;
 
-    memset(&rgb, 0, sizeof(rgb));
     avifRGBImageSetDefaults(&rgb, image);
 
     rgb.depth = 8;
-
-    if (decoder->alphaPresent) {
-        rgb.format = AVIF_RGB_FORMAT_RGBA;
-    } else {
-        rgb.format = AVIF_RGB_FORMAT_RGB;
-        rgb.ignoreAlpha = AVIF_TRUE;
-    }
+    rgb.format =
+        decoder->alphaPresent == AVIF_TRUE ? AVIF_RGB_FORMAT_RGBA : AVIF_RGB_FORMAT_RGB;
 
     result = avifRGBImageAllocatePixels(&rgb);
     if (result != AVIF_RESULT_OK) {
        PyErr_Format(
            exc_type_for_avif_result(result),
            "Pixel allocation failed: %s",
            avifResultToString(result)
        );
        return NULL;
    }

    Py_BEGIN_ALLOW_THREADS;
@@ -828,18 +812,18 @@
    Py_END_ALLOW_THREADS;

    if (result != AVIF_RESULT_OK) {
        PyErr_Format(
            exc_type_for_avif_result(result),
            "Conversion from YUV failed: %s",
            avifResultToString(result)
        );
        avifRGBImageFreePixels(&rgb);
        return NULL;
    }

    if (rgb.height > PY_SSIZE_T_MAX / rgb.rowBytes) {
        PyErr_SetString(PyExc_MemoryError, "Integer overflow in pixel size");
        return NULL;
    }

    size = rgb.rowBytes * rgb.height;
 if (rgb.height > PY_SSIZE_T_MAX / row_bytes) { 
     PyErr_SetString(PyExc_MemoryError, "Integer overflow in pixel size"); 
     return NULL; 
 } 
 if (rgb.height > PY_SSIZE_T_MAX / row_bytes) { 
     PyErr_SetString(PyExc_MemoryError, "Integer overflow in pixel size"); 
     return NULL; 
 } 
@@ -912,7 +896,7 @@
 static int
 setup_module(PyObject *m) {
    if (PyType_Ready(&AvifDecoder_Type) < 0 || PyType_Ready(&AvifEncoder_Type) < 0) {
        return -1;
    }

    PyObject *d = PyModule_GetDict(m);
@@ -936,9 +920,13 @@

    m = PyModule_Create(&module_def);
    if (setup_module(m) < 0) {
        Py_DECREF(m);
         return NULL;
     }
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     return m;
 }