Hide navigation sidebar
Hide table of contents sidebar
Skip to content
Back to top
Toggle table of contents sidebar

# Source code for PIL.TiffImagePlugin

    #
    # The Python Imaging Library.
    # $Id$
    #
    # TIFF file handling
    #
    # TIFF is a flexible, if somewhat aged, image file format originally
    # defined by Aldus.  Although TIFF supports a wide variety of pixel
    # layouts and compression methods, the name doesn't really stand for
    # "thousands of incompatible file formats," it just feels that way.
    #
    # To read TIFF data from a stream, the stream must be seekable.  For
    # progressive decoding, make sure to use TIFF files where the tag
    # directory is placed first in the file.
    #
    # History:
    # 1995-09-01 fl   Created
    # 1996-05-04 fl   Handle JPEGTABLES tag
    # 1996-05-18 fl   Fixed COLORMAP support
    # 1997-01-05 fl   Fixed PREDICTOR support
    # 1997-08-27 fl   Added support for rational tags (from Perry Stoll)
    # 1998-01-10 fl   Fixed seek/tell (from Jan Blom)
    # 1998-07-15 fl   Use private names for internal variables
    # 1999-06-13 fl   Rewritten for PIL 1.0 (1.0)
    # 2000-10-11 fl   Additional fixes for Python 2.0 (1.1)
    # 2001-04-17 fl   Fixed rewind support (seek to frame 0) (1.2)
    # 2001-05-12 fl   Added write support for more tags (from Greg Couch) (1.3)
    # 2001-12-18 fl   Added workaround for broken Matrox library
    # 2002-01-18 fl   Don't mess up if photometric tag is missing (D. Alan Stewart)
    # 2003-05-19 fl   Check FILLORDER tag
    # 2003-09-26 fl   Added RGBa support
    # 2004-02-24 fl   Added DPI support; fixed rational write support
    # 2005-02-07 fl   Added workaround for broken Corel Draw 10 files
    # 2006-01-09 fl   Added support for float/double tags (from Russell Nelson)
    #
    # Copyright (c) 1997-2006 by Secret Labs AB.  All rights reserved.
    # Copyright (c) 1995-1997 by Fredrik Lundh
    #
    # See the README file for information on usage and redistribution.
    #
    from __future__ import annotations

    import io
    import itertools
    import logging
    import math
    import os
    import struct
    import warnings
    from collections.abc import Iterator, MutableMapping
    from fractions import Fraction
    from numbers import Number, Rational
    from typing import IO, Any, Callable, NoReturn, cast

    from . import ExifTags, Image, ImageFile, ImageOps, ImagePalette, TiffTags
    from ._binary import i16be as i16
    from ._binary import i32be as i32
    from ._binary import o8
    from ._deprecate import deprecate
    from ._typing import StrOrBytesPath
    from ._util import DeferredError, is_path
    from .TiffTags import TYPES

    TYPE_CHECKING = False
    if TYPE_CHECKING:
        from ._typing import Buffer, IntegralLike

    logger = logging.getLogger(__name__)

    # Set these to true to force use of libtiff for reading or writing.
    READ_LIBTIFF = False
    WRITE_LIBTIFF = False
    STRIP_SIZE = 65536

    II = b"II"  # little-endian (Intel style)
    MM = b"MM"  # big-endian (Motorola style)

    #
    # --------------------------------------------------------------------
    # Read TIFF files

    # a few tag names, just to make the code below a bit more readable
    OSUBFILETYPE = 255
    IMAGEWIDTH = 256
    IMAGELENGTH = 257
    BITSPERSAMPLE = 258
    COMPRESSION = 259
    PHOTOMETRIC_INTERPRETATION = 262
    FILLORDER = 266
    IMAGEDESCRIPTION = 270
    STRIPOFFSETS = 273
    SAMPLESPERPIXEL = 277
    ROWSPERSTRIP = 278
    STRIPBYTECOUNTS = 279
    X_RESOLUTION = 282
    Y_RESOLUTION = 283
    PLANAR_CONFIGURATION = 284
    RESOLUTION_UNIT = 296
    TRANSFERFUNCTION = 301
    SOFTWARE = 305
    DATE_TIME = 306
    ARTIST = 315
    PREDICTOR = 317
    COLORMAP = 320
    TILEWIDTH = 322
    TILELENGTH = 323
    TILEOFFSETS = 324
    TILEBYTECOUNTS = 325
    SUBIFD = 330
    EXTRASAMPLES = 338
    SAMPLEFORMAT = 339
    JPEGTABLES = 347
    YCBCRSUBSAMPLING = 530
    REFERENCEBLACKWHITE = 532
    COPYRIGHT = 33432
    IPTC_NAA_CHUNK = 33723  # newsphoto properties
    PHOTOSHOP_CHUNK = 34377  # photoshop properties
    ICCPROFILE = 34675
    EXIFIFD = 34665
    XMP = 700
    JPEGQUALITY = 65537  # pseudo-tag by libtiff

    # https://github.com/imagej/ImageJA/blob/master/src/main/java/ij/io/TiffDecoder.java
    IMAGEJ_META_DATA_BYTE_COUNTS = 50838
    IMAGEJ_META_DATA = 50839

    COMPRESSION_INFO = {
        # Compression => pil compression name
        1: "raw",
        2: "tiff_ccitt",
        3: "group3",
        4: "group4",
        5: "tiff_lzw",
        6: "tiff_jpeg",  # obsolete
        7: "jpeg",
        8: "tiff_adobe_deflate",
        32771: "tiff_raw_16",  # 16-bit padding
        32773: "packbits",
        32809: "tiff_thunderscan",
        32946: "tiff_deflate",
        34676: "tiff_sgilog",
        34677: "tiff_sgilog24",
        34925: "lzma",
        50000: "zstd",
        50001: "webp",
    }

    COMPRESSION_INFO_REV = {v: k for k, v in COMPRESSION_INFO.items()}

    OPEN_INFO = {
        # (ByteOrder, PhotoInterpretation, SampleFormat, FillOrder, BitsPerSample,
        #  ExtraSamples) => mode, rawmode
        (II, 0, (1,), 1, (1,), ()): ("1", "1;I"),
        (MM, 0, (1,), 1, (1,), ()): ("1", "1;I"),
        (II, 0, (1,), 2, (1,), ()): ("1", "1;IR"),
        (MM, 0, (1,), 2, (1,), ()): ("1", "1;IR"),
        (II, 1, (1,), 1, (1,), ()): ("1", "1"),
        (MM, 1, (1,), 1, (1,), ()): ("1", "1"),
        (II, 1, (1,), 2, (1,), ()): ("1", "1;R"),
        (MM, 1, (1,), 2, (1,), ()): ("1", "1;R"),
        (II, 0, (1,), 1, (2,), ()): ("L", "L;2I"),
        (MM, 0, (1,), 1, (2,), ()): ("L", "L;2I"),
        (II, 0, (1,), 2, (2,), ()): ("L", "L;2IR"),
        (MM, 0, (1,), 2, (2,), ()): ("L", "L;2IR"),
        (II, 1, (1,), 1, (2,), ()): ("L", "L;2"),
        (MM, 1, (1,), 1, (2,), ()): ("L", "L;2"),
        (II, 1, (1,), 2, (2,), ()): ("L", "L;2R"),
        (MM, 1, (1,), 2, (2,), ()): ("L", "L;2R"),
        (II, 0, (1,), 1, (4,), ()): ("L", "L;4I"),
        (MM, 0, (1,), 1, (4,), ()): ("L", "L;4I"),
        (II, 0, (1,), 2, (4,), ()): ("L", "L;4IR"),
        (MM, 0, (1,), 2, (4,), ()): ("L", "L;4IR"),
        (II, 1, (1,), 1, (4,), ()): ("L", "L;4"),
        (MM, 1, (1,), 1, (4,), ()): ("L", "L;4"),
        (II, 1, (1,), 2, (4,), ()): ("L", "L;4R"),
        (MM, 1, (1,), 2, (4,), ()): ("L", "L;4R"),
        (II, 0, (1,), 1, (8,), ()): ("L", "L;I"),
        (MM, 0, (1,), 1, (8,), ()): ("L", "L;I"),
        (II, 0, (1,), 2, (8,), ()): ("L", "L;IR"),
        (MM, 0, (1,), 2, (8,), ()): ("L", "L;IR"),
        (II, 1, (1,), 1, (8,), ()): ("L", "L"),
        (MM, 1, (1,), 1, (8,), ()): ("L", "L"),
        (II, 1, (2,), 1, (8,), ()): ("L", "L"),
        (MM, 1, (2,), 1, (8,), ()): ("L", "L"),
        (II, 1, (1,), 2, (8,), ()): ("L", "L;R"),
        (MM, 1, (1,), 2, (8,), ()): ("L", "L;R"),
        (II, 1, (1,), 1, (12,), ()): ("I;16", "I;12"),
        (II, 0, (1,), 1, (16,), ()): ("I;16", "I;16"),
        (II, 1, (1,), 1, (16,), ()): ("I;16", "I;16"),
        (MM, 1, (1,), 1, (16,), ()): ("I;16B", "I;16B"),
        (II, 1, (1,), 2, (16,), ()): ("I;16", "I;16R"),
        (II, 1, (2,), 1, (16,), ()): ("I", "I;16S"),
        (MM, 1, (2,), 1, (16,), ()): ("I", "I;16BS"),
        (II, 0, (3,), 1, (32,), ()): ("F", "F;32F"),
        (MM, 0, (3,), 1, (32,), ()): ("F", "F;32BF"),
        (II, 1, (1,), 1, (32,), ()): ("I", "I;32N"),
        (II, 1, (2,), 1, (32,), ()): ("I", "I;32S"),
        (MM, 1, (2,), 1, (32,), ()): ("I", "I;32BS"),
        (II, 1, (3,), 1, (32,), ()): ("F", "F;32F"),
        (MM, 1, (3,), 1, (32,), ()): ("F", "F;32BF"),
        (II, 1, (1,), 1, (8, 8), (2,)): ("LA", "LA"),
        (MM, 1, (1,), 1, (8, 8), (2,)): ("LA", "LA"),
        (II, 2, (1,), 1, (8, 8, 8), ()): ("RGB", "RGB"),
        (MM, 2, (1,), 1, (8, 8, 8), ()): ("RGB", "RGB"),
        (II, 2, (1,), 2, (8, 8, 8), ()): ("RGB", "RGB;R"),
        (MM, 2, (1,), 2, (8, 8, 8), ()): ("RGB", "RGB;R"),
        (II, 2, (1,), 1, (8, 8, 8, 8), ()): ("RGBA", "RGBA"),  # missing ExtraSamples
        (MM, 2, (1,), 1, (8, 8, 8, 8), ()): ("RGBA", "RGBA"),  # missing ExtraSamples
        (II, 2, (1,), 1, (8, 8, 8, 8), (0,)): ("RGB", "RGBX"),
        (MM, 2, (1,), 1, (8, 8, 8, 8), (0,)): ("RGB", "RGBX"),
        (II, 2, (1,), 1, (8, 8, 8, 8, 8), (0, 0)): ("RGB", "RGBXX"),
        (MM, 2, (1,), 1, (8, 8, 8, 8, 8), (0, 0)): ("RGB", "RGBXX"),
        (II, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0, 0)): ("RGB", "RGBXXX"),
        (MM, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0, 0)): ("RGB", "RGBXXX"),
        (II, 2, (1,), 1, (8, 8, 8, 8), (1,)): ("RGBA", "RGBa"),
        (MM, 2, (1,), 1, (8, 8, 8, 8), (1,)): ("RGBA", "RGBa"),
        (II, 2, (1,), 1, (8, 8, 8, 8, 8), (1, 0)): ("RGBA", "RGBaX"),
        (MM, 2, (1,), 1, (8, 8, 8, 8, 8), (1, 0)): ("RGBA", "RGBaX"),
        (II, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (1, 0, 0)): ("RGBA", "RGBaXX"),
        (MM, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (1, 0, 0)): ("RGBA", "RGBaXX"),
        (II, 2, (1,), 1, (8, 8, 8, 8), (2,)): ("RGBA", "RGBA"),
        (MM, 2, (1,), 1, (8, 8, 8, 8), (2,)): ("RGBA", "RGBA"),
        (II, 2, (1,), 1, (8, 8, 8, 8, 8), (2, 0)): ("RGBA", "RGBAX"),
        (MM, 2, (1,), 1, (8, 8, 8, 8, 8), (2, 0)): ("RGBA", "RGBAX"),
        (II, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (2, 0, 0)): ("RGBA", "RGBAXX"),
        (MM, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (2, 0, 0)): ("RGBA", "RGBAXX"),
        (II, 2, (1,), 1, (8, 8, 8, 8), (999,)): ("RGBA", "RGBA"),  # Corel Draw 10
        (MM, 2, (1,), 1, (8, 8, 8, 8), (999,)): ("RGBA", "RGBA"),  # Corel Draw 10
        (II, 2, (1,), 1, (16, 16, 16), ()): ("RGB", "RGB;16L"),
        (MM, 2, (1,), 1, (16, 16, 16), ()): ("RGB", "RGB;16B"),
        (II, 2, (1,), 1, (16, 16, 16, 16), ()): ("RGBA", "RGBA;16L"),
        (MM, 2, (1,), 1, (16, 16, 16, 16), ()): ("RGBA", "RGBA;16B"),
        (II, 2, (1,), 1, (16, 16, 16, 16), (0,)): ("RGB", "RGBX;16L"),
        (MM, 2, (1,), 1, (16, 16, 16, 16), (0,)): ("RGB", "RGBX;16B"),
        (II, 2, (1,), 1, (16, 16, 16, 16), (1,)): ("RGBA", "RGBa;16L"),
        (MM, 2, (1,), 1, (16, 16, 16, 16), (1,)): ("RGBA", "RGBa;16B"),
        (II, 2, (1,), 1, (16, 16, 16, 16), (2,)): ("RGBA", "RGBA;16L"),
        (MM, 2, (1,), 1, (16, 16, 16, 16), (2,)): ("RGBA", "RGBA;16B"),
        (II, 3, (1,), 1, (1,), ()): ("P", "P;1"),
        (MM, 3, (1,), 1, (1,), ()): ("P", "P;1"),
        (II, 3, (1,), 2, (1,), ()): ("P", "P;1R"),
        (MM, 3, (1,), 2, (1,), ()): ("P", "P;1R"),
        (II, 3, (1,), 1, (2,), ()): ("P", "P;2"),
        (MM, 3, (1,), 1, (2,), ()): ("P", "P;2"),
        (II, 3, (1,), 2, (2,), ()): ("P", "P;2R"),
        (MM, 3, (1,), 2, (2,), ()): ("P", "P;2R"),
        (II, 3, (1,), 1, (4,), ()): ("P", "P;4"),
        (MM, 3, (1,), 1, (4,), ()): ("P", "P;4"),
        (II, 3, (1,), 2, (4,), ()): ("P", "P;4R"),
        (MM, 3, (1,), 2, (4,), ()): ("P", "P;4R"),
        (II, 3, (1,), 1, (8,), ()): ("P", "P"),
        (MM, 3, (1,), 1, (8,), ()): ("P", "P"),
        (II, 3, (1,), 1, (8, 8), (0,)): ("P", "PX"),
        (II, 3, (1,), 1, (8, 8), (2,)): ("PA", "PA"),
        (MM, 3, (1,), 1, (8, 8), (2,)): ("PA", "PA"),
        (II, 3, (1,), 2, (8,), ()): ("P", "P;R"),
        (MM, 3, (1,), 2, (8,), ()): ("P", "P;R"),
        (II, 5, (1,), 1, (8, 8, 8, 8), ()): ("CMYK", "CMYK"),
        (MM, 5, (1,), 1, (8, 8, 8, 8), ()): ("CMYK", "CMYK"),
        (II, 5, (1,), 1, (8, 8, 8, 8, 8), (0,)): ("CMYK", "CMYKX"),
        (MM, 5, (1,), 1, (8, 8, 8, 8, 8), (0,)): ("CMYK", "CMYKX"),
        (II, 5, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0)): ("CMYK", "CMYKXX"),
        (MM, 5, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0)): ("CMYK", "CMYKXX"),
        (II, 5, (1,), 1, (16, 16, 16, 16), ()): ("CMYK", "CMYK;16L"),
        (MM, 5, (1,), 1, (16, 16, 16, 16), ()): ("CMYK", "CMYK;16B"),
        (II, 6, (1,), 1, (8,), ()): ("L", "L"),
        (MM, 6, (1,), 1, (8,), ()): ("L", "L"),
        # JPEG compressed images handled by LibTiff and auto-converted to RGBX
        # Minimal Baseline TIFF requires YCbCr images to have 3 SamplesPerPixel
        (II, 6, (1,), 1, (8, 8, 8), ()): ("RGB", "RGBX"),
        (MM, 6, (1,), 1, (8, 8, 8), ()): ("RGB", "RGBX"),
        (II, 8, (1,), 1, (8, 8, 8), ()): ("LAB", "LAB"),
        (MM, 8, (1,), 1, (8, 8, 8), ()): ("LAB", "LAB"),
    }

    MAX_SAMPLESPERPIXEL = max(len(key_tp[4]) for key_tp in OPEN_INFO)

    PREFIXES = [
        b"MM\x00\x2a",  # Valid TIFF header with big-endian byte order
        b"II\x2a\x00",  # Valid TIFF header with little-endian byte order
        b"MM\x2a\x00",  # Invalid TIFF header, assume big-endian
        b"II\x00\x2a",  # Invalid TIFF header, assume little-endian
        b"MM\x00\x2b",  # BigTIFF with big-endian byte order
        b"II\x2b\x00",  # BigTIFF with little-endian byte order
    ]

    if not getattr(Image.core, "libtiff_support_custom_tags", True):
        deprecate("Support for LibTIFF earlier than version 4", 12)

    def _accept(prefix: bytes) -> bool:
        return prefix.startswith(tuple(PREFIXES))

    def _limit_rational(
        val: float | Fraction | IFDRational, max_val: int
    ) -> tuple[IntegralLike, IntegralLike]:
        inv = abs(val) > 1
        n_d = IFDRational(1 / val if inv else val).limit_rational(max_val)
        return n_d[::-1] if inv else n_d

    def _limit_signed_rational(
        val: IFDRational, max_val: int, min_val: int
    ) -> tuple[IntegralLike, IntegralLike]:
        frac = Fraction(val)
        n_d: tuple[IntegralLike, IntegralLike] = frac.numerator, frac.denominator

        if min(float(i) for i in n_d) < min_val:
            n_d = _limit_rational(val, abs(min_val))

        n_d_float = tuple(float(i) for i in n_d)
        if max(n_d_float) > max_val:
            n_d = _limit_rational(n_d_float[0] / n_d_float[1], max_val)

        return n_d

    ##
    # Wrapper for TIFF IFDs.

    _load_dispatch = {}
    _write_dispatch = {}

    def _delegate(op: str) -> Any:
        def delegate(
            self: IFDRational, *args: tuple[float, ...]
        ) -> bool | float | Fraction:
            return getattr(self._val, op)(*args)

        return delegate

    class IFDRational(Rational):
        """Implements a rational class where 0/0 is a legal value to match
        the in the wild use of exif rationals.

        e.g., DigitalZoomRatio - 0.00/0.00  indicates that no digital zoom was used
        """

        """ If the denominator is 0, store this as a float('nan'), otherwise store
        as a fractions.Fraction(). Delegate as appropriate

        """

        __slots__ = ("_numerator", "_denominator", "_val")

        def __init__(
            self, value: float | Fraction | IFDRational, denominator: int = 1
        ) -> None:
            """
            :param value: either an integer numerator, a
            float/rational/other number, or an IFDRational
            :param denominator: Optional integer denominator
            """
            self._val: Fraction | float
            if isinstance(value, IFDRational):
                self._numerator = value.numerator
                self._denominator = value.denominator
                self._val = value._val
                return

            if isinstance(value, Fraction):
                self._numerator = value.numerator
                self._denominator = value.denominator
            else:
                if TYPE_CHECKING:
                    self._numerator = cast(IntegralLike, value)
                else:
                    self._numerator = value
                self._denominator = denominator

            if denominator == 0:
                self._val = float("nan")
            elif denominator == 1:
                self._val = Fraction(value)
            elif int(value) == value:
                self._val = Fraction(int(value), denominator)
            else:
                self._val = Fraction(value / denominator)

        @property
        def numerator(self) -> IntegralLike:
            return self._numerator

        @property
        def denominator(self) -> int:
            return self._denominator

        def limit_rational(self, max_denominator: int) -> tuple[IntegralLike, int]:
            """

            :param max_denominator: Integer, the maximum denominator value
            :returns: Tuple of (numerator, denominator)
            """

            if self.denominator == 0:
                return self.numerator, self.denominator

            assert isinstance(self._val, Fraction)
            f = self._val.limit_denominator(max_denominator)
            return f.numerator, f.denominator

        def __repr__(self) -> str:
            return str(float(self._val))

        def __hash__(self) -> int:  # type: ignore[override]
            return self._val.__hash__()

        def __eq__(self, other: object) -> bool:
            val = self._val
            if isinstance(other, IFDRational):
                other = other._val
            if isinstance(other, float):
                val = float(val)
            return val == other

        def __getstate__(self) -> list[float | Fraction | IntegralLike]:
            return [self._val, self._numerator, self._denominator]

        def __setstate__(self, state: list[float | Fraction | IntegralLike]) -> None:
            IFDRational.__init__(self, 0)
            _val, _numerator, _denominator = state
            assert isinstance(_val, (float, Fraction))
            self._val = _val
            if TYPE_CHECKING:
                self._numerator = cast(IntegralLike, _numerator)
            else:
                self._numerator = _numerator
            assert isinstance(_denominator, int)
            self._denominator = _denominator

        """ a = ['add','radd', 'sub', 'rsub', 'mul', 'rmul',
                 'truediv', 'rtruediv', 'floordiv', 'rfloordiv',
                 'mod','rmod', 'pow','rpow', 'pos', 'neg',
                 'abs', 'trunc', 'lt', 'gt', 'le', 'ge', 'bool',
                 'ceil', 'floor', 'round']
            print("\n".join("__%s__ = _delegate('__%s__')" % (s,s) for s in a))
            """

        __add__ = _delegate("__add__")
        __radd__ = _delegate("__radd__")
        __sub__ = _delegate("__sub__")
        __rsub__ = _delegate("__rsub__")
        __mul__ = _delegate("__mul__")
        __rmul__ = _delegate("__rmul__")
        __truediv__ = _delegate("__truediv__")
        __rtruediv__ = _delegate("__rtruediv__")
        __floordiv__ = _delegate("__floordiv__")
        __rfloordiv__ = _delegate("__rfloordiv__")
        __mod__ = _delegate("__mod__")
        __rmod__ = _delegate("__rmod__")
        __pow__ = _delegate("__pow__")
        __rpow__ = _delegate("__rpow__")
        __pos__ = _delegate("__pos__")
        __neg__ = _delegate("__neg__")
        __abs__ = _delegate("__abs__")
        __trunc__ = _delegate("__trunc__")
        __lt__ = _delegate("__lt__")
        __gt__ = _delegate("__gt__")
        __le__ = _delegate("__le__")
        __ge__ = _delegate("__ge__")
        __bool__ = _delegate("__bool__")
        __ceil__ = _delegate("__ceil__")
        __floor__ = _delegate("__floor__")
        __round__ = _delegate("__round__")
        # Python >= 3.11
        if hasattr(Fraction, "__int__"):
            __int__ = _delegate("__int__")

    _LoaderFunc = Callable[["ImageFileDirectory_v2", bytes, bool], Any]

    def _register_loader(idx: int, size: int) -> Callable[[_LoaderFunc], _LoaderFunc]:
        def decorator(func: _LoaderFunc) -> _LoaderFunc:
            from .TiffTags import TYPES

            if func.__name__.startswith("load_"):
                TYPES[idx] = func.__name__[5:].replace("_", " ")
            _load_dispatch[idx] = size, func  # noqa: F821
            return func

        return decorator

    def _register_writer(idx: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
            _write_dispatch[idx] = func  # noqa: F821
            return func

        return decorator

    def _register_basic(idx_fmt_name: tuple[int, str, str]) -> None:
        from .TiffTags import TYPES

        idx, fmt, name = idx_fmt_name
        TYPES[idx] = name
        size = struct.calcsize(f"={fmt}")

        def basic_handler(
            self: ImageFileDirectory_v2, data: bytes, legacy_api: bool = True
        ) -> tuple[Any, ...]:
            return self._unpack(f"{len(data) // size}{fmt}", data)

        _load_dispatch[idx] = size, basic_handler  # noqa: F821
        _write_dispatch[idx] = lambda self, *values: (  # noqa: F821
            b"".join(self._pack(fmt, value) for value in values)
        )

    if TYPE_CHECKING:
        _IFDv2Base = MutableMapping[int, Any]
    else:
        _IFDv2Base = MutableMapping

    class ImageFileDirectory_v2(_IFDv2Base):
        """This class represents a TIFF tag directory.  To speed things up, we
        don't decode tags unless they're asked for.

        Exposes a dictionary interface of the tags in the directory::

            ifd = ImageFileDirectory_v2()
            ifd[key] = 'Some Data'
            ifd.tagtype[key] = TiffTags.ASCII
            print(ifd[key])
            'Some Data'

        Individual values are returned as the strings or numbers, sequences are
        returned as tuples of the values.

        The tiff metadata type of each item is stored in a dictionary of
        tag types in
        :attr:`~PIL.TiffImagePlugin.ImageFileDirectory_v2.tagtype`. The types
        are read from a tiff file, guessed from the type added, or added
        manually.

        Data Structures:

            * ``self.tagtype = {}``

              * Key: numerical TIFF tag number
              * Value: integer corresponding to the data type from
                :py:data:`.TiffTags.TYPES`

              .. versionadded:: 3.0.0

        'Internal' data structures:

            * ``self._tags_v2 = {}``

              * Key: numerical TIFF tag number
              * Value: decoded data, as tuple for multiple values

            * ``self._tagdata = {}``

              * Key: numerical TIFF tag number
              * Value: undecoded byte string from file

            * ``self._tags_v1 = {}``

              * Key: numerical TIFF tag number
              * Value: decoded data in the v1 format

        Tags will be found in the private attributes ``self._tagdata``, and in
        ``self._tags_v2`` once decoded.

        ``self.legacy_api`` is a value for internal use, and shouldn't be changed
        from outside code. In cooperation with
        :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v1`, if ``legacy_api``
        is true, then decoded tags will be populated into both ``_tags_v1`` and
        ``_tags_v2``. ``_tags_v2`` will be used if this IFD is used in the TIFF
        save routine. Tags should be read from ``_tags_v1`` if
        ``legacy_api == true``.

        """

        _load_dispatch: dict[int, tuple[int, _LoaderFunc]] = {}
        _write_dispatch: dict[int, Callable[..., Any]] = {}

        def __init__(
            self,
            ifh: bytes = b"II\x2a\x00\x00\x00\x00\x00",
            prefix: bytes | None = None,
            group: int | None = None,
        ) -> None:
            """Initialize an ImageFileDirectory.

            To construct an ImageFileDirectory from a real file, pass the 8-byte
            magic header to the constructor.  To only set the endianness, pass it
            as the 'prefix' keyword argument.

            :param ifh: One of the accepted magic headers (cf. PREFIXES); also sets
                  endianness.
            :param prefix: Override the endianness of the file.
            """
            if not _accept(ifh):
                msg = f"not a TIFF file (header {repr(ifh)} not valid)"
                raise SyntaxError(msg)
            self._prefix = prefix if prefix is not None else ifh[:2]
            if self._prefix == MM:
                self._endian = ">"
            elif self._prefix == II:
                self._endian = "<"
            else:
                msg = "not a TIFF IFD"
                raise SyntaxError(msg)
            self._bigtiff = ifh[2] == 43
            self.group = group
            self.tagtype: dict[int, int] = {}
            """ Dictionary of tag types """
            self.reset()
            self.next = (
                self._unpack("Q", ifh[8:])[0]
                if self._bigtiff
                else self._unpack("L", ifh[4:])[0]
            )
            self._legacy_api = False

        prefix = property(lambda self: self._prefix)
        offset = property(lambda self: self._offset)

        @property
        def legacy_api(self) -> bool:
            return self._legacy_api

        @legacy_api.setter
        def legacy_api(self, value: bool) -> NoReturn:
            msg = "Not allowing setting of legacy api"
            raise Exception(msg)

        def reset(self) -> None:
            self._tags_v1: dict[int, Any] = {}  # will remain empty if legacy_api is false
            self._tags_v2: dict[int, Any] = {}  # main tag storage
            self._tagdata: dict[int, bytes] = {}
            self.tagtype = {}  # added 2008-06-05 by Florian Hoech
            self._next = None
            self._offset: int | None = None

        def __str__(self) -> str:
            return str(dict(self))

        def named(self) -> dict[str, Any]:
            """
            :returns: dict of name|key: value

            Returns the complete tag dictionary, with named tags where possible.
            """
            return {
                TiffTags.lookup(code, self.group).name: value
                for code, value in self.items()
            }

        def __len__(self) -> int:
            return len(set(self._tagdata) | set(self._tags_v2))

        def __getitem__(self, tag: int) -> Any:
            if tag not in self._tags_v2:  # unpack on the fly
                data = self._tagdata[tag]
                typ = self.tagtype[tag]
                size, handler = self._load_dispatch[typ]
                self[tag] = handler(self, data, self.legacy_api)  # check type
            val = self._tags_v2[tag]
            if self.legacy_api and not isinstance(val, (tuple, bytes)):
                val = (val,)
            return val

        def __contains__(self, tag: object) -> bool:
            return tag in self._tags_v2 or tag in self._tagdata

        def __setitem__(self, tag: int, value: Any) -> None:
            self._setitem(tag, value, self.legacy_api)

        def _setitem(self, tag: int, value: Any, legacy_api: bool) -> None:
            basetypes = (Number, bytes, str)

            info = TiffTags.lookup(tag, self.group)
            values = [value] if isinstance(value, basetypes) else value

            if tag not in self.tagtype:
                if info.type:
                    self.tagtype[tag] = info.type
                else:
                    self.tagtype[tag] = TiffTags.UNDEFINED
                    if all(isinstance(v, IFDRational) for v in values):
                        for v in values:
                            assert isinstance(v, IFDRational)
                            if v < 0:
                                self.tagtype[tag] = TiffTags.SIGNED_RATIONAL
                                break
                        else:
                            self.tagtype[tag] = TiffTags.RATIONAL
                    elif all(isinstance(v, int) for v in values):
                        short = True
                        signed_short = True
                        long = True
                        for v in values:
                            assert isinstance(v, int)
                            if short and not (0 <= v < 2**16):
                                short = False
                            if signed_short and not (-(2**15) < v < 2**15):
                                signed_short = False
                            if long and v < 0:
                                long = False
                        if short:
                            self.tagtype[tag] = TiffTags.SHORT
                        elif signed_short:
                            self.tagtype[tag] = TiffTags.SIGNED_SHORT
                        elif long:
                            self.tagtype[tag] = TiffTags.LONG
                        else:
                            self.tagtype[tag] = TiffTags.SIGNED_LONG
                    elif all(isinstance(v, float) for v in values):
                        self.tagtype[tag] = TiffTags.DOUBLE
                    elif all(isinstance(v, str) for v in values):
                        self.tagtype[tag] = TiffTags.ASCII
                    elif all(isinstance(v, bytes) for v in values):
                        self.tagtype[tag] = TiffTags.BYTE

            if self.tagtype[tag] == TiffTags.UNDEFINED:
                values = [
                    v.encode("ascii", "replace") if isinstance(v, str) else v
                    for v in values
                ]
            elif self.tagtype[tag] == TiffTags.RATIONAL:
                values = [float(v) if isinstance(v, int) else v for v in values]

            is_ifd = self.tagtype[tag] == TiffTags.LONG and isinstance(values, dict)
            if not is_ifd:
                values = tuple(
                    info.cvt_enum(value) if isinstance(value, str) else value
                    for value in values
                )

            dest = self._tags_v1 if legacy_api else self._tags_v2

            # Three branches:
            # Spec'd length == 1, Actual length 1, store as element
            # Spec'd length == 1, Actual > 1, Warn and truncate. Formerly barfed.
            # No Spec, Actual length 1, Formerly (<4.2) returned a 1 element tuple.
            # Don't mess with the legacy api, since it's frozen.
            if not is_ifd and (
                (info.length == 1)
                or self.tagtype[tag] == TiffTags.BYTE
                or (info.length is None and len(values) == 1 and not legacy_api)
            ):
                # Don't mess with the legacy api, since it's frozen.
                if legacy_api and self.tagtype[tag] in [
                    TiffTags.RATIONAL,
                    TiffTags.SIGNED_RATIONAL,
                ]:  # rationals
                    values = (values,)
                try:
                    (dest[tag],) = values
                except ValueError:
                    # We've got a builtin tag with 1 expected entry
                    warnings.warn(
                        f"Metadata Warning, tag {tag} had too many entries: "
                        f"{len(values)}, expected 1"
                    )
                    dest[tag] = values[0]

            else:
                # Spec'd length > 1 or undefined
                # Unspec'd, and length > 1
                dest[tag] = values

        def __delitem__(self, tag: int) -> None:
            self._tags_v2.pop(tag, None)
            self._tags_v1.pop(tag, None)
            self._tagdata.pop(tag, None)

        def __iter__(self) -> Iterator[int]:
            return iter(set(self._tagdata) | set(self._tags_v2))

        def _unpack(self, fmt: str, data: bytes) -> tuple[Any, ...]:
            return struct.unpack(self._endian + fmt, data)

        def _pack(self, fmt: str, *values: Any) -> bytes:
            return struct.pack(self._endian + fmt, *values)

        list(
            map(
                _register_basic,
                [
                    (TiffTags.SHORT, "H", "short"),
                    (TiffTags.LONG, "L", "long"),
                    (TiffTags.SIGNED_BYTE, "b", "signed byte"),
                    (TiffTags.SIGNED_SHORT, "h", "signed short"),
                    (TiffTags.SIGNED_LONG, "l", "signed long"),
                    (TiffTags.FLOAT, "f", "float"),
                    (TiffTags.DOUBLE, "d", "double"),
                    (TiffTags.IFD, "L", "long"),
                    (TiffTags.LONG8, "Q", "long8"),
                ],
            )
        )

        @_register_loader(1, 1)  # Basic type, except for the legacy API.
        def load_byte(self, data: bytes, legacy_api: bool = True) -> bytes:
            return data

        @_register_writer(1)  # Basic type, except for the legacy API.
        def write_byte(self, data: bytes | int | IFDRational) -> bytes:
            if isinstance(data, IFDRational):
                data = int(data)
            if isinstance(data, int):
                data = bytes((data,))
            return data

        @_register_loader(2, 1)
        def load_string(self, data: bytes, legacy_api: bool = True) -> str:
            if data.endswith(b"\0"):
                data = data[:-1]
            return data.decode("latin-1", "replace")

        @_register_writer(2)
        def write_string(self, value: str | bytes | int) -> bytes:
            # remerge of https://github.com/python-pillow/Pillow/pull/1416
            if isinstance(value, int):
                value = str(value)
            if not isinstance(value, bytes):
                value = value.encode("ascii", "replace")
            return value + b"\0"

        @_register_loader(5, 8)
        def load_rational(
            self, data: bytes, legacy_api: bool = True
        ) -> tuple[tuple[int, int] | IFDRational, ...]:
            vals = self._unpack(f"{len(data) // 4}L", data)

            def combine(a: int, b: int) -> tuple[int, int] | IFDRational:
                return (a, b) if legacy_api else IFDRational(a, b)

            return tuple(combine(num, denom) for num, denom in zip(vals[::2], vals[1::2]))

        @_register_writer(5)
        def write_rational(self, *values: IFDRational) -> bytes:
            return b"".join(
                self._pack("2L", *_limit_rational(frac, 2**32 - 1)) for frac in values
            )

        @_register_loader(7, 1)
        def load_undefined(self, data: bytes, legacy_api: bool = True) -> bytes:
            return data

        @_register_writer(7)
        def write_undefined(self, value: bytes | int | IFDRational) -> bytes:
            if isinstance(value, IFDRational):
                value = int(value)
            if isinstance(value, int):
                value = str(value).encode("ascii", "replace")
            return value

        @_register_loader(10, 8)
        def load_signed_rational(
            self, data: bytes, legacy_api: bool = True
        ) -> tuple[tuple[int, int] | IFDRational, ...]:
            vals = self._unpack(f"{len(data) // 4}l", data)

            def combine(a: int, b: int) -> tuple[int, int] | IFDRational:
                return (a, b) if legacy_api else IFDRational(a, b)

            return tuple(combine(num, denom) for num, denom in zip(vals[::2], vals[1::2]))

        @_register_writer(10)
        def write_signed_rational(self, *values: IFDRational) -> bytes:
            return b"".join(
                self._pack("2l", *_limit_signed_rational(frac, 2**31 - 1, -(2**31)))
                for frac in values
            )

        def _ensure_read(self, fp: IO[bytes], size: int) -> bytes:
            ret = fp.read(size)
            if len(ret) != size:
                msg = (
                    "Corrupt EXIF data.  "
                    f"Expecting to read {size} bytes but only got {len(ret)}. "
                )
                raise OSError(msg)
            return ret

        def load(self, fp: IO[bytes]) -> None:
            self.reset()
            self._offset = fp.tell()

            try:
                tag_count = (
                    self._unpack("Q", self._ensure_read(fp, 8))
                    if self._bigtiff
                    else self._unpack("H", self._ensure_read(fp, 2))
                )[0]
                for i in range(tag_count):
                    tag, typ, count, data = (
                        self._unpack("HHQ8s", self._ensure_read(fp, 20))
                        if self._bigtiff
                        else self._unpack("HHL4s", self._ensure_read(fp, 12))
                    )

                    tagname = TiffTags.lookup(tag, self.group).name
                    typname = TYPES.get(typ, "unknown")
                    msg = f"tag: {tagname} ({tag}) - type: {typname} ({typ})"

                    try:
                        unit_size, handler = self._load_dispatch[typ]
                    except KeyError:
                        logger.debug("%s - unsupported type %s", msg, typ)
                        continue  # ignore unsupported type
                    size = count * unit_size
                    if size > (8 if self._bigtiff else 4):
                        here = fp.tell()
                        (offset,) = self._unpack("Q" if self._bigtiff else "L", data)
                        msg += f" Tag Location: {here} - Data Location: {offset}"
                        fp.seek(offset)
                        data = ImageFile._safe_read(fp, size)
                        fp.seek(here)
                    else:
                        data = data[:size]

                    if len(data) != size:
                        warnings.warn(
                            "Possibly corrupt EXIF data.  "
                            f"Expecting to read {size} bytes but only got {len(data)}."
                            f" Skipping tag {tag}"
                        )
                        logger.debug(msg)
                        continue

                    if not data:
                        logger.debug(msg)
                        continue

                    self._tagdata[tag] = data
                    self.tagtype[tag] = typ

                    msg += " - value: "
                    msg += f"<table: {size} bytes>" if size > 32 else repr(data)

                    logger.debug(msg)

                (self.next,) = (
                    self._unpack("Q", self._ensure_read(fp, 8))
                    if self._bigtiff
                    else self._unpack("L", self._ensure_read(fp, 4))
                )
            except OSError as msg:
                warnings.warn(str(msg))
                return

        def _get_ifh(self) -> bytes:
            ifh = self._prefix + self._pack("H", 43 if self._bigtiff else 42)
            if self._bigtiff:
                ifh += self._pack("HH", 8, 0)
            ifh += self._pack("Q", 16) if self._bigtiff else self._pack("L", 8)

            return ifh

        def tobytes(self, offset: int = 0) -> bytes:
            # FIXME What about tagdata?
            result = self._pack("Q" if self._bigtiff else "H", len(self._tags_v2))

            entries: list[tuple[int, int, int, bytes, bytes]] = []

            fmt = "Q" if self._bigtiff else "L"
            fmt_size = 8 if self._bigtiff else 4
            offset += (
                len(result) + len(self._tags_v2) * (20 if self._bigtiff else 12) + fmt_size
            )
            stripoffsets = None

            # pass 1: convert tags to binary format
            # always write tags in ascending order
            for tag, value in sorted(self._tags_v2.items()):
                if tag == STRIPOFFSETS:
                    stripoffsets = len(entries)
                typ = self.tagtype[tag]
                logger.debug("Tag %s, Type: %s, Value: %s", tag, typ, repr(value))
                is_ifd = typ == TiffTags.LONG and isinstance(value, dict)
                if is_ifd:
                    ifd = ImageFileDirectory_v2(self._get_ifh(), group=tag)
                    values = self._tags_v2[tag]
                    for ifd_tag, ifd_value in values.items():
                        ifd[ifd_tag] = ifd_value
                    data = ifd.tobytes(offset)
                else:
                    values = value if isinstance(value, tuple) else (value,)
                    data = self._write_dispatch[typ](self, *values)

                tagname = TiffTags.lookup(tag, self.group).name
                typname = "ifd" if is_ifd else TYPES.get(typ, "unknown")
                msg = f"save: {tagname} ({tag}) - type: {typname} ({typ}) - value: "
                msg += f"<table: {len(data)} bytes>" if len(data) >= 16 else str(values)
                logger.debug(msg)

                # count is sum of lengths for string and arbitrary data
                if is_ifd:
                    count = 1
                elif typ in [TiffTags.BYTE, TiffTags.ASCII, TiffTags.UNDEFINED]:
                    count = len(data)
                else:
                    count = len(values)
                # figure out if data fits into the entry
                if len(data) <= fmt_size:
                    entries.append((tag, typ, count, data.ljust(fmt_size, b"\0"), b""))
                else:
                    entries.append((tag, typ, count, self._pack(fmt, offset), data))
                    offset += (len(data) + 1) // 2 * 2  # pad to word

            # update strip offset data to point beyond auxiliary data
            if stripoffsets is not None:
                tag, typ, count, value, data = entries[stripoffsets]
                if data:
                    size, handler = self._load_dispatch[typ]
                    values = [val + offset for val in handler(self, data, self.legacy_api)]
                    data = self._write_dispatch[typ](self, *values)
                else:
                    value = self._pack(fmt, self._unpack(fmt, value)[0] + offset)
                entries[stripoffsets] = tag, typ, count, value, data

            # pass 2: write entries to file
            for tag, typ, count, value, data in entries:
                logger.debug("%s %s %s %s %s", tag, typ, count, repr(value), repr(data))
                result += self._pack(
                    "HHQ8s" if self._bigtiff else "HHL4s", tag, typ, count, value
                )

            # -- overwrite here for multi-page --
            result += self._pack(fmt, 0)  # end of entries

            # pass 3: write auxiliary data to file
            for tag, typ, count, value, data in entries:
                result += data
                if len(data) & 1:
                    result += b"\0"

            return result

        def save(self, fp: IO[bytes]) -> int:
            if fp.tell() == 0:  # skip TIFF header on subsequent pages
                fp.write(self._get_ifh())

            offset = fp.tell()
            result = self.tobytes(offset)
            fp.write(result)
            return offset + len(result)

    ImageFileDirectory_v2._load_dispatch = _load_dispatch
    ImageFileDirectory_v2._write_dispatch = _write_dispatch
    for idx, name in TYPES.items():
        name = name.replace(" ", "_")
        setattr(ImageFileDirectory_v2, f"load_{name}", _load_dispatch[idx][1])
        setattr(ImageFileDirectory_v2, f"write_{name}", _write_dispatch[idx])
    del _load_dispatch, _write_dispatch, idx, name

    # Legacy ImageFileDirectory support.

    class ImageFileDirectory_v1(ImageFileDirectory_v2):
        """This class represents the **legacy** interface to a TIFF tag directory.

        Exposes a dictionary interface of the tags in the directory::

            ifd = ImageFileDirectory_v1()
            ifd[key] = 'Some Data'
            ifd.tagtype[key] = TiffTags.ASCII
            print(ifd[key])
            ('Some Data',)

        Also contains a dictionary of tag types as read from the tiff image file,
        :attr:`~PIL.TiffImagePlugin.ImageFileDirectory_v1.tagtype`.

        Values are returned as a tuple.

        ..  deprecated:: 3.0.0
        """

        def __init__(self, *args: Any, **kwargs: Any) -> None:
            super().__init__(*args, **kwargs)
            self._legacy_api = True

        tags = property(lambda self: self._tags_v1)
        tagdata = property(lambda self: self._tagdata)

        # defined in ImageFileDirectory_v2
        tagtype: dict[int, int]
        """Dictionary of tag types"""

        @classmethod
        def from_v2(cls, original: ImageFileDirectory_v2) -> ImageFileDirectory_v1:
            """Returns an
            :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v1`
            instance with the same data as is contained in the original
            :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v2`
            instance.

            :returns: :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v1`

            """

            ifd = cls(prefix=original.prefix)
            ifd._tagdata = original._tagdata
            ifd.tagtype = original.tagtype
            ifd.next = original.next  # an indicator for multipage tiffs
            return ifd

        def to_v2(self) -> ImageFileDirectory_v2:
            """Returns an
            :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v2`
            instance with the same data as is contained in the original
            :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v1`
            instance.

            :returns: :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v2`

            """

            ifd = ImageFileDirectory_v2(prefix=self.prefix)
            ifd._tagdata = dict(self._tagdata)
            ifd.tagtype = dict(self.tagtype)
            ifd._tags_v2 = dict(self._tags_v2)
            return ifd

        def __contains__(self, tag: object) -> bool:
            return tag in self._tags_v1 or tag in self._tagdata

        def __len__(self) -> int:
            return len(set(self._tagdata) | set(self._tags_v1))

        def __iter__(self) -> Iterator[int]:
            return iter(set(self._tagdata) | set(self._tags_v1))

        def __setitem__(self, tag: int, value: Any) -> None:
            for legacy_api in (False, True):
                self._setitem(tag, value, legacy_api)

        def __getitem__(self, tag: int) -> Any:
            if tag not in self._tags_v1:  # unpack on the fly
                data = self._tagdata[tag]
                typ = self.tagtype[tag]
                size, handler = self._load_dispatch[typ]
                for legacy in (False, True):
                    self._setitem(tag, handler(self, data, legacy), legacy)
            val = self._tags_v1[tag]
            if not isinstance(val, (tuple, bytes)):
                val = (val,)
            return val

    # undone -- switch this pointer
    ImageFileDirectory = ImageFileDirectory_v1

    ##
    # Image plugin for TIFF files.

    class TiffImageFile(ImageFile.ImageFile):
        format = "TIFF"
        format_description = "Adobe TIFF"
        _close_exclusive_fp_after_loading = False

        def __init__(
            self,
            fp: StrOrBytesPath | IO[bytes],
            filename: str | bytes | None = None,
        ) -> None:
            self.tag_v2: ImageFileDirectory_v2
            """ Image file directory (tag dictionary) """

            self.tag: ImageFileDirectory_v1
            """ Legacy tag entries """

            super().__init__(fp, filename)

        def _open(self) -> None:
            """Open the first image in a TIFF file"""

            # Header
            ifh = self.fp.read(8)
            if ifh[2] == 43:
                ifh += self.fp.read(8)

            self.tag_v2 = ImageFileDirectory_v2(ifh)

            # setup frame pointers
            self.__first = self.__next = self.tag_v2.next
            self.__frame = -1
            self._fp = self.fp
            self._frame_pos: list[int] = []
            self._n_frames: int | None = None

            logger.debug("*** TiffImageFile._open ***")
            logger.debug("- __first: %s", self.__first)
            logger.debug("- ifh: %s", repr(ifh))  # Use repr to avoid str(bytes)

            # and load the first frame
            self._seek(0)

        @property
        def n_frames(self) -> int:
            current_n_frames = self._n_frames
            if current_n_frames is None:
                current = self.tell()
                self._seek(len(self._frame_pos))
                while self._n_frames is None:
                    self._seek(self.tell() + 1)
                self.seek(current)
            assert self._n_frames is not None
            return self._n_frames

        def seek(self, frame: int) -> None:
            """Select a given frame as current image"""
            if not self._seek_check(frame):
                return
            self._seek(frame)
            if self._im is not None and (
                self.im.size != self._tile_size
                or self.im.mode != self.mode
                or self.readonly
            ):
                self._im = None

        def _seek(self, frame: int) -> None:
            if isinstance(self._fp, DeferredError):
                raise self._fp.ex
            self.fp = self._fp

            while len(self._frame_pos) <= frame:
                if not self.__next:
                    msg = "no more images in TIFF file"
                    raise EOFError(msg)
                logger.debug(
                    "Seeking to frame %s, on frame %s, __next %s, location: %s",
                    frame,
                    self.__frame,
                    self.__next,
                    self.fp.tell(),
                )
                if self.__next >= 2**63:
                    msg = "Unable to seek to frame"
                    raise ValueError(msg)
                self.fp.seek(self.__next)
                self._frame_pos.append(self.__next)
                logger.debug("Loading tags, location: %s", self.fp.tell())
                self.tag_v2.load(self.fp)
                if self.tag_v2.next in self._frame_pos:
                    # This IFD has already been processed
                    # Declare this to be the end of the image
                    self.__next = 0
                else:
                    self.__next = self.tag_v2.next
                if self.__next == 0:
                    self._n_frames = frame + 1
                if len(self._frame_pos) == 1:
                    self.is_animated = self.__next != 0
                self.__frame += 1
            self.fp.seek(self._frame_pos[frame])
            self.tag_v2.load(self.fp)
            if XMP in self.tag_v2:
                xmp = self.tag_v2[XMP]
                if isinstance(xmp, tuple) and len(xmp) == 1:
                    xmp = xmp[0]
                self.info["xmp"] = xmp
            elif "xmp" in self.info:
                del self.info["xmp"]
            self._reload_exif()
            # fill the legacy tag/ifd entries
            self.tag = self.ifd = ImageFileDirectory_v1.from_v2(self.tag_v2)
            self.__frame = frame
            self._setup()

        def tell(self) -> int:
            """Return the current frame number"""
            return self.__frame

        def get_photoshop_blocks(self) -> dict[int, dict[str, bytes]]:
            """
            Returns a dictionary of Photoshop "Image Resource Blocks".
            The keys are the image resource ID. For more information, see
            https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577409_pgfId-1037727

            :returns: Photoshop "Image Resource Blocks" in a dictionary.
            """
            blocks = {}
            val = self.tag_v2.get(ExifTags.Base.ImageResources)
            if val:
                while val.startswith(b"8BIM"):
                    id = i16(val[4:6])
                    n = math.ceil((val[6] + 1) / 2) * 2
                    size = i32(val[6 + n : 10 + n])
                    data = val[10 + n : 10 + n + size]
                    blocks[id] = {"data": data}

                    val = val[math.ceil((10 + n + size) / 2) * 2 :]
            return blocks

        def load(self) -> Image.core.PixelAccess | None:
            if self.tile and self.use_load_libtiff:
                return self._load_libtiff()
            return super().load()

        def load_prepare(self) -> None:
            if self._im is None:
                Image._decompression_bomb_check(self._tile_size)
                self.im = Image.core.new(self.mode, self._tile_size)
            ImageFile.ImageFile.load_prepare(self)

        def load_end(self) -> None:
            # allow closing if we're on the first frame, there's no next
            # This is the ImageFile.load path only, libtiff specific below.
            if not self.is_animated:
                self._close_exclusive_fp_after_loading = True

                # load IFD data from fp before it is closed
                exif = self.getexif()
                for key in TiffTags.TAGS_V2_GROUPS:
                    if key not in exif:
                        continue
                    exif.get_ifd(key)

            ImageOps.exif_transpose(self, in_place=True)
            if ExifTags.Base.Orientation in self.tag_v2:
                del self.tag_v2[ExifTags.Base.Orientation]

        def _load_libtiff(self) -> Image.core.PixelAccess | None:
            """Overload method triggered when we detect a compressed tiff
            Calls out to libtiff"""

            Image.Image.load(self)

            self.load_prepare()

            if not len(self.tile) == 1:
                msg = "Not exactly one tile"
                raise OSError(msg)

            # (self._compression, (extents tuple),
            #   0, (rawmode, self._compression, fp))
            extents = self.tile[0][1]
            args = self.tile[0][3]

            # To be nice on memory footprint, if there's a
            # file descriptor, use that instead of reading
            # into a string in python.
            try:
                fp = hasattr(self.fp, "fileno") and self.fp.fileno()
                # flush the file descriptor, prevents error on pypy 2.4+
                # should also eliminate the need for fp.tell
                # in _seek
                if hasattr(self.fp, "flush"):
                    self.fp.flush()
            except OSError:
                # io.BytesIO have a fileno, but returns an OSError if
                # it doesn't use a file descriptor.
                fp = False

            if fp:
                assert isinstance(args, tuple)
                args_list = list(args)
                args_list[2] = fp
                args = tuple(args_list)

            decoder = Image._getdecoder(self.mode, "libtiff", args, self.decoderconfig)
            try:
                decoder.setimage(self.im, extents)
            except ValueError as e:
                msg = "Couldn't set the image"
                raise OSError(msg) from e

            close_self_fp = self._exclusive_fp and not self.is_animated
            if hasattr(self.fp, "getvalue"):
                # We've got a stringio like thing passed in. Yay for all in memory.
                # The decoder needs the entire file in one shot, so there's not
                # a lot we can do here other than give it the entire file.
                # unless we could do something like get the address of the
                # underlying string for stringio.
                #
                # Rearranging for supporting byteio items, since they have a fileno
                # that returns an OSError if there's no underlying fp. Easier to
                # deal with here by reordering.
                logger.debug("have getvalue. just sending in a string from getvalue")
                n, err = decoder.decode(self.fp.getvalue())
            elif fp:
                # we've got a actual file on disk, pass in the fp.
                logger.debug("have fileno, calling fileno version of the decoder.")
                if not close_self_fp:
                    self.fp.seek(0)
                # Save and restore the file position, because libtiff will move it
                # outside of the Python runtime, and that will confuse
                # io.BufferedReader and possible others.
                # NOTE: This must use os.lseek(), and not fp.tell()/fp.seek(),
                # because the buffer read head already may not equal the actual
                # file position, and fp.seek() may just adjust it's internal
                # pointer and not actually seek the OS file handle.
                pos = os.lseek(fp, 0, os.SEEK_CUR)
                # 4 bytes, otherwise the trace might error out
                n, err = decoder.decode(b"fpfp")
                os.lseek(fp, pos, os.SEEK_SET)
            else:
                # we have something else.
                logger.debug("don't have fileno or getvalue. just reading")
                self.fp.seek(0)
                # UNDONE -- so much for that buffer size thing.
                n, err = decoder.decode(self.fp.read())

            self.tile = []
            self.readonly = 0

            self.load_end()

            if close_self_fp:
                self.fp.close()
                self.fp = None  # might be shared

            if err < 0:
                msg = f"decoder error {err}"
                raise OSError(msg)

            return Image.Image.load(self)

        def _setup(self) -> None:
            """Setup this image object based on current tags"""

            if 0xBC01 in self.tag_v2:
                msg = "Windows Media Photo files not yet supported"
                raise OSError(msg)

            # extract relevant tags
            self._compression = COMPRESSION_INFO[self.tag_v2.get(COMPRESSION, 1)]
            self._planar_configuration = self.tag_v2.get(PLANAR_CONFIGURATION, 1)

            # photometric is a required tag, but not everyone is reading
            # the specification
            photo = self.tag_v2.get(PHOTOMETRIC_INTERPRETATION, 0)

            # old style jpeg compression images most certainly are YCbCr
            if self._compression == "tiff_jpeg":
                photo = 6

            fillorder = self.tag_v2.get(FILLORDER, 1)

            logger.debug("*** Summary ***")
            logger.debug("- compression: %s", self._compression)
            logger.debug("- photometric_interpretation: %s", photo)
            logger.debug("- planar_configuration: %s", self._planar_configuration)
            logger.debug("- fill_order: %s", fillorder)
            logger.debug("- YCbCr subsampling: %s", self.tag_v2.get(YCBCRSUBSAMPLING))

            # size
            try:
                xsize = self.tag_v2[IMAGEWIDTH]
                ysize = self.tag_v2[IMAGELENGTH]
            except KeyError as e:
                msg = "Missing dimensions"
                raise TypeError(msg) from e
            if not isinstance(xsize, int) or not isinstance(ysize, int):
                msg = "Invalid dimensions"
                raise ValueError(msg)
            self._tile_size = xsize, ysize
            orientation = self.tag_v2.get(ExifTags.Base.Orientation)
            if orientation in (5, 6, 7, 8):
                self._size = ysize, xsize
            else:
                self._size = xsize, ysize

            logger.debug("- size: %s", self.size)

            sample_format = self.tag_v2.get(SAMPLEFORMAT, (1,))
            if len(sample_format) > 1 and max(sample_format) == min(sample_format) == 1:
                # SAMPLEFORMAT is properly per band, so an RGB image will
                # be (1,1,1).  But, we don't support per band pixel types,
                # and anything more than one band is a uint8. So, just
                # take the first element. Revisit this if adding support
                # for more exotic images.
                sample_format = (1,)

            bps_tuple = self.tag_v2.get(BITSPERSAMPLE, (1,))
            extra_tuple = self.tag_v2.get(EXTRASAMPLES, ())
            if photo in (2, 6, 8):  # RGB, YCbCr, LAB
                bps_count = 3
            elif photo == 5:  # CMYK
                bps_count = 4
            else:
                bps_count = 1
            bps_count += len(extra_tuple)
            bps_actual_count = len(bps_tuple)
            samples_per_pixel = self.tag_v2.get(
                SAMPLESPERPIXEL,
                3 if self._compression == "tiff_jpeg" and photo in (2, 6) else 1,
            )

            if samples_per_pixel > MAX_SAMPLESPERPIXEL:
                # DOS check, samples_per_pixel can be a Long, and we extend the tuple below
                logger.error(
                    "More samples per pixel than can be decoded: %s", samples_per_pixel
                )
                msg = "Invalid value for samples per pixel"
                raise SyntaxError(msg)

            if samples_per_pixel < bps_actual_count:
                # If a file has more values in bps_tuple than expected,
                # remove the excess.
                bps_tuple = bps_tuple[:samples_per_pixel]
            elif samples_per_pixel > bps_actual_count and bps_actual_count == 1:
                # If a file has only one value in bps_tuple, when it should have more,
                # presume it is the same number of bits for all of the samples.
                bps_tuple = bps_tuple * samples_per_pixel

            if len(bps_tuple) != samples_per_pixel:
                msg = "unknown data organization"
                raise SyntaxError(msg)

            # mode: check photometric interpretation and bits per pixel
            key = (
                self.tag_v2.prefix,
                photo,
                sample_format,
                fillorder,
                bps_tuple,
                extra_tuple,
            )
            logger.debug("format key: %s", key)
            try:
                self._mode, rawmode = OPEN_INFO[key]
            except KeyError as e:
                logger.debug("- unsupported format")
                msg = "unknown pixel mode"
                raise SyntaxError(msg) from e

            logger.debug("- raw mode: %s", rawmode)
            logger.debug("- pil mode: %s", self.mode)

            self.info["compression"] = self._compression

            xres = self.tag_v2.get(X_RESOLUTION, 1)
            yres = self.tag_v2.get(Y_RESOLUTION, 1)

            if xres and yres:
                resunit = self.tag_v2.get(RESOLUTION_UNIT)
                if resunit == 2:  # dots per inch
                    self.info["dpi"] = (xres, yres)
                elif resunit == 3:  # dots per centimeter. convert to dpi
                    self.info["dpi"] = (xres * 2.54, yres * 2.54)
                elif resunit is None:  # used to default to 1, but now 2)
                    self.info["dpi"] = (xres, yres)
                    # For backward compatibility,
                    # we also preserve the old behavior
                    self.info["resolution"] = xres, yres
                else:  # No absolute unit of measurement
                    self.info["resolution"] = xres, yres

            # build tile descriptors
            x = y = layer = 0
            self.tile = []
            self.use_load_libtiff = READ_LIBTIFF or self._compression != "raw"
            if self.use_load_libtiff:
                # Decoder expects entire file as one tile.
                # There's a buffer size limit in load (64k)
                # so large g4 images will fail if we use that
                # function.
                #
                # Setup the one tile for the whole image, then
                # use the _load_libtiff function.

                # libtiff handles the fillmode for us, so 1;IR should
                # actually be 1;I. Including the R double reverses the
                # bits, so stripes of the image are reversed.  See
                # https://github.com/python-pillow/Pillow/issues/279
                if fillorder == 2:
                    # Replace fillorder with fillorder=1
                    key = key[:3] + (1,) + key[4:]
                    logger.debug("format key: %s", key)
                    # this should always work, since all the
                    # fillorder==2 modes have a corresponding
                    # fillorder=1 mode
                    self._mode, rawmode = OPEN_INFO[key]
                # YCbCr images with new jpeg compression with pixels in one plane
                # unpacked straight into RGB values
                if (
                    photo == 6
                    and self._compression == "jpeg"
                    and self._planar_configuration == 1
                ):
                    rawmode = "RGB"
                # libtiff always returns the bytes in native order.
                # we're expecting image byte order. So, if the rawmode
                # contains I;16, we need to convert from native to image
                # byte order.
                elif rawmode == "I;16":
                    rawmode = "I;16N"
                elif rawmode.endswith((";16B", ";16L")):
                    rawmode = rawmode[:-1] + "N"

                # Offset in the tile tuple is 0, we go from 0,0 to
                # w,h, and we only do this once -- eds
                a = (rawmode, self._compression, False, self.tag_v2.offset)
                self.tile.append(ImageFile._Tile("libtiff", (0, 0, xsize, ysize), 0, a))

            elif STRIPOFFSETS in self.tag_v2 or TILEOFFSETS in self.tag_v2:
                # striped image
                if STRIPOFFSETS in self.tag_v2:
                    offsets = self.tag_v2[STRIPOFFSETS]
                    h = self.tag_v2.get(ROWSPERSTRIP, ysize)
                    w = xsize
                else:
                    # tiled image
                    offsets = self.tag_v2[TILEOFFSETS]
                    tilewidth = self.tag_v2.get(TILEWIDTH)
                    h = self.tag_v2.get(TILELENGTH)
                    if not isinstance(tilewidth, int) or not isinstance(h, int):
                        msg = "Invalid tile dimensions"
                        raise ValueError(msg)
                    w = tilewidth

                if w == xsize and h == ysize and self._planar_configuration != 2:
                    # Every tile covers the image. Only use the last offset
                    offsets = offsets[-1:]

                for offset in offsets:
                    if x + w > xsize:
                        stride = w * sum(bps_tuple) / 8  # bytes per line
                    else:
                        stride = 0

                    tile_rawmode = rawmode
                    if self._planar_configuration == 2:
                        # each band on it's own layer
                        tile_rawmode = rawmode[layer]
                        # adjust stride width accordingly
                        stride /= bps_count

                    args = (tile_rawmode, int(stride), 1)
                    self.tile.append(
                        ImageFile._Tile(
                            self._compression,
                            (x, y, min(x + w, xsize), min(y + h, ysize)),
                            offset,
                            args,
                        )
                    )
                    x += w
                    if x >= xsize:
                        x, y = 0, y + h
                        if y >= ysize:
                            y = 0
                            layer += 1
            else:
                logger.debug("- unsupported data organization")
                msg = "unknown data organization"
                raise SyntaxError(msg)

            # Fix up info.
            if ICCPROFILE in self.tag_v2:
                self.info["icc_profile"] = self.tag_v2[ICCPROFILE]

            # fixup palette descriptor

            if self.mode in ["P", "PA"]:
                palette = [o8(b // 256) for b in self.tag_v2[COLORMAP]]
                self.palette = ImagePalette.raw("RGB;L", b"".join(palette))

    #
    # --------------------------------------------------------------------
    # Write TIFF files

    # little endian is default except for image modes with
    # explicit big endian byte-order

    SAVE_INFO = {
        # mode => rawmode, byteorder, photometrics,
        #           sampleformat, bitspersample, extra
        "1": ("1", II, 1, 1, (1,), None),
        "L": ("L", II, 1, 1, (8,), None),
        "LA": ("LA", II, 1, 1, (8, 8), 2),
        "P": ("P", II, 3, 1, (8,), None),
        "PA": ("PA", II, 3, 1, (8, 8), 2),
        "I": ("I;32S", II, 1, 2, (32,), None),
        "I;16": ("I;16", II, 1, 1, (16,), None),
        "I;16L": ("I;16L", II, 1, 1, (16,), None),
        "F": ("F;32F", II, 1, 3, (32,), None),
        "RGB": ("RGB", II, 2, 1, (8, 8, 8), None),
        "RGBX": ("RGBX", II, 2, 1, (8, 8, 8, 8), 0),
        "RGBA": ("RGBA", II, 2, 1, (8, 8, 8, 8), 2),
        "CMYK": ("CMYK", II, 5, 1, (8, 8, 8, 8), None),
        "YCbCr": ("YCbCr", II, 6, 1, (8, 8, 8), None),
        "LAB": ("LAB", II, 8, 1, (8, 8, 8), None),
        "I;16B": ("I;16B", MM, 1, 1, (16,), None),
    }

    def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
        try:
            rawmode, prefix, photo, format, bits, extra = SAVE_INFO[im.mode]
        except KeyError as e:
            msg = f"cannot write mode {im.mode} as TIFF"
            raise OSError(msg) from e

        encoderinfo = im.encoderinfo
        encoderconfig = im.encoderconfig

        ifd = ImageFileDirectory_v2(prefix=prefix)
        if encoderinfo.get("big_tiff"):
            ifd._bigtiff = True

        try:
            compression = encoderinfo["compression"]
        except KeyError:
            compression = im.info.get("compression")
            if isinstance(compression, int):
                # compression value may be from BMP. Ignore it
                compression = None
        if compression is None:
            compression = "raw"
        elif compression == "tiff_jpeg":
            # OJPEG is obsolete, so use new-style JPEG compression instead
            compression = "jpeg"
        elif compression == "tiff_deflate":
            compression = "tiff_adobe_deflate"

        libtiff = WRITE_LIBTIFF or compression != "raw"

        # required for color libtiff images
        ifd[PLANAR_CONFIGURATION] = 1

        ifd[IMAGEWIDTH] = im.size[0]
        ifd[IMAGELENGTH] = im.size[1]

        # write any arbitrary tags passed in as an ImageFileDirectory
        if "tiffinfo" in encoderinfo:
            info = encoderinfo["tiffinfo"]
        elif "exif" in encoderinfo:
            info = encoderinfo["exif"]
            if isinstance(info, bytes):
                exif = Image.Exif()
                exif.load(info)
                info = exif
        else:
            info = {}
        logger.debug("Tiffinfo Keys: %s", list(info))
        if isinstance(info, ImageFileDirectory_v1):
            info = info.to_v2()
        for key in info:
            if isinstance(info, Image.Exif) and key in TiffTags.TAGS_V2_GROUPS:
                ifd[key] = info.get_ifd(key)
            else:
                ifd[key] = info.get(key)
            try:
                ifd.tagtype[key] = info.tagtype[key]
            except Exception:
                pass  # might not be an IFD. Might not have populated type

        legacy_ifd = {}
        if hasattr(im, "tag"):
            legacy_ifd = im.tag.to_v2()

        supplied_tags = {**legacy_ifd, **getattr(im, "tag_v2", {})}
        for tag in (
            # IFD offset that may not be correct in the saved image
            EXIFIFD,
            # Determined by the image format and should not be copied from legacy_ifd.
            SAMPLEFORMAT,
        ):
            if tag in supplied_tags:
                del supplied_tags[tag]

        # additions written by Greg Couch, gregc@cgl.ucsf.edu
        # inspired by image-sig posting from Kevin Cazabon, kcazabon@home.com
        if hasattr(im, "tag_v2"):
            # preserve tags from original TIFF image file
            for key in (
                RESOLUTION_UNIT,
                X_RESOLUTION,
                Y_RESOLUTION,
                IPTC_NAA_CHUNK,
                PHOTOSHOP_CHUNK,
                XMP,
            ):
                if key in im.tag_v2:
                    if key == IPTC_NAA_CHUNK and im.tag_v2.tagtype[key] not in (
                        TiffTags.BYTE,
                        TiffTags.UNDEFINED,
                    ):
                        del supplied_tags[key]
                    else:
                        ifd[key] = im.tag_v2[key]
                        ifd.tagtype[key] = im.tag_v2.tagtype[key]

        # preserve ICC profile (should also work when saving other formats
        # which support profiles as TIFF) -- 2008-06-06 Florian Hoech
        icc = encoderinfo.get("icc_profile", im.info.get("icc_profile"))
        if icc:
            ifd[ICCPROFILE] = icc

        for key, name in [
            (IMAGEDESCRIPTION, "description"),
            (X_RESOLUTION, "resolution"),
            (Y_RESOLUTION, "resolution"),
            (X_RESOLUTION, "x_resolution"),
            (Y_RESOLUTION, "y_resolution"),
            (RESOLUTION_UNIT, "resolution_unit"),
            (SOFTWARE, "software"),
            (DATE_TIME, "date_time"),
            (ARTIST, "artist"),
            (COPYRIGHT, "copyright"),
        ]:
            if name in encoderinfo:
                ifd[key] = encoderinfo[name]

        dpi = encoderinfo.get("dpi")
        if dpi:
            ifd[RESOLUTION_UNIT] = 2
            ifd[X_RESOLUTION] = dpi[0]
            ifd[Y_RESOLUTION] = dpi[1]

        if bits != (1,):
            ifd[BITSPERSAMPLE] = bits
            if len(bits) != 1:
                ifd[SAMPLESPERPIXEL] = len(bits)
        if extra is not None:
            ifd[EXTRASAMPLES] = extra
        if format != 1:
            ifd[SAMPLEFORMAT] = format

        if PHOTOMETRIC_INTERPRETATION not in ifd:
            ifd[PHOTOMETRIC_INTERPRETATION] = photo
        elif im.mode in ("1", "L") and ifd[PHOTOMETRIC_INTERPRETATION] == 0:
            if im.mode == "1":
                inverted_im = im.copy()
                px = inverted_im.load()
                if px is not None:
                    for y in range(inverted_im.height):
                        for x in range(inverted_im.width):
                            px[x, y] = 0 if px[x, y] == 255 else 255
                    im = inverted_im
            else:
                im = ImageOps.invert(im)

        if im.mode in ["P", "PA"]:
            lut = im.im.getpalette("RGB", "RGB;L")
            colormap = []
            colors = len(lut) // 3
            for i in range(3):
                colormap += [v * 256 for v in lut[colors * i : colors * (i + 1)]]
                colormap += [0] * (256 - colors)
            ifd[COLORMAP] = colormap
        # data orientation
        w, h = ifd[IMAGEWIDTH], ifd[IMAGELENGTH]
        stride = len(bits) * ((w * bits[0] + 7) // 8)
        if ROWSPERSTRIP not in ifd:
            # aim for given strip size (64 KB by default) when using libtiff writer
            if libtiff:
                im_strip_size = encoderinfo.get("strip_size", STRIP_SIZE)
                rows_per_strip = 1 if stride == 0 else min(im_strip_size // stride, h)
                # JPEG encoder expects multiple of 8 rows
                if compression == "jpeg":
                    rows_per_strip = min(((rows_per_strip + 7) // 8) * 8, h)
            else:
                rows_per_strip = h
            if rows_per_strip == 0:
                rows_per_strip = 1
            ifd[ROWSPERSTRIP] = rows_per_strip
        strip_byte_counts = 1 if stride == 0 else stride * ifd[ROWSPERSTRIP]
        strips_per_image = (h + ifd[ROWSPERSTRIP] - 1) // ifd[ROWSPERSTRIP]
        if strip_byte_counts >= 2**16:
            ifd.tagtype[STRIPBYTECOUNTS] = TiffTags.LONG
        ifd[STRIPBYTECOUNTS] = (strip_byte_counts,) * (strips_per_image - 1) + (
            stride * h - strip_byte_counts * (strips_per_image - 1),
        )
        ifd[STRIPOFFSETS] = tuple(
            range(0, strip_byte_counts * strips_per_image, strip_byte_counts)
        )  # this is adjusted by IFD writer
        # no compression by default:
        ifd[COMPRESSION] = COMPRESSION_INFO_REV.get(compression, 1)

        if im.mode == "YCbCr":
            for tag, default_value in {
                YCBCRSUBSAMPLING: (1, 1),
                REFERENCEBLACKWHITE: (0, 255, 128, 255, 128, 255),
            }.items():
                ifd.setdefault(tag, default_value)

        blocklist = [TILEWIDTH, TILELENGTH, TILEOFFSETS, TILEBYTECOUNTS]
        if libtiff:
            if "quality" in encoderinfo:
                quality = encoderinfo["quality"]
                if not isinstance(quality, int) or quality < 0 or quality > 100:
                    msg = "Invalid quality setting"
                    raise ValueError(msg)
                if compression != "jpeg":
                    msg = "quality setting only supported for 'jpeg' compression"
                    raise ValueError(msg)
                ifd[JPEGQUALITY] = quality

            logger.debug("Saving using libtiff encoder")
            logger.debug("Items: %s", sorted(ifd.items()))
            _fp = 0
            if hasattr(fp, "fileno"):
                try:
                    fp.seek(0)
                    _fp = fp.fileno()
                except io.UnsupportedOperation:
                    pass

            # optional types for non core tags
            types = {}
            # STRIPOFFSETS and STRIPBYTECOUNTS are added by the library
            # based on the data in the strip.
            # OSUBFILETYPE is deprecated.
            # The other tags expect arrays with a certain length (fixed or depending on
            # BITSPERSAMPLE, etc), passing arrays with a different length will result in
            # segfaults. Block these tags until we add extra validation.
            # SUBIFD may also cause a segfault.
            blocklist += [
                OSUBFILETYPE,
                REFERENCEBLACKWHITE,
                STRIPBYTECOUNTS,
                STRIPOFFSETS,
                TRANSFERFUNCTION,
                SUBIFD,
            ]

            # bits per sample is a single short in the tiff directory, not a list.
            atts: dict[int, Any] = {BITSPERSAMPLE: bits[0]}
            # Merge the ones that we have with (optional) more bits from
            # the original file, e.g x,y resolution so that we can
            # save(load('')) == original file.
            for tag, value in itertools.chain(ifd.items(), supplied_tags.items()):
                # Libtiff can only process certain core items without adding
                # them to the custom dictionary.
                # Custom items are supported for int, float, unicode, string and byte
                # values. Other types and tuples require a tagtype.
                if tag not in TiffTags.LIBTIFF_CORE:
                    if not getattr(Image.core, "libtiff_support_custom_tags", False):
                        continue

                    if tag in TiffTags.TAGS_V2_GROUPS:
                        types[tag] = TiffTags.LONG8
                    elif tag in ifd.tagtype:
                        types[tag] = ifd.tagtype[tag]
                    elif not (isinstance(value, (int, float, str, bytes))):
                        continue
                    else:
                        type = TiffTags.lookup(tag).type
                        if type:
                            types[tag] = type
                if tag not in atts and tag not in blocklist:
                    if isinstance(value, str):
                        atts[tag] = value.encode("ascii", "replace") + b"\0"
                    elif isinstance(value, IFDRational):
                        atts[tag] = float(value)
                    else:
                        atts[tag] = value

            if SAMPLEFORMAT in atts and len(atts[SAMPLEFORMAT]) == 1:
                atts[SAMPLEFORMAT] = atts[SAMPLEFORMAT][0]

            logger.debug("Converted items: %s", sorted(atts.items()))

            # libtiff always expects the bytes in native order.
            # we're storing image byte order. So, if the rawmode
            # contains I;16, we need to convert from native to image
            # byte order.
            if im.mode in ("I;16", "I;16B", "I;16L"):
                rawmode = "I;16N"

            # Pass tags as sorted list so that the tags are set in a fixed order.
            # This is required by libtiff for some tags. For example, the JPEGQUALITY
            # pseudo tag requires that the COMPRESS tag was already set.
            tags = list(atts.items())
            tags.sort()
            a = (rawmode, compression, _fp, filename, tags, types)
            encoder = Image._getencoder(im.mode, "libtiff", a, encoderconfig)
            encoder.setimage(im.im, (0, 0) + im.size)
            while True:
                errcode, data = encoder.encode(ImageFile.MAXBLOCK)[1:]
                if not _fp:
                    fp.write(data)
                if errcode:
                    break
            if errcode < 0:
                msg = f"encoder error {errcode} when writing image file"
                raise OSError(msg)

        else:
            for tag in blocklist:
                del ifd[tag]
            offset = ifd.save(fp)

            ImageFile._save(
                im,
                fp,
                [ImageFile._Tile("raw", (0, 0) + im.size, offset, (rawmode, stride, 1))],
            )

        # -- helper for multi-page save --
        if "_debug_multipage" in encoderinfo:
            # just to access o32 and o16 (using correct byte order)
            setattr(im, "_debug_multipage", ifd)

    class AppendingTiffWriter(io.BytesIO):
        fieldSizes = [
            0,  # None
            1,  # byte
            1,  # ascii
            2,  # short
            4,  # long
            8,  # rational
            1,  # sbyte
            1,  # undefined
            2,  # sshort
            4,  # slong
            8,  # srational
            4,  # float
            8,  # double
            4,  # ifd
            2,  # unicode
            4,  # complex
            8,  # long8
        ]

        Tags = {
            273,  # StripOffsets
            288,  # FreeOffsets
            324,  # TileOffsets
            519,  # JPEGQTables
            520,  # JPEGDCTables
            521,  # JPEGACTables
        }

        def __init__(self, fn: StrOrBytesPath | IO[bytes], new: bool = False) -> None:
            self.f: IO[bytes]
            if is_path(fn):
                self.name = fn
                self.close_fp = True
                try:
                    self.f = open(fn, "w+b" if new else "r+b")
                except OSError:
                    self.f = open(fn, "w+b")
            else:
                self.f = cast(IO[bytes], fn)
                self.close_fp = False
            self.beginning = self.f.tell()
            self.setup()

        def setup(self) -> None:
            # Reset everything.
            self.f.seek(self.beginning, os.SEEK_SET)

            self.whereToWriteNewIFDOffset: int | None = None
            self.offsetOfNewPage = 0

            self.IIMM = iimm = self.f.read(4)
            self._bigtiff = b"\x2b" in iimm
            if not iimm:
                # empty file - first page
                self.isFirst = True
                return

            self.isFirst = False
            if iimm not in PREFIXES:
                msg = "Invalid TIFF file header"
                raise RuntimeError(msg)

            self.setEndian("<" if iimm.startswith(II) else ">")

            if self._bigtiff:
                self.f.seek(4, os.SEEK_CUR)
            self.skipIFDs()
            self.goToEnd()

        def finalize(self) -> None:
            if self.isFirst:
                return

            # fix offsets
            self.f.seek(self.offsetOfNewPage)

            iimm = self.f.read(4)
            if not iimm:
                # Make it easy to finish a frame without committing to a new one.
                return

            if iimm != self.IIMM:
                msg = "IIMM of new page doesn't match IIMM of first page"
                raise RuntimeError(msg)

            if self._bigtiff:
                self.f.seek(4, os.SEEK_CUR)
            ifd_offset = self._read(8 if self._bigtiff else 4)
            ifd_offset += self.offsetOfNewPage
            assert self.whereToWriteNewIFDOffset is not None
            self.f.seek(self.whereToWriteNewIFDOffset)
            self._write(ifd_offset, 8 if self._bigtiff else 4)
            self.f.seek(ifd_offset)
            self.fixIFD()

        def newFrame(self) -> None:
            # Call this to finish a frame.
            self.finalize()
            self.setup()

        def __enter__(self) -> AppendingTiffWriter:
            return self

        def __exit__(self, *args: object) -> None:
            if self.close_fp:
                self.close()

        def tell(self) -> int:
            return self.f.tell() - self.offsetOfNewPage

        def seek(self, offset: int, whence: int = io.SEEK_SET) -> int:
            """
            :param offset: Distance to seek.
            :param whence: Whether the distance is relative to the start,
                           end or current position.
            :returns: The resulting position, relative to the start.
            """
            if whence == os.SEEK_SET:
                offset += self.offsetOfNewPage

            self.f.seek(offset, whence)
            return self.tell()

        def goToEnd(self) -> None:
            self.f.seek(0, os.SEEK_END)
            pos = self.f.tell()

            # pad to 16 byte boundary
            pad_bytes = 16 - pos % 16
            if 0 < pad_bytes < 16:
                self.f.write(bytes(pad_bytes))
            self.offsetOfNewPage = self.f.tell()

        def setEndian(self, endian: str) -> None:
            self.endian = endian
            self.longFmt = f"{self.endian}L"
            self.shortFmt = f"{self.endian}H"
            self.tagFormat = f"{self.endian}HH" + ("Q" if self._bigtiff else "L")

        def skipIFDs(self) -> None:
            while True:
                ifd_offset = self._read(8 if self._bigtiff else 4)
                if ifd_offset == 0:
                    self.whereToWriteNewIFDOffset = self.f.tell() - (
                        8 if self._bigtiff else 4
                    )
                    break

                self.f.seek(ifd_offset)
                num_tags = self._read(8 if self._bigtiff else 2)
                self.f.seek(num_tags * (20 if self._bigtiff else 12), os.SEEK_CUR)

        def write(self, data: Buffer, /) -> int:
            return self.f.write(data)

        def _fmt(self, field_size: int) -> str:
            try:
                return {2: "H", 4: "L", 8: "Q"}[field_size]
            except KeyError:
                msg = "offset is not supported"
                raise RuntimeError(msg)

        def _read(self, field_size: int) -> int:
            (value,) = struct.unpack(
                self.endian + self._fmt(field_size), self.f.read(field_size)
            )
            return value

        def readShort(self) -> int:
            return self._read(2)

        def readLong(self) -> int:
            return self._read(4)

        @staticmethod
        def _verify_bytes_written(bytes_written: int | None, expected: int) -> None:
            if bytes_written is not None and bytes_written != expected:
                msg = f"wrote only {bytes_written} bytes but wanted {expected}"
                raise RuntimeError(msg)

        def _rewriteLast(
            self, value: int, field_size: int, new_field_size: int = 0
        ) -> None:
            self.f.seek(-field_size, os.SEEK_CUR)
            if not new_field_size:
                new_field_size = field_size
            bytes_written = self.f.write(
                struct.pack(self.endian + self._fmt(new_field_size), value)
            )
            self._verify_bytes_written(bytes_written, new_field_size)

        def rewriteLastShortToLong(self, value: int) -> None:
            self._rewriteLast(value, 2, 4)

        def rewriteLastShort(self, value: int) -> None:
            return self._rewriteLast(value, 2)

        def rewriteLastLong(self, value: int) -> None:
            return self._rewriteLast(value, 4)

        def _write(self, value: int, field_size: int) -> None:
            bytes_written = self.f.write(
                struct.pack(self.endian + self._fmt(field_size), value)
            )
            self._verify_bytes_written(bytes_written, field_size)

        def writeShort(self, value: int) -> None:
            self._write(value, 2)

        def writeLong(self, value: int) -> None:
            self._write(value, 4)

        def close(self) -> None:
            self.finalize()
            if self.close_fp:
                self.f.close()

        def fixIFD(self) -> None:
            num_tags = self._read(8 if self._bigtiff else 2)

            for i in range(num_tags):
                tag, field_type, count = struct.unpack(
                    self.tagFormat, self.f.read(12 if self._bigtiff else 8)
                )

                field_size = self.fieldSizes[field_type]
                total_size = field_size * count
                fmt_size = 8 if self._bigtiff else 4
                is_local = total_size <= fmt_size
                if not is_local:
                    offset = self._read(fmt_size) + self.offsetOfNewPage
                    self._rewriteLast(offset, fmt_size)

                if tag in self.Tags:
                    cur_pos = self.f.tell()

                    logger.debug(
                        "fixIFD: %s (%d) - type: %s (%d) - type size: %d - count: %d",
                        TiffTags.lookup(tag).name,
                        tag,
                        TYPES.get(field_type, "unknown"),
                        field_type,
                        field_size,
                        count,
                    )

                    if is_local:
                        self._fixOffsets(count, field_size)
                        self.f.seek(cur_pos + fmt_size)
                    else:
                        self.f.seek(offset)
                        self._fixOffsets(count, field_size)
                        self.f.seek(cur_pos)

                elif is_local:
                    # skip the locally stored value that is not an offset
                    self.f.seek(fmt_size, os.SEEK_CUR)

        def _fixOffsets(self, count: int, field_size: int) -> None:
            for i in range(count):
                offset = self._read(field_size)
                offset += self.offsetOfNewPage

                new_field_size = 0
                if self._bigtiff and field_size in (2, 4) and offset >= 2**32:
                    # offset is now too large - we must convert long to long8
                    new_field_size = 8
                elif field_size == 2 and offset >= 2**16:
                    # offset is now too large - we must convert short to long
                    new_field_size = 4
                if new_field_size:
                    if count != 1:
                        msg = "not implemented"
                        raise RuntimeError(msg)  # XXX TODO

                    # simple case - the offset is just one and therefore it is
                    # local (not referenced with another offset)
                    self._rewriteLast(offset, field_size, new_field_size)
                    # Move back past the new offset, past 'count', and before 'field_type'
                    rewind = -new_field_size - 4 - 2
                    self.f.seek(rewind, os.SEEK_CUR)
                    self.writeShort(new_field_size)  # rewrite the type
                    self.f.seek(2 - rewind, os.SEEK_CUR)
                else:
                    self._rewriteLast(offset, field_size)

        def fixOffsets(
            self, count: int, isShort: bool = False, isLong: bool = False
        ) -> None:
            if isShort:
                field_size = 2
            elif isLong:
                field_size = 4
            else:
                field_size = 0
            return self._fixOffsets(count, field_size)

    def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
        append_images = list(im.encoderinfo.get("append_images", []))
        if not hasattr(im, "n_frames") and not append_images:
            return _save(im, fp, filename)

        cur_idx = im.tell()
        try:
            with AppendingTiffWriter(fp) as tf:
                for ims in [im] + append_images:
                    encoderinfo = ims._attach_default_encoderinfo(im)
                    if not hasattr(ims, "encoderconfig"):
                        ims.encoderconfig = ()
                    nfr = getattr(ims, "n_frames", 1)

                    for idx in range(nfr):
                        ims.seek(idx)
                        ims.load()
                        _save(ims, tf, filename)
                        tf.newFrame()
                    ims.encoderinfo = encoderinfo
        finally:
            im.seek(cur_idx)

    #
    # --------------------------------------------------------------------
    # Register

    Image.register_open(TiffImageFile.format, TiffImageFile, _accept)
    Image.register_save(TiffImageFile.format, _save)
    Image.register_save_all(TiffImageFile.format, _save_all)

    Image.register_extensions(TiffImageFile.format, [".tif", ".tiff"])

    Image.register_mime(TiffImageFile.format, "image/tiff")