updates

Backend/venv/lib/python3.12/site-packages/PIL/GifImagePlugin.py

@@ -23,17 +23,36 @@
 #
 # See the README file for information on usage and redistribution.
 #
+from __future__ import annotations
 
 import itertools
 import math
 import os
 import subprocess
 from enum import IntEnum
+from functools import cached_property
+from typing import Any, NamedTuple, cast
 
-from . import Image, ImageChops, ImageFile, ImagePalette, ImageSequence
+from . import (
+    Image,
+    ImageChops,
+    ImageFile,
+    ImageMath,
+    ImageOps,
+    ImagePalette,
+    ImageSequence,
+)
 from ._binary import i16le as i16
 from ._binary import o8
 from ._binary import o16le as o16
+from ._util import DeferredError
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import IO, Literal
+
+    from . import _imaging
+    from ._typing import Buffer
 
 
 class LoadingStrategy(IntEnum):
@@ -51,8 +70,8 @@ LOADING_STRATEGY = LoadingStrategy.RGB_AFTER_FIRST
 # Identify/read GIF files
 
 
-def _accept(prefix):
-    return prefix[:6] in [b"GIF87a", b"GIF89a"]
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith((b"GIF87a", b"GIF89a"))
 
 
 ##
@@ -67,19 +86,19 @@ class GifImageFile(ImageFile.ImageFile):
 
     global_palette = None
 
-    def data(self):
+    def data(self) -> bytes | None:
         s = self.fp.read(1)
         if s and s[0]:
             return self.fp.read(s[0])
         return None
 
-    def _is_palette_needed(self, p):
+    def _is_palette_needed(self, p: bytes) -> bool:
         for i in range(0, len(p), 3):
             if not (i // 3 == p[i] == p[i + 1] == p[i + 2]):
                 return True
         return False
 
-    def _open(self):
+    def _open(self) -> None:
         # Screen
         s = self.fp.read(13)
         if not _accept(s):
@@ -88,7 +107,6 @@ class GifImageFile(ImageFile.ImageFile):
 
         self.info["version"] = s[:6]
         self._size = i16(s, 6), i16(s, 8)
-        self.tile = []
         flags = s[10]
         bits = (flags & 7) + 1
 
@@ -103,12 +121,11 @@ class GifImageFile(ImageFile.ImageFile):
 
         self._fp = self.fp  # FIXME: hack
         self.__rewind = self.fp.tell()
-        self._n_frames = None
-        self._is_animated = None
+        self._n_frames: int | None = None
         self._seek(0)  # get ready to read first frame
 
     @property
-    def n_frames(self):
+    def n_frames(self) -> int:
         if self._n_frames is None:
             current = self.tell()
             try:
@@ -119,30 +136,29 @@ class GifImageFile(ImageFile.ImageFile):
             self.seek(current)
         return self._n_frames
 
-    @property
-    def is_animated(self):
-        if self._is_animated is None:
-            if self._n_frames is not None:
-                self._is_animated = self._n_frames != 1
-            else:
-                current = self.tell()
-                if current:
-                    self._is_animated = True
-                else:
-                    try:
-                        self._seek(1, False)
-                        self._is_animated = True
-                    except EOFError:
-                        self._is_animated = False
+    @cached_property
+    def is_animated(self) -> bool:
+        if self._n_frames is not None:
+            return self._n_frames != 1
 
-                    self.seek(current)
-        return self._is_animated
+        current = self.tell()
+        if current:
+            return True
 
-    def seek(self, frame):
+        try:
+            self._seek(1, False)
+            is_animated = True
+        except EOFError:
+            is_animated = False
+
+        self.seek(current)
+        return is_animated
+
+    def seek(self, frame: int) -> None:
         if not self._seek_check(frame):
             return
         if frame < self.__frame:
-            self.im = None
+            self._im = None
             self._seek(0)
 
         last_frame = self.__frame
@@ -154,11 +170,13 @@ class GifImageFile(ImageFile.ImageFile):
                 msg = "no more images in GIF file"
                 raise EOFError(msg) from e
 
-    def _seek(self, frame, update_image=True):
+    def _seek(self, frame: int, update_image: bool = True) -> None:
+        if isinstance(self._fp, DeferredError):
+            raise self._fp.ex
         if frame == 0:
             # rewind
             self.__offset = 0
-            self.dispose = None
+            self.dispose: _imaging.ImagingCore | None = None
             self.__frame = -1
             self._fp.seek(self.__rewind)
             self.disposal_method = 0
@@ -183,11 +201,12 @@ class GifImageFile(ImageFile.ImageFile):
 
         s = self.fp.read(1)
         if not s or s == b";":
-            raise EOFError
+            msg = "no more images in GIF file"
+            raise EOFError(msg)
 
-        palette = None
+        palette: ImagePalette.ImagePalette | Literal[False] | None = None
 
-        info = {}
+        info: dict[str, Any] = {}
         frame_transparency = None
         interlace = None
         frame_dispose_extent = None
@@ -203,7 +222,7 @@ class GifImageFile(ImageFile.ImageFile):
                 #
                 s = self.fp.read(1)
                 block = self.data()
-                if s[0] == 249:
+                if s[0] == 249 and block is not None:
                     #
                     # graphic control extension
                     #
@@ -239,14 +258,14 @@ class GifImageFile(ImageFile.ImageFile):
                         info["comment"] = comment
                     s = None
                     continue
-                elif s[0] == 255 and frame == 0:
+                elif s[0] == 255 and frame == 0 and block is not None:
                     #
                     # application extension
                     #
                     info["extension"] = block, self.fp.tell()
-                    if block[:11] == b"NETSCAPE2.0":
+                    if block.startswith(b"NETSCAPE2.0"):
                         block = self.data()
-                        if len(block) >= 3 and block[0] == 1:
+                        if block and len(block) >= 3 and block[0] == 1:
                             self.info["loop"] = i16(block, 1)
                 while self.data():
                     pass
@@ -280,15 +299,11 @@ class GifImageFile(ImageFile.ImageFile):
                 bits = self.fp.read(1)[0]
                 self.__offset = self.fp.tell()
                 break
-
-            else:
-                pass
-                # raise OSError, "illegal GIF tag `%x`" % s[0]
             s = None
 
         if interlace is None:
-            # self._fp = None
-            raise EOFError
+            msg = "image not found in GIF frame"
+            raise EOFError(msg)
 
         self.__frame = frame
         if not update_image:
@@ -310,18 +325,20 @@ class GifImageFile(ImageFile.ImageFile):
             else:
                 self._mode = "L"
 
-            if not palette and self.global_palette:
+            if palette:
+                self.palette = palette
+            elif self.global_palette:
                 from copy import copy
 
-                palette = copy(self.global_palette)
-            self.palette = palette
+                self.palette = copy(self.global_palette)
+            else:
+                self.palette = None
         else:
             if self.mode == "P":
                 if (
                     LOADING_STRATEGY != LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY
                     or palette
                 ):
-                    self.pyaccess = None
                     if "transparency" in self.info:
                         self.im.putpalettealpha(self.info["transparency"], 0)
                         self.im = self.im.convert("RGBA", Image.Dither.FLOYDSTEINBERG)
@@ -331,58 +348,63 @@ class GifImageFile(ImageFile.ImageFile):
                         self._mode = "RGB"
                         self.im = self.im.convert("RGB", Image.Dither.FLOYDSTEINBERG)
 
-        def _rgb(color):
+        def _rgb(color: int) -> tuple[int, int, int]:
             if self._frame_palette:
-                color = tuple(self._frame_palette.palette[color * 3 : color * 3 + 3])
+                if color * 3 + 3 > len(self._frame_palette.palette):
+                    color = 0
+                return cast(
+                    tuple[int, int, int],
+                    tuple(self._frame_palette.palette[color * 3 : color * 3 + 3]),
+                )
             else:
-                color = (color, color, color)
-            return color
+                return (color, color, color)
 
-        self.dispose_extent = frame_dispose_extent
-        try:
-            if self.disposal_method < 2:
-                # do not dispose or none specified
-                self.dispose = None
-            elif self.disposal_method == 2:
-                # replace with background colour
+        self.dispose = None
+        self.dispose_extent: tuple[int, int, int, int] | None = frame_dispose_extent
+        if self.dispose_extent and self.disposal_method >= 2:
+            try:
+                if self.disposal_method == 2:
+                    # replace with background colour
 
-                # only dispose the extent in this frame
-                x0, y0, x1, y1 = self.dispose_extent
-                dispose_size = (x1 - x0, y1 - y0)
-
-                Image._decompression_bomb_check(dispose_size)
-
-                # by convention, attempt to use transparency first
-                dispose_mode = "P"
-                color = self.info.get("transparency", frame_transparency)
-                if color is not None:
-                    if self.mode in ("RGB", "RGBA"):
-                        dispose_mode = "RGBA"
-                        color = _rgb(color) + (0,)
-                else:
-                    color = self.info.get("background", 0)
-                    if self.mode in ("RGB", "RGBA"):
-                        dispose_mode = "RGB"
-                        color = _rgb(color)
-                self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
-            else:
-                # replace with previous contents
-                if self.im is not None:
                     # only dispose the extent in this frame
-                    self.dispose = self._crop(self.im, self.dispose_extent)
-                elif frame_transparency is not None:
                     x0, y0, x1, y1 = self.dispose_extent
                     dispose_size = (x1 - x0, y1 - y0)
 
                     Image._decompression_bomb_check(dispose_size)
+
+                    # by convention, attempt to use transparency first
                     dispose_mode = "P"
-                    color = frame_transparency
-                    if self.mode in ("RGB", "RGBA"):
-                        dispose_mode = "RGBA"
-                        color = _rgb(frame_transparency) + (0,)
+                    color = self.info.get("transparency", frame_transparency)
+                    if color is not None:
+                        if self.mode in ("RGB", "RGBA"):
+                            dispose_mode = "RGBA"
+                            color = _rgb(color) + (0,)
+                    else:
+                        color = self.info.get("background", 0)
+                        if self.mode in ("RGB", "RGBA"):
+                            dispose_mode = "RGB"
+                            color = _rgb(color)
                     self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
-        except AttributeError:
-            pass
+                else:
+                    # replace with previous contents
+                    if self._im is not None:
+                        # only dispose the extent in this frame
+                        self.dispose = self._crop(self.im, self.dispose_extent)
+                    elif frame_transparency is not None:
+                        x0, y0, x1, y1 = self.dispose_extent
+                        dispose_size = (x1 - x0, y1 - y0)
+
+                        Image._decompression_bomb_check(dispose_size)
+                        dispose_mode = "P"
+                        color = frame_transparency
+                        if self.mode in ("RGB", "RGBA"):
+                            dispose_mode = "RGBA"
+                            color = _rgb(frame_transparency) + (0,)
+                        self.dispose = Image.core.fill(
+                            dispose_mode, dispose_size, color
+                        )
+            except AttributeError:
+                pass
 
         if interlace is not None:
             transparency = -1
@@ -393,7 +415,7 @@ class GifImageFile(ImageFile.ImageFile):
                 elif self.mode not in ("RGB", "RGBA"):
                     transparency = frame_transparency
             self.tile = [
-                (
+                ImageFile._Tile(
                     "gif",
                     (x0, y0, x1, y1),
                     self.__offset,
@@ -409,7 +431,7 @@ class GifImageFile(ImageFile.ImageFile):
             elif k in self.info:
                 del self.info[k]
 
-    def load_prepare(self):
+    def load_prepare(self) -> None:
         temp_mode = "P" if self._frame_palette else "L"
         self._prev_im = None
         if self.__frame == 0:
@@ -421,15 +443,22 @@ class GifImageFile(ImageFile.ImageFile):
             self._prev_im = self.im
             if self._frame_palette:
                 self.im = Image.core.fill("P", self.size, self._frame_transparency or 0)
-                self.im.putpalette(*self._frame_palette.getdata())
+                self.im.putpalette("RGB", *self._frame_palette.getdata())
             else:
-                self.im = None
+                self._im = None
+        if not self._prev_im and self._im is not None and self.size != self.im.size:
+            expanded_im = Image.core.fill(self.im.mode, self.size)
+            if self._frame_palette:
+                expanded_im.putpalette("RGB", *self._frame_palette.getdata())
+            expanded_im.paste(self.im, (0, 0) + self.im.size)
+
+            self.im = expanded_im
         self._mode = temp_mode
         self._frame_palette = None
 
         super().load_prepare()
 
-    def load_end(self):
+    def load_end(self) -> None:
         if self.__frame == 0:
             if self.mode == "P" and LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
                 if self._frame_transparency is not None:
@@ -441,21 +470,37 @@ class GifImageFile(ImageFile.ImageFile):
             return
         if not self._prev_im:
             return
+        if self.size != self._prev_im.size:
+            if self._frame_transparency is not None:
+                expanded_im = Image.core.fill("RGBA", self.size)
+            else:
+                expanded_im = Image.core.fill("P", self.size)
+                expanded_im.putpalette("RGB", "RGB", self.im.getpalette())
+                expanded_im = expanded_im.convert("RGB")
+            expanded_im.paste(self._prev_im, (0, 0) + self._prev_im.size)
+
+            self._prev_im = expanded_im
+            assert self._prev_im is not None
         if self._frame_transparency is not None:
-            self.im.putpalettealpha(self._frame_transparency, 0)
-            frame_im = self.im.convert("RGBA")
+            if self.mode == "L":
+                frame_im = self.im.convert_transparent("LA", self._frame_transparency)
+            else:
+                self.im.putpalettealpha(self._frame_transparency, 0)
+                frame_im = self.im.convert("RGBA")
         else:
             frame_im = self.im.convert("RGB")
+
+        assert self.dispose_extent is not None
         frame_im = self._crop(frame_im, self.dispose_extent)
 
         self.im = self._prev_im
         self._mode = self.im.mode
-        if frame_im.mode == "RGBA":
+        if frame_im.mode in ("LA", "RGBA"):
             self.im.paste(frame_im, self.dispose_extent, frame_im)
         else:
             self.im.paste(frame_im, self.dispose_extent)
 
-    def tell(self):
+    def tell(self) -> int:
         return self.__frame
 
 
@@ -466,7 +511,7 @@ class GifImageFile(ImageFile.ImageFile):
 RAWMODE = {"1": "L", "L": "L", "P": "P"}
 
 
-def _normalize_mode(im):
+def _normalize_mode(im: Image.Image) -> Image.Image:
     """
     Takes an image (or frame), returns an image in a mode that is appropriate
     for saving in a Gif.
@@ -482,6 +527,7 @@ def _normalize_mode(im):
         return im
     if Image.getmodebase(im.mode) == "RGB":
         im = im.convert("P", palette=Image.Palette.ADAPTIVE)
+        assert im.palette is not None
         if im.palette.mode == "RGBA":
             for rgba in im.palette.colors:
                 if rgba[3] == 0:
@@ -491,7 +537,12 @@ def _normalize_mode(im):
     return im.convert("L")
 
 
-def _normalize_palette(im, palette, info):
+_Palette = bytes | bytearray | list[int] | ImagePalette.ImagePalette
+
+
+def _normalize_palette(
+    im: Image.Image, palette: _Palette | None, info: dict[str, Any]
+) -> Image.Image:
     """
     Normalizes the palette for image.
       - Sets the palette to the incoming palette, if provided.
@@ -513,14 +564,18 @@ def _normalize_palette(im, palette, info):
 
     if im.mode == "P":
         if not source_palette:
-            source_palette = im.im.getpalette("RGB")[:768]
+            im_palette = im.getpalette(None)
+            assert im_palette is not None
+            source_palette = bytearray(im_palette)
     else:  # L-mode
         if not source_palette:
             source_palette = bytearray(i // 3 for i in range(768))
         im.palette = ImagePalette.ImagePalette("RGB", palette=source_palette)
+    assert source_palette is not None
 
     if palette:
-        used_palette_colors = []
+        used_palette_colors: list[int | None] = []
+        assert im.palette is not None
         for i in range(0, len(source_palette), 3):
             source_color = tuple(source_palette[i : i + 3])
             index = im.palette.colors.get(source_color)
@@ -533,20 +588,38 @@ def _normalize_palette(im, palette, info):
                     if j not in used_palette_colors:
                         used_palette_colors[i] = j
                         break
-        im = im.remap_palette(used_palette_colors)
+        dest_map: list[int] = []
+        for index in used_palette_colors:
+            assert index is not None
+            dest_map.append(index)
+        im = im.remap_palette(dest_map)
     else:
-        used_palette_colors = _get_optimize(im, info)
-        if used_palette_colors is not None:
-            return im.remap_palette(used_palette_colors, source_palette)
+        optimized_palette_colors = _get_optimize(im, info)
+        if optimized_palette_colors is not None:
+            im = im.remap_palette(optimized_palette_colors, source_palette)
+            if "transparency" in info:
+                try:
+                    info["transparency"] = optimized_palette_colors.index(
+                        info["transparency"]
+                    )
+                except ValueError:
+                    del info["transparency"]
+            return im
 
+    assert im.palette is not None
     im.palette.palette = source_palette
     return im
 
 
-def _write_single_frame(im, fp, palette):
+def _write_single_frame(
+    im: Image.Image,
+    fp: IO[bytes],
+    palette: _Palette | None,
+) -> None:
     im_out = _normalize_mode(im)
     for k, v in im_out.info.items():
-        im.encoderinfo.setdefault(k, v)
+        if isinstance(k, str):
+            im.encoderinfo.setdefault(k, v)
     im_out = _normalize_palette(im_out, palette, im.encoderinfo)
 
     for s in _get_global_header(im_out, im.encoderinfo):
@@ -559,26 +632,40 @@ def _write_single_frame(im, fp, palette):
     _write_local_header(fp, im, (0, 0), flags)
 
     im_out.encoderconfig = (8, get_interlace(im))
-    ImageFile._save(im_out, fp, [("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])])
+    ImageFile._save(
+        im_out, fp, [ImageFile._Tile("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])]
+    )
 
     fp.write(b"\0")  # end of image data
 
 
-def _getbbox(base_im, im_frame):
-    if _get_palette_bytes(im_frame) == _get_palette_bytes(base_im):
-        delta = ImageChops.subtract_modulo(im_frame, base_im)
-    else:
-        delta = ImageChops.subtract_modulo(
-            im_frame.convert("RGBA"), base_im.convert("RGBA")
-        )
-    return delta.getbbox(alpha_only=False)
+def _getbbox(
+    base_im: Image.Image, im_frame: Image.Image
+) -> tuple[Image.Image, tuple[int, int, int, int] | None]:
+    palette_bytes = [
+        bytes(im.palette.palette) if im.palette else b"" for im in (base_im, im_frame)
+    ]
+    if palette_bytes[0] != palette_bytes[1]:
+        im_frame = im_frame.convert("RGBA")
+        base_im = base_im.convert("RGBA")
+    delta = ImageChops.subtract_modulo(im_frame, base_im)
+    return delta, delta.getbbox(alpha_only=False)
 
 
-def _write_multiple_frames(im, fp, palette):
+class _Frame(NamedTuple):
+    im: Image.Image
+    bbox: tuple[int, int, int, int] | None
+    encoderinfo: dict[str, Any]
+
+
+def _write_multiple_frames(
+    im: Image.Image, fp: IO[bytes], palette: _Palette | None
+) -> bool:
     duration = im.encoderinfo.get("duration")
     disposal = im.encoderinfo.get("disposal", im.info.get("disposal"))
 
-    im_frames = []
+    im_frames: list[_Frame] = []
+    previous_im: Image.Image | None = None
     frame_count = 0
     background_im = None
     for imSequence in itertools.chain([im], im.encoderinfo.get("append_images", [])):
@@ -589,12 +676,13 @@ def _write_multiple_frames(im, fp, palette):
                 for k, v in im_frame.info.items():
                     if k == "transparency":
                         continue
-                    im.encoderinfo.setdefault(k, v)
+                    if isinstance(k, str):
+                        im.encoderinfo.setdefault(k, v)
 
             encoderinfo = im.encoderinfo.copy()
-            im_frame = _normalize_palette(im_frame, palette, encoderinfo)
             if "transparency" in im_frame.info:
                 encoderinfo.setdefault("transparency", im_frame.info["transparency"])
+            im_frame = _normalize_palette(im_frame, palette, encoderinfo)
             if isinstance(duration, (list, tuple)):
                 encoderinfo["duration"] = duration[frame_count]
             elif duration is None and "duration" in im_frame.info:
@@ -603,63 +691,116 @@ def _write_multiple_frames(im, fp, palette):
                 encoderinfo["disposal"] = disposal[frame_count]
             frame_count += 1
 
-            if im_frames:
+            diff_frame = None
+            if im_frames and previous_im:
                 # delta frame
-                previous = im_frames[-1]
-                bbox = _getbbox(previous["im"], im_frame)
+                delta, bbox = _getbbox(previous_im, im_frame)
                 if not bbox:
                     # This frame is identical to the previous frame
                     if encoderinfo.get("duration"):
-                        previous["encoderinfo"]["duration"] += encoderinfo["duration"]
+                        im_frames[-1].encoderinfo["duration"] += encoderinfo["duration"]
                     continue
-                if encoderinfo.get("disposal") == 2:
-                    if background_im is None:
-                        color = im.encoderinfo.get(
-                            "transparency", im.info.get("transparency", (0, 0, 0))
-                        )
-                        background = _get_background(im_frame, color)
-                        background_im = Image.new("P", im_frame.size, background)
-                        background_im.putpalette(im_frames[0]["im"].palette)
-                    bbox = _getbbox(background_im, im_frame)
+                if im_frames[-1].encoderinfo.get("disposal") == 2:
+                    # To appear correctly in viewers using a convention,
+                    # only consider transparency, and not background color
+                    color = im.encoderinfo.get(
+                        "transparency", im.info.get("transparency")
+                    )
+                    if color is not None:
+                        if background_im is None:
+                            background = _get_background(im_frame, color)
+                            background_im = Image.new("P", im_frame.size, background)
+                            first_palette = im_frames[0].im.palette
+                            assert first_palette is not None
+                            background_im.putpalette(first_palette, first_palette.mode)
+                        bbox = _getbbox(background_im, im_frame)[1]
+                    else:
+                        bbox = (0, 0) + im_frame.size
+                elif encoderinfo.get("optimize") and im_frame.mode != "1":
+                    if "transparency" not in encoderinfo:
+                        assert im_frame.palette is not None
+                        try:
+                            encoderinfo["transparency"] = (
+                                im_frame.palette._new_color_index(im_frame)
+                            )
+                        except ValueError:
+                            pass
+                    if "transparency" in encoderinfo:
+                        # When the delta is zero, fill the image with transparency
+                        diff_frame = im_frame.copy()
+                        fill = Image.new("P", delta.size, encoderinfo["transparency"])
+                        if delta.mode == "RGBA":
+                            r, g, b, a = delta.split()
+                            mask = ImageMath.lambda_eval(
+                                lambda args: args["convert"](
+                                    args["max"](
+                                        args["max"](
+                                            args["max"](args["r"], args["g"]), args["b"]
+                                        ),
+                                        args["a"],
+                                    )
+                                    * 255,
+                                    "1",
+                                ),
+                                r=r,
+                                g=g,
+                                b=b,
+                                a=a,
+                            )
+                        else:
+                            if delta.mode == "P":
+                                # Convert to L without considering palette
+                                delta_l = Image.new("L", delta.size)
+                                delta_l.putdata(delta.getdata())
+                                delta = delta_l
+                            mask = ImageMath.lambda_eval(
+                                lambda args: args["convert"](args["im"] * 255, "1"),
+                                im=delta,
+                            )
+                        diff_frame.paste(fill, mask=ImageOps.invert(mask))
             else:
                 bbox = None
-            im_frames.append({"im": im_frame, "bbox": bbox, "encoderinfo": encoderinfo})
+            previous_im = im_frame
+            im_frames.append(_Frame(diff_frame or im_frame, bbox, encoderinfo))
 
-    if len(im_frames) > 1:
-        for frame_data in im_frames:
-            im_frame = frame_data["im"]
-            if not frame_data["bbox"]:
-                # global header
-                for s in _get_global_header(im_frame, frame_data["encoderinfo"]):
-                    fp.write(s)
-                offset = (0, 0)
-            else:
-                # compress difference
-                if not palette:
-                    frame_data["encoderinfo"]["include_color_table"] = True
+    if len(im_frames) == 1:
+        if "duration" in im.encoderinfo:
+            # Since multiple frames will not be written, use the combined duration
+            im.encoderinfo["duration"] = im_frames[0].encoderinfo["duration"]
+        return False
 
-                im_frame = im_frame.crop(frame_data["bbox"])
-                offset = frame_data["bbox"][:2]
-            _write_frame_data(fp, im_frame, offset, frame_data["encoderinfo"])
-        return True
-    elif "duration" in im.encoderinfo and isinstance(
-        im.encoderinfo["duration"], (list, tuple)
-    ):
-        # Since multiple frames will not be written, add together the frame durations
-        im.encoderinfo["duration"] = sum(im.encoderinfo["duration"])
+    for frame_data in im_frames:
+        im_frame = frame_data.im
+        if not frame_data.bbox:
+            # global header
+            for s in _get_global_header(im_frame, frame_data.encoderinfo):
+                fp.write(s)
+            offset = (0, 0)
+        else:
+            # compress difference
+            if not palette:
+                frame_data.encoderinfo["include_color_table"] = True
+
+            if frame_data.bbox != (0, 0) + im_frame.size:
+                im_frame = im_frame.crop(frame_data.bbox)
+            offset = frame_data.bbox[:2]
+        _write_frame_data(fp, im_frame, offset, frame_data.encoderinfo)
+    return True
 
 
-def _save_all(im, fp, filename):
+def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
     _save(im, fp, filename, save_all=True)
 
 
-def _save(im, fp, filename, save_all=False):
+def _save(
+    im: Image.Image, fp: IO[bytes], filename: str | bytes, save_all: bool = False
+) -> None:
     # header
     if "palette" in im.encoderinfo or "palette" in im.info:
         palette = im.encoderinfo.get("palette", im.info.get("palette"))
     else:
         palette = None
-        im.encoderinfo["optimize"] = im.encoderinfo.get("optimize", True)
+        im.encoderinfo.setdefault("optimize", True)
 
     if not save_all or not _write_multiple_frames(im, fp, palette):
         _write_single_frame(im, fp, palette)
@@ -670,7 +811,7 @@ def _save(im, fp, filename, save_all=False):
         fp.flush()
 
 
-def get_interlace(im):
+def get_interlace(im: Image.Image) -> int:
     interlace = im.encoderinfo.get("interlace", 1)
 
     # workaround for @PIL153
@@ -680,23 +821,13 @@ def get_interlace(im):
     return interlace
 
 
-def _write_local_header(fp, im, offset, flags):
-    transparent_color_exists = False
+def _write_local_header(
+    fp: IO[bytes], im: Image.Image, offset: tuple[int, int], flags: int
+) -> None:
     try:
-        transparency = int(im.encoderinfo["transparency"])
-    except (KeyError, ValueError):
-        pass
-    else:
-        # optimize the block away if transparent color is not used
-        transparent_color_exists = True
-
-        used_palette_colors = _get_optimize(im, im.encoderinfo)
-        if used_palette_colors is not None:
-            # adjust the transparency index after optimize
-            try:
-                transparency = used_palette_colors.index(transparency)
-            except ValueError:
-                transparent_color_exists = False
+        transparency = im.encoderinfo["transparency"]
+    except KeyError:
+        transparency = None
 
     if "duration" in im.encoderinfo:
         duration = int(im.encoderinfo["duration"] / 10)
@@ -705,11 +836,9 @@ def _write_local_header(fp, im, offset, flags):
 
     disposal = int(im.encoderinfo.get("disposal", 0))
 
-    if transparent_color_exists or duration != 0 or disposal:
-        packed_flag = 1 if transparent_color_exists else 0
+    if transparency is not None or duration != 0 or disposal:
+        packed_flag = 1 if transparency is not None else 0
         packed_flag |= disposal << 2
-        if not transparent_color_exists:
-            transparency = 0
 
         fp.write(
             b"!"
@@ -717,7 +846,7 @@ def _write_local_header(fp, im, offset, flags):
             + o8(4)  # length
             + o8(packed_flag)  # packed fields
             + o16(duration)  # duration
-            + o8(transparency)  # transparency index
+            + o8(transparency or 0)  # transparency index
             + o8(0)
         )
 
@@ -742,7 +871,7 @@ def _write_local_header(fp, im, offset, flags):
     fp.write(o8(8))  # bits
 
 
-def _save_netpbm(im, fp, filename):
+def _save_netpbm(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
     # Unused by default.
     # To use, uncomment the register_save call at the end of the file.
     #
@@ -773,6 +902,7 @@ def _save_netpbm(im, fp, filename):
                 )
 
                 # Allow ppmquant to receive SIGPIPE if ppmtogif exits
+                assert quant_proc.stdout is not None
                 quant_proc.stdout.close()
 
                 retcode = quant_proc.wait()
@@ -794,7 +924,7 @@ def _save_netpbm(im, fp, filename):
 _FORCE_OPTIMIZE = False
 
 
-def _get_optimize(im, info):
+def _get_optimize(im: Image.Image, info: dict[str, Any]) -> list[int] | None:
     """
     Palette optimization is a potentially expensive operation.
 
@@ -805,7 +935,7 @@ def _get_optimize(im, info):
     :param info: encoderinfo
     :returns: list of indexes of palette entries in use, or None
     """
-    if im.mode in ("P", "L") and info and info.get("optimize", 0):
+    if im.mode in ("P", "L") and info and info.get("optimize"):
         # Potentially expensive operation.
 
         # The palette saves 3 bytes per color not used, but palette
@@ -827,6 +957,7 @@ def _get_optimize(im, info):
             if optimise or max(used_palette_colors) >= len(used_palette_colors):
                 return used_palette_colors
 
+            assert im.palette is not None
             num_palette_colors = len(im.palette.palette) // Image.getmodebands(
                 im.palette.mode
             )
@@ -838,9 +969,10 @@ def _get_optimize(im, info):
                 and current_palette_size > 2
             ):
                 return used_palette_colors
+    return None
 
 
-def _get_color_table_size(palette_bytes):
+def _get_color_table_size(palette_bytes: bytes) -> int:
     # calculate the palette size for the header
     if not palette_bytes:
         return 0
@@ -850,7 +982,7 @@ def _get_color_table_size(palette_bytes):
         return math.ceil(math.log(len(palette_bytes) // 3, 2)) - 1
 
 
-def _get_header_palette(palette_bytes):
+def _get_header_palette(palette_bytes: bytes) -> bytes:
     """
     Returns the palette, null padded to the next power of 2 (*3) bytes
     suitable for direct inclusion in the GIF header
@@ -868,23 +1000,33 @@ def _get_header_palette(palette_bytes):
     return palette_bytes
 
 
-def _get_palette_bytes(im):
+def _get_palette_bytes(im: Image.Image) -> bytes:
     """
     Gets the palette for inclusion in the gif header
 
     :param im: Image object
     :returns: Bytes, len<=768 suitable for inclusion in gif header
     """
-    return im.palette.palette if im.palette else b""
+    if not im.palette:
+        return b""
+
+    palette = bytes(im.palette.palette)
+    if im.palette.mode == "RGBA":
+        palette = b"".join(palette[i * 4 : i * 4 + 3] for i in range(len(palette) // 3))
+    return palette
 
 
-def _get_background(im, info_background):
+def _get_background(
+    im: Image.Image,
+    info_background: int | tuple[int, int, int] | tuple[int, int, int, int] | None,
+) -> int:
     background = 0
     if info_background:
         if isinstance(info_background, tuple):
             # WebPImagePlugin stores an RGBA value in info["background"]
             # So it must be converted to the same format as GifImagePlugin's
             # info["background"] - a global color table index
+            assert im.palette is not None
             try:
                 background = im.palette.getcolor(info_background, im)
             except ValueError as e:
@@ -901,7 +1043,7 @@ def _get_background(im, info_background):
     return background
 
 
-def _get_global_header(im, info):
+def _get_global_header(im: Image.Image, info: dict[str, Any]) -> list[bytes]:
     """Return a list of strings representing a GIF header"""
 
     # Header Block
@@ -963,7 +1105,12 @@ def _get_global_header(im, info):
     return header
 
 
-def _write_frame_data(fp, im_frame, offset, params):
+def _write_frame_data(
+    fp: IO[bytes],
+    im_frame: Image.Image,
+    offset: tuple[int, int],
+    params: dict[str, Any],
+) -> None:
     try:
         im_frame.encoderinfo = params
 
@@ -971,7 +1118,9 @@ def _write_frame_data(fp, im_frame, offset, params):
         _write_local_header(fp, im_frame, offset, 0)
 
         ImageFile._save(
-            im_frame, fp, [("gif", (0, 0) + im_frame.size, 0, RAWMODE[im_frame.mode])]
+            im_frame,
+            fp,
+            [ImageFile._Tile("gif", (0, 0) + im_frame.size, 0, RAWMODE[im_frame.mode])],
         )
 
         fp.write(b"\0")  # end of image data
@@ -983,7 +1132,9 @@ def _write_frame_data(fp, im_frame, offset, params):
 # Legacy GIF utilities
 
 
-def getheader(im, palette=None, info=None):
+def getheader(
+    im: Image.Image, palette: _Palette | None = None, info: dict[str, Any] | None = None
+) -> tuple[list[bytes], list[int] | None]:
     """
     Legacy Method to get Gif data from image.
 
@@ -995,11 +1146,11 @@ def getheader(im, palette=None, info=None):
     :returns: tuple of(list of header items, optimized palette)
 
     """
-    used_palette_colors = _get_optimize(im, info)
-
     if info is None:
         info = {}
 
+    used_palette_colors = _get_optimize(im, info)
+
     if "background" not in info and "background" in im.info:
         info["background"] = im.info["background"]
 
@@ -1011,7 +1162,9 @@ def getheader(im, palette=None, info=None):
     return header, used_palette_colors
 
 
-def getdata(im, offset=(0, 0), **params):
+def getdata(
+    im: Image.Image, offset: tuple[int, int] = (0, 0), **params: Any
+) -> list[bytes]:
     """
     Legacy Method
 
@@ -1028,12 +1181,14 @@ def getdata(im, offset=(0, 0), **params):
     :returns: List of bytes containing GIF encoded frame data
 
     """
+    from io import BytesIO
 
-    class Collector:
+    class Collector(BytesIO):
         data = []
 
-        def write(self, data):
+        def write(self, data: Buffer) -> int:
             self.data.append(data)
+            return len(data)
 
     im.load()  # make sure raster data is available