fix: set exif orientation from irot/imir when decoding AVIF

python-pillow · hugovk · Apr 1, 2025 · Jan 3, 2021 · Oct 16, 2024 · Oct 16, 2024
commit 524d802eda37e23bc1f438b205f40e95ba37aeab
diff --git a/Tests/images/avif/rot0mir0.avif b/Tests/images/avif/rot0mir0.avif
diff --git a/Tests/images/avif/rot0mir1.avif b/Tests/images/avif/rot0mir1.avif
diff --git a/Tests/images/avif/rot1mir0.avif b/Tests/images/avif/rot1mir0.avif
diff --git a/Tests/images/avif/rot1mir1.avif b/Tests/images/avif/rot1mir1.avif
diff --git a/Tests/images/avif/rot2mir0.avif b/Tests/images/avif/rot2mir0.avif
diff --git a/Tests/images/avif/rot2mir1.avif b/Tests/images/avif/rot2mir1.avif
diff --git a/Tests/images/avif/rot3mir0.avif b/Tests/images/avif/rot3mir0.avif
diff --git a/Tests/images/avif/rot3mir1.avif b/Tests/images/avif/rot3mir1.avif
diff --git a/Tests/test_file_avif.py b/Tests/test_file_avif.py
@@ -10,6 +10,7 @@
 from pathlib import Path
 from struct import unpack
 from typing import Any
+from unittest import mock
 
 import pytest
 
@@ -72,7 +73,7 @@
    except (FileNotFoundError, PermissionError):
        return False
    else:
        return "qemu" in init_proc_exe


 def has_alpha_premultiplied(im_bytes: bytes) -> bool:
@@ -83,9 +84,9 @@
        size, boxtype = unpack(">L4s", stream.read(8))
        if not all(0x20 <= c <= 0x7E for c in boxtype):
            # Not ascii
            return False
        if size == 1:  # 64bit size
            (size,) = unpack(">Q", stream.read(8))
        end = start + size
        version, _ = unpack(">B3s", stream.read(4))
        if boxtype in (b"ftyp", b"hdlr", b"pitm", b"iloc", b"iinf"):
@@ -105,7 +106,7 @@
                stream.read(2 if version == 0 else 4)
        else:
            return False
    return False


 class TestUnsupportedAvif:
@@ -172,7 +173,7 @@
            # the image.
            target = hopper(mode)
            if mode != "RGB":
                target = target.convert("RGB")
            assert_image_similar(image, target, epsilon)

    def test_write_rgb(self, tmp_path: Path) -> None:
@@ -329,24 +330,65 @@
             exif = im.getexif()
         assert exif[274] == 3
 
-    @pytest.mark.parametrize("bytes", [True, False])
-    def test_exif_save(self, tmp_path: Path, bytes: bool) -> None:
+    @pytest.mark.parametrize("bytes,orientation", [(True, 1), (False, 2)])
+    def test_exif_save(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        bytes: bool,
+        orientation: int,
+    ) -> None:
+        mock_avif_encoder = mock.Mock(wraps=_avif.AvifEncoder)
+        monkeypatch.setattr(_avif, "AvifEncoder", mock_avif_encoder)
         exif = Image.Exif()
-        exif[274] = 1
+        exif[274] = orientation
         exif_data = exif.tobytes()
         with Image.open(TEST_AVIF_FILE) as im:
             test_file = str(tmp_path / "temp.avif")
             im.save(test_file, exif=exif_data if bytes else exif)
 
         with Image.open(test_file) as reloaded:
-            assert reloaded.info["exif"] == exif_data
+            if orientation == 1:
+                assert "exif" not in reloaded.info
+            else:
+                assert reloaded.info["exif"] == exif_data
+        mock_avif_encoder.mock_calls[0].args[16:17] == (b"", orientation)
 
     def test_exif_invalid(self, tmp_path: Path) -> None:
         with Image.open(TEST_AVIF_FILE) as im:
             test_file = str(tmp_path / "temp.avif")
             with pytest.raises(SyntaxError):
                 im.save(test_file, exif=b"invalid")
 
+    @pytest.mark.parametrize(
+        "rot,mir,exif_orientation",
+        [
+            (0, 0, 4),
+            (0, 1, 2),
+            (1, 0, 5),
+            (1, 1, 7),
+            (2, 0, 2),
+            (2, 1, 4),
+            (3, 0, 7),
+            (3, 1, 5),
+        ],
+    )
+    def test_rot_mir_exif(
+        self, rot: int, mir: int, exif_orientation: int, tmp_path: Path
+    ) -> None:
+        with Image.open(f"Tests/images/avif/rot{rot}mir{mir}.avif") as im:
+            exif = im.info["exif"]
+            test_file = str(tmp_path / "temp.avif")
+            im.save(test_file, exif=exif)
+
+            exif_data = Image.Exif()
+            exif_data.load(exif)
+            assert exif_data[274] == exif_orientation
+        with Image.open(test_file) as reloaded:
+            exif_data = Image.Exif()
+            exif_data.load(reloaded.info["exif"])
+            assert exif_data[274] == exif_orientation
+
     def test_xmp(self) -> None:
         with Image.open("Tests/images/avif/xmp_tags_orientation.avif") as im:
             xmp = im.info["xmp"]

diff --git a/src/PIL/AvifImagePlugin.py b/src/PIL/AvifImagePlugin.py
@@ -50,9 +50,9 @@

 def _get_default_max_threads():
    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

@@ -86,7 +86,9 @@
         )
 
         # Get info from decoder
-        width, height, n_frames, mode, icc, exif, xmp = self._decoder.get_info()
+        width, height, n_frames, mode, icc, exif, xmp, exif_orientation = (
+            self._decoder.get_info()
+        )
         self._size = width, height
         self.n_frames = n_frames
         self.is_animated = self.n_frames > 1
@@ -99,6 +101,16 @@
         if xmp:
             self.info["xmp"] = xmp
 
+        if exif_orientation != 1 or exif is not None:
+            exif_data = Image.Exif()
+            orig_orientation = 1
+            if exif is not None:
+                exif_data.load(exif)
+                orig_orientation = exif_data.get(ExifTags.Base.Orientation, 1)
+            if exif_orientation != orig_orientation:
+                exif_data[ExifTags.Base.Orientation] = exif_orientation
+                self.info["exif"] = exif_data.tobytes()
+
     def seek(self, frame: int) -> None:
         if not self._seek_check(frame):
             return
@@ -176,9 +188,14 @@
         else:
             exif_data = Image.Exif()
             exif_data.load(exif)
-        exif_orientation = exif_data.pop(ExifTags.Base.Orientation, 1)
+        exif_orientation = exif_data.pop(ExifTags.Base.Orientation, 0)
+        if exif_orientation != 0:
+            if len(exif_data):
+                exif = exif_data.tobytes()
+            else:
+                exif = None
     else:
-        exif_orientation = 1
+        exif_orientation = 0
 
     xmp = info.get("xmp")
 

diff --git a/src/_avif.c b/src/_avif.c
@@ -39,22 +39,22 @@
 static PyTypeObject AvifDecoder_Type;

 static int
 normalize_quantize_value(int qvalue) {
    if (qvalue < AVIF_QUANTIZER_BEST_QUALITY) {
        return AVIF_QUANTIZER_BEST_QUALITY;
    } else if (qvalue > AVIF_QUANTIZER_WORST_QUALITY) {
        return AVIF_QUANTIZER_WORST_QUALITY;
    } else {
        return qvalue;
    }
 }

 static int
 normalize_tiles_log2(int value) {
    if (value < 0) {
        return 0;
    } else if (value > 6) {
        return 6;
    } else {
        return value;
    }
@@ -71,11 +71,49 @@
        case AVIF_RESULT_TRUNCATED_DATA:
        case AVIF_RESULT_NO_CONTENT:
            return PyExc_SyntaxError;
        default:
            return PyExc_RuntimeError;
     }
 }
 
+static uint8_t
+irot_imir_to_exif_orientation(const avifImage *image) {
+#if AVIF_VERSION_MAJOR >= 1
+    uint8_t axis = image->imir.axis;
+#else
+    uint8_t axis = image->imir.mode;
+#endif
+    uint8_t angle = image->irot.angle;
+    int irot = !!(image->transformFlags & AVIF_TRANSFORM_IROT);
+    int imir = !!(image->transformFlags & AVIF_TRANSFORM_IMIR);
+    if (irot && angle == 1) {
+        if (imir) {
+            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 (irot && 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 (irot && angle == 3) {
+        if (imir) {
+            return axis ? 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) {
+        return axis ? 2   // Swap left and right.
+                    : 4;  // Swap top and bottom.
+    }
+    return 1;  // Default orientation ("top-left", no-op).
+}
+
 static void
 exif_orientation_to_irot_imir(avifImage *image, int orientation) {
     const avifTransformFlags otherFlags =
@@ -106,16 +144,16 @@
            image->imir.mode = 1;
 #endif
            return;
        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 = otherFlags | AVIF_TRANSFORM_IROT;
            image->irot.angle = 2;
 #if AVIF_VERSION_MAJOR >= 1
            image->imir.axis = 0;  // ignored
 #else
            image->imir.mode = 0;  // ignored
 #endif
            return;
        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 = otherFlags | AVIF_TRANSFORM_IMIR;
@@ -138,16 +176,16 @@
            image->imir.mode = 0;
 #endif
            return;
        case 6:  // The 0th row is the visual right-hand side of the image, and the 0th
                 // column is the visual top.
            image->transformFlags = otherFlags | AVIF_TRANSFORM_IROT;
            image->irot.angle = 3;
 #if AVIF_VERSION_MAJOR >= 1
            image->imir.axis = 0;  // ignored
 #else
            image->imir.mode = 0;  // ignored
 #endif
            return;
        case 7:  // The 0th row is the visual right-hand side of the image, and the 0th
                 // column is the visual bottom.
            image->transformFlags =
@@ -160,16 +198,16 @@
            image->imir.mode = 0;
 #endif
            return;
        case 8:  // The 0th row is the visual left-hand side of the image, and the 0th
                 // column is the visual bottom.
            image->transformFlags = otherFlags | AVIF_TRANSFORM_IROT;
            image->irot.angle = 1;
 #if AVIF_VERSION_MAJOR >= 1
            image->imir.axis = 0;  // ignored
 #else
            image->imir.mode = 0;  // ignored
 #endif
            return;
    }
 }

@@ -209,34 +247,34 @@
    PyObject *keyval, *py_key, *py_val;
    char *key, *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 (!PyBytes_Check(py_key) || !PyBytes_Check(py_val)) {
            PyErr_SetString(PyExc_ValueError, "Invalid advanced codec options");
            return 1;
        }
        key = PyBytes_AsString(py_key);
        val = PyBytes_AsString(py_val);

        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;
@@ -318,15 +356,15 @@
        enc_options.qmax = normalize_quantize_value(100 - quality);
 #endif
    } else {
        enc_options.qmin = normalize_quantize_value(qmin);
        enc_options.qmax = normalize_quantize_value(qmax);
    }
    enc_options.quality = quality;

    if (speed < AVIF_SPEED_SLOWEST) {
        speed = AVIF_SPEED_SLOWEST;
    } else if (speed > AVIF_SPEED_FASTEST) {
        speed = AVIF_SPEED_FASTEST;
    }
    enc_options.speed = speed;

@@ -347,8 +385,8 @@

    // Validate canvas dimensions
    if (width <= 0 || height <= 0) {
        PyErr_SetString(PyExc_ValueError, "invalid canvas dimensions");
        return NULL;
    }

    enc_options.tile_rows_log2 = normalize_tiles_log2(tile_rows_log2);
@@ -378,9 +416,9 @@
        encoder->maxThreads = is_aom_encode && max_threads > 64 ? 64 : max_threads;
 #if AVIF_VERSION >= 1000000
        if (enc_options.qmin != -1 && enc_options.qmax != -1) {
            encoder->minQuantizer = enc_options.qmin;
            encoder->maxQuantizer = enc_options.qmax;
        } else {
            encoder->quality = enc_options.quality;
        }
 #else
@@ -400,7 +438,7 @@
        if (advanced != Py_None) {
 #if AVIF_VERSION >= 80200
            if (_add_codec_specific_options(encoder, advanced)) {
                return NULL;
            }
 #else
            PyErr_SetString(
@@ -437,12 +475,12 @@
                PyBytes_GET_SIZE(icc_bytes)
            );
            if (result != AVIF_RESULT_OK) {
                PyErr_Format(
                    exc_type_for_avif_result(result),
                    "Setting ICC profile failed: %s",
                    avifResultToString(result)
                );
                return NULL;
            }
        } else {
            image->colorPrimaries = AVIF_COLOR_PRIMARIES_BT709;
@@ -450,21 +488,21 @@
        }

        if (PyBytes_GET_SIZE(exif_bytes)) {
            self->exif_bytes = exif_bytes;
            Py_INCREF(exif_bytes);

            result = avifImageSetMetadataExif(
                image,
                (uint8_t *)PyBytes_AS_STRING(exif_bytes),
                PyBytes_GET_SIZE(exif_bytes)
            );
            if (result != AVIF_RESULT_OK) {
                PyErr_Format(
                    exc_type_for_avif_result(result),
                    "Setting EXIF data failed: %s",
                    avifResultToString(result)
                );
                return NULL;
            }
        }
        if (PyBytes_GET_SIZE(xmp_bytes)) {
@@ -477,23 +515,25 @@
                PyBytes_GET_SIZE(xmp_bytes)
            );
            if (result != AVIF_RESULT_OK) {
                PyErr_Format(
                    exc_type_for_avif_result(result),
                    "Setting XMP data failed: %s",
                    avifResultToString(result)
                );
                 return NULL;
             }
         }
-        exif_orientation_to_irot_imir(image, exif_orientation);
+        if (exif_orientation > 0) {
+            exif_orientation_to_irot_imir(image, exif_orientation);
+        }
 
         self->image = image;
         self->frame_index = -1;

        return (PyObject *)self;
    }
    PyErr_SetString(PyExc_RuntimeError, "could not create encoder object");
    return NULL;
 }

 PyObject *
@@ -540,7 +580,7 @@
            &mode,
            &is_single_frame
        )) {
        return NULL;
    }

    is_first_frame = (self->frame_index == -1);
@@ -590,25 +630,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
@@ -618,13 +658,13 @@
    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;
@@ -672,13 +712,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);
@@ -712,8 +752,8 @@

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

@@ -740,15 +780,15 @@
        PyBytes_GET_SIZE(self->data)
    );
    if (result != AVIF_RESULT_OK) {
        PyErr_Format(
            exc_type_for_avif_result(result),
            "Setting IO memory failed: %s",
            avifResultToString(result)
        );
        avifDecoderDestroy(self->decoder);
        self->decoder = NULL;
        Py_DECREF(self);
        return NULL;
    }

    result = avifDecoderParse(self->decoder);
@@ -806,14 +846,15 @@
     }
 
     ret = Py_BuildValue(
-        "IIIsSSS",
+        "IIIsSSSI",
         image->width,
         image->height,
         decoder->imageCount,
         self->mode,
         NULL == icc ? Py_None : icc,
         NULL == exif ? Py_None : exif,
-        NULL == xmp ? Py_None : xmp
+        NULL == xmp ? Py_None : xmp,
+        irot_imir_to_exif_orientation(image)
     );
 
     Py_XDECREF(xmp);
@@ -838,18 +879,18 @@
    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,
            avifResultToString(result)
        );
        return NULL;
    }

    image = decoder->image;
@@ -869,31 +910,31 @@
    row_bytes = rgb.width * avifRGBImagePixelSize(&rgb);

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

    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 result = avifImageYUVToRGB(image, &rgb);
    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;
    }

    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; 
 } 
@@ -969,16 +1010,16 @@

    PyObject *v = PyUnicode_FromString(avifVersion());
    if (PyDict_SetItemString(d, "libavif_version", v) < 0) {
        Py_DECREF(v);
        return -1;
    }
    Py_DECREF(v);

    v = Py_True;
    Py_INCREF(v);
    if (PyDict_SetItemString(d, "HAVE_AVIF", v) < 0) {
        Py_DECREF(v);
        return -1;
    }
    Py_DECREF(v);

@@ -987,13 +1028,13 @@
    );

    if (PyDict_SetItemString(d, "VERSION", v) < 0) {
        Py_DECREF(v);
        return -1;
    }
    Py_DECREF(v);

    if (PyType_Ready(&AvifDecoder_Type) < 0 || PyType_Ready(&AvifEncoder_Type) < 0) {
        return -1;
    }
    return 0;
 }
@@ -1011,7 +1052,7 @@

    m = PyModule_Create(&module_def);
    if (setup_module(m) < 0) {
        return NULL;
    }

    return m;