Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.10/site-packages/pillow-11.1.0-py3.10-linux-x86_64.egg/PIL/GifImagePlugin.py: 10%

1# 

2# The Python Imaging Library. 

3# $Id$ 

4# 

5# GIF file handling 

6# 

7# History: 

8# 1995-09-01 fl Created 

9# 1996-12-14 fl Added interlace support 

10# 1996-12-30 fl Added animation support 

11# 1997-01-05 fl Added write support, fixed local colour map bug 

12# 1997-02-23 fl Make sure to load raster data in getdata() 

13# 1997-07-05 fl Support external decoder (0.4) 

14# 1998-07-09 fl Handle all modes when saving (0.5) 

15# 1998-07-15 fl Renamed offset attribute to avoid name clash 

16# 2001-04-16 fl Added rewind support (seek to frame 0) (0.6) 

17# 2001-04-17 fl Added palette optimization (0.7) 

18# 2002-06-06 fl Added transparency support for save (0.8) 

19# 2004-02-24 fl Disable interlacing for small images 

20# 

21# Copyright (c) 1997-2004 by Secret Labs AB 

22# Copyright (c) 1995-2004 by Fredrik Lundh 

23# 

24# See the README file for information on usage and redistribution. 

25# 

26from __future__ import annotations 

27 

28import itertools 

29import math 

30import os 

31import subprocess 

32from enum import IntEnum 

33from functools import cached_property 

34from typing import IO, TYPE_CHECKING, Any, Literal, NamedTuple, Union 

35 

36from . import ( 

37 Image, 

38 ImageChops, 

39 ImageFile, 

40 ImageMath, 

41 ImageOps, 

42 ImagePalette, 

43 ImageSequence, 

44) 

45from ._binary import i16le as i16 

46from ._binary import o8 

47from ._binary import o16le as o16 

48 

49if TYPE_CHECKING: 

50 from . import _imaging 

51 from ._typing import Buffer 

52 

53 

54class LoadingStrategy(IntEnum): 

55 """.. versionadded:: 9.1.0""" 

56 

57 RGB_AFTER_FIRST = 0 

58 RGB_AFTER_DIFFERENT_PALETTE_ONLY = 1 

59 RGB_ALWAYS = 2 

60 

61 

62#: .. versionadded:: 9.1.0 

63LOADING_STRATEGY = LoadingStrategy.RGB_AFTER_FIRST 

64 

65# -------------------------------------------------------------------- 

66# Identify/read GIF files 

67 

68 

69def _accept(prefix: bytes) -> bool: 

70 return prefix[:6] in [b"GIF87a", b"GIF89a"] 

71 

72 

73## 

74# Image plugin for GIF images. This plugin supports both GIF87 and 

75# GIF89 images. 

76 

77 

78class GifImageFile(ImageFile.ImageFile): 

79 format = "GIF" 

80 format_description = "Compuserve GIF" 

81 _close_exclusive_fp_after_loading = False 

82 

83 global_palette = None 

84 

85 def data(self) -> bytes | None: 

86 s = self.fp.read(1) 

87 if s and s[0]: 

88 return self.fp.read(s[0]) 

89 return None 

90 

91 def _is_palette_needed(self, p: bytes) -> bool: 

92 for i in range(0, len(p), 3): 

93 if not (i // 3 == p[i] == p[i + 1] == p[i + 2]): 

94 return True 

95 return False 

96 

97 def _open(self) -> None: 

98 # Screen 

99 s = self.fp.read(13) 

100 if not _accept(s): 

101 msg = "not a GIF file" 

102 raise SyntaxError(msg) 

103 

104 self.info["version"] = s[:6] 

105 self._size = i16(s, 6), i16(s, 8) 

106 flags = s[10] 

107 bits = (flags & 7) + 1 

108 

109 if flags & 128: 

110 # get global palette 

111 self.info["background"] = s[11] 

112 # check if palette contains colour indices 

113 p = self.fp.read(3 << bits) 

114 if self._is_palette_needed(p): 

115 p = ImagePalette.raw("RGB", p) 

116 self.global_palette = self.palette = p 

117 

118 self._fp = self.fp # FIXME: hack 

119 self.__rewind = self.fp.tell() 

120 self._n_frames: int | None = None 

121 self._seek(0) # get ready to read first frame 

122 

123 @property 

124 def n_frames(self) -> int: 

125 if self._n_frames is None: 

126 current = self.tell() 

127 try: 

128 while True: 

129 self._seek(self.tell() + 1, False) 

130 except EOFError: 

131 self._n_frames = self.tell() + 1 

132 self.seek(current) 

133 return self._n_frames 

134 

135 @cached_property 

136 def is_animated(self) -> bool: 

137 if self._n_frames is not None: 

138 return self._n_frames != 1 

139 

140 current = self.tell() 

141 if current: 

142 return True 

143 

144 try: 

145 self._seek(1, False) 

146 is_animated = True 

147 except EOFError: 

148 is_animated = False 

149 

150 self.seek(current) 

151 return is_animated 

152 

153 def seek(self, frame: int) -> None: 

154 if not self._seek_check(frame): 

155 return 

156 if frame < self.__frame: 

157 self._im = None 

158 self._seek(0) 

159 

160 last_frame = self.__frame 

161 for f in range(self.__frame + 1, frame + 1): 

162 try: 

163 self._seek(f) 

164 except EOFError as e: 

165 self.seek(last_frame) 

166 msg = "no more images in GIF file" 

167 raise EOFError(msg) from e 

168 

169 def _seek(self, frame: int, update_image: bool = True) -> None: 

170 if frame == 0: 

171 # rewind 

172 self.__offset = 0 

173 self.dispose: _imaging.ImagingCore | None = None 

174 self.__frame = -1 

175 self._fp.seek(self.__rewind) 

176 self.disposal_method = 0 

177 if "comment" in self.info: 

178 del self.info["comment"] 

179 else: 

180 # ensure that the previous frame was loaded 

181 if self.tile and update_image: 

182 self.load() 

183 

184 if frame != self.__frame + 1: 

185 msg = f"cannot seek to frame {frame}" 

186 raise ValueError(msg) 

187 

188 self.fp = self._fp 

189 if self.__offset: 

190 # backup to last frame 

191 self.fp.seek(self.__offset) 

192 while self.data(): 

193 pass 

194 self.__offset = 0 

195 

196 s = self.fp.read(1) 

197 if not s or s == b";": 

198 msg = "no more images in GIF file" 

199 raise EOFError(msg) 

200 

201 palette: ImagePalette.ImagePalette | Literal[False] | None = None 

202 

203 info: dict[str, Any] = {} 

204 frame_transparency = None 

205 interlace = None 

206 frame_dispose_extent = None 

207 while True: 

208 if not s: 

209 s = self.fp.read(1) 

210 if not s or s == b";": 

211 break 

212 

213 elif s == b"!": 

214 # 

215 # extensions 

216 # 

217 s = self.fp.read(1) 

218 block = self.data() 

219 if s[0] == 249 and block is not None: 

220 # 

221 # graphic control extension 

222 # 

223 flags = block[0] 

224 if flags & 1: 

225 frame_transparency = block[3] 

226 info["duration"] = i16(block, 1) * 10 

227 

228 # disposal method - find the value of bits 4 - 6 

229 dispose_bits = 0b00011100 & flags 

230 dispose_bits = dispose_bits >> 2 

231 if dispose_bits: 

232 # only set the dispose if it is not 

233 # unspecified. I'm not sure if this is 

234 # correct, but it seems to prevent the last 

235 # frame from looking odd for some animations 

236 self.disposal_method = dispose_bits 

237 elif s[0] == 254: 

238 # 

239 # comment extension 

240 # 

241 comment = b"" 

242 

243 # Read this comment block 

244 while block: 

245 comment += block 

246 block = self.data() 

247 

248 if "comment" in info: 

249 # If multiple comment blocks in frame, separate with \n 

250 info["comment"] += b"\n" + comment 

251 else: 

252 info["comment"] = comment 

253 s = None 

254 continue 

255 elif s[0] == 255 and frame == 0 and block is not None: 

256 # 

257 # application extension 

258 # 

259 info["extension"] = block, self.fp.tell() 

260 if block[:11] == b"NETSCAPE2.0": 

261 block = self.data() 

262 if block and len(block) >= 3 and block[0] == 1: 

263 self.info["loop"] = i16(block, 1) 

264 while self.data(): 

265 pass 

266 

267 elif s == b",": 

268 # 

269 # local image 

270 # 

271 s = self.fp.read(9) 

272 

273 # extent 

274 x0, y0 = i16(s, 0), i16(s, 2) 

275 x1, y1 = x0 + i16(s, 4), y0 + i16(s, 6) 

276 if (x1 > self.size[0] or y1 > self.size[1]) and update_image: 

277 self._size = max(x1, self.size[0]), max(y1, self.size[1]) 

278 Image._decompression_bomb_check(self._size) 

279 frame_dispose_extent = x0, y0, x1, y1 

280 flags = s[8] 

281 

282 interlace = (flags & 64) != 0 

283 

284 if flags & 128: 

285 bits = (flags & 7) + 1 

286 p = self.fp.read(3 << bits) 

287 if self._is_palette_needed(p): 

288 palette = ImagePalette.raw("RGB", p) 

289 else: 

290 palette = False 

291 

292 # image data 

293 bits = self.fp.read(1)[0] 

294 self.__offset = self.fp.tell() 

295 break 

296 s = None 

297 

298 if interlace is None: 

299 msg = "image not found in GIF frame" 

300 raise EOFError(msg) 

301 

302 self.__frame = frame 

303 if not update_image: 

304 return 

305 

306 self.tile = [] 

307 

308 if self.dispose: 

309 self.im.paste(self.dispose, self.dispose_extent) 

310 

311 self._frame_palette = palette if palette is not None else self.global_palette 

312 self._frame_transparency = frame_transparency 

313 if frame == 0: 

314 if self._frame_palette: 

315 if LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS: 

316 self._mode = "RGBA" if frame_transparency is not None else "RGB" 

317 else: 

318 self._mode = "P" 

319 else: 

320 self._mode = "L" 

321 

322 if palette: 

323 self.palette = palette 

324 elif self.global_palette: 

325 from copy import copy 

326 

327 self.palette = copy(self.global_palette) 

328 else: 

329 self.palette = None 

330 else: 

331 if self.mode == "P": 

332 if ( 

333 LOADING_STRATEGY != LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY 

334 or palette 

335 ): 

336 if "transparency" in self.info: 

337 self.im.putpalettealpha(self.info["transparency"], 0) 

338 self.im = self.im.convert("RGBA", Image.Dither.FLOYDSTEINBERG) 

339 self._mode = "RGBA" 

340 del self.info["transparency"] 

341 else: 

342 self._mode = "RGB" 

343 self.im = self.im.convert("RGB", Image.Dither.FLOYDSTEINBERG) 

344 

345 def _rgb(color: int) -> tuple[int, int, int]: 

346 if self._frame_palette: 

347 if color * 3 + 3 > len(self._frame_palette.palette): 

348 color = 0 

349 return tuple(self._frame_palette.palette[color * 3 : color * 3 + 3]) 

350 else: 

351 return (color, color, color) 

352 

353 self.dispose = None 

354 self.dispose_extent = frame_dispose_extent 

355 if self.dispose_extent and self.disposal_method >= 2: 

356 try: 

357 if self.disposal_method == 2: 

358 # replace with background colour 

359 

360 # only dispose the extent in this frame 

361 x0, y0, x1, y1 = self.dispose_extent 

362 dispose_size = (x1 - x0, y1 - y0) 

363 

364 Image._decompression_bomb_check(dispose_size) 

365 

366 # by convention, attempt to use transparency first 

367 dispose_mode = "P" 

368 color = self.info.get("transparency", frame_transparency) 

369 if color is not None: 

370 if self.mode in ("RGB", "RGBA"): 

371 dispose_mode = "RGBA" 

372 color = _rgb(color) + (0,) 

373 else: 

374 color = self.info.get("background", 0) 

375 if self.mode in ("RGB", "RGBA"): 

376 dispose_mode = "RGB" 

377 color = _rgb(color) 

378 self.dispose = Image.core.fill(dispose_mode, dispose_size, color) 

379 else: 

380 # replace with previous contents 

381 if self._im is not None: 

382 # only dispose the extent in this frame 

383 self.dispose = self._crop(self.im, self.dispose_extent) 

384 elif frame_transparency is not None: 

385 x0, y0, x1, y1 = self.dispose_extent 

386 dispose_size = (x1 - x0, y1 - y0) 

387 

388 Image._decompression_bomb_check(dispose_size) 

389 dispose_mode = "P" 

390 color = frame_transparency 

391 if self.mode in ("RGB", "RGBA"): 

392 dispose_mode = "RGBA" 

393 color = _rgb(frame_transparency) + (0,) 

394 self.dispose = Image.core.fill( 

395 dispose_mode, dispose_size, color 

396 ) 

397 except AttributeError: 

398 pass 

399 

400 if interlace is not None: 

401 transparency = -1 

402 if frame_transparency is not None: 

403 if frame == 0: 

404 if LOADING_STRATEGY != LoadingStrategy.RGB_ALWAYS: 

405 self.info["transparency"] = frame_transparency 

406 elif self.mode not in ("RGB", "RGBA"): 

407 transparency = frame_transparency 

408 self.tile = [ 

409 ImageFile._Tile( 

410 "gif", 

411 (x0, y0, x1, y1), 

412 self.__offset, 

413 (bits, interlace, transparency), 

414 ) 

415 ] 

416 

417 if info.get("comment"): 

418 self.info["comment"] = info["comment"] 

419 for k in ["duration", "extension"]: 

420 if k in info: 

421 self.info[k] = info[k] 

422 elif k in self.info: 

423 del self.info[k] 

424 

425 def load_prepare(self) -> None: 

426 temp_mode = "P" if self._frame_palette else "L" 

427 self._prev_im = None 

428 if self.__frame == 0: 

429 if self._frame_transparency is not None: 

430 self.im = Image.core.fill( 

431 temp_mode, self.size, self._frame_transparency 

432 ) 

433 elif self.mode in ("RGB", "RGBA"): 

434 self._prev_im = self.im 

435 if self._frame_palette: 

436 self.im = Image.core.fill("P", self.size, self._frame_transparency or 0) 

437 self.im.putpalette("RGB", *self._frame_palette.getdata()) 

438 else: 

439 self._im = None 

440 if not self._prev_im and self._im is not None and self.size != self.im.size: 

441 expanded_im = Image.core.fill(self.im.mode, self.size) 

442 if self._frame_palette: 

443 expanded_im.putpalette("RGB", *self._frame_palette.getdata()) 

444 expanded_im.paste(self.im, (0, 0) + self.im.size) 

445 

446 self.im = expanded_im 

447 self._mode = temp_mode 

448 self._frame_palette = None 

449 

450 super().load_prepare() 

451 

452 def load_end(self) -> None: 

453 if self.__frame == 0: 

454 if self.mode == "P" and LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS: 

455 if self._frame_transparency is not None: 

456 self.im.putpalettealpha(self._frame_transparency, 0) 

457 self._mode = "RGBA" 

458 else: 

459 self._mode = "RGB" 

460 self.im = self.im.convert(self.mode, Image.Dither.FLOYDSTEINBERG) 

461 return 

462 if not self._prev_im: 

463 return 

464 if self.size != self._prev_im.size: 

465 if self._frame_transparency is not None: 

466 expanded_im = Image.core.fill("RGBA", self.size) 

467 else: 

468 expanded_im = Image.core.fill("P", self.size) 

469 expanded_im.putpalette("RGB", "RGB", self.im.getpalette()) 

470 expanded_im = expanded_im.convert("RGB") 

471 expanded_im.paste(self._prev_im, (0, 0) + self._prev_im.size) 

472 

473 self._prev_im = expanded_im 

474 assert self._prev_im is not None 

475 if self._frame_transparency is not None: 

476 self.im.putpalettealpha(self._frame_transparency, 0) 

477 frame_im = self.im.convert("RGBA") 

478 else: 

479 frame_im = self.im.convert("RGB") 

480 

481 assert self.dispose_extent is not None 

482 frame_im = self._crop(frame_im, self.dispose_extent) 

483 

484 self.im = self._prev_im 

485 self._mode = self.im.mode 

486 if frame_im.mode == "RGBA": 

487 self.im.paste(frame_im, self.dispose_extent, frame_im) 

488 else: 

489 self.im.paste(frame_im, self.dispose_extent) 

490 

491 def tell(self) -> int: 

492 return self.__frame 

493 

494 

495# -------------------------------------------------------------------- 

496# Write GIF files 

497 

498 

499RAWMODE = {"1": "L", "L": "L", "P": "P"} 

500 

501 

502def _normalize_mode(im: Image.Image) -> Image.Image: 

503 """ 

504 Takes an image (or frame), returns an image in a mode that is appropriate 

505 for saving in a Gif. 

506 

507 It may return the original image, or it may return an image converted to 

508 palette or 'L' mode. 

509 

510 :param im: Image object 

511 :returns: Image object 

512 """ 

513 if im.mode in RAWMODE: 

514 im.load() 

515 return im 

516 if Image.getmodebase(im.mode) == "RGB": 

517 im = im.convert("P", palette=Image.Palette.ADAPTIVE) 

518 assert im.palette is not None 

519 if im.palette.mode == "RGBA": 

520 for rgba in im.palette.colors: 

521 if rgba[3] == 0: 

522 im.info["transparency"] = im.palette.colors[rgba] 

523 break 

524 return im 

525 return im.convert("L") 

526 

527 

528_Palette = Union[bytes, bytearray, list[int], ImagePalette.ImagePalette] 

529 

530 

531def _normalize_palette( 

532 im: Image.Image, palette: _Palette | None, info: dict[str, Any] 

533) -> Image.Image: 

534 """ 

535 Normalizes the palette for image. 

536 - Sets the palette to the incoming palette, if provided. 

537 - Ensures that there's a palette for L mode images 

538 - Optimizes the palette if necessary/desired. 

539 

540 :param im: Image object 

541 :param palette: bytes object containing the source palette, or .... 

542 :param info: encoderinfo 

543 :returns: Image object 

544 """ 

545 source_palette = None 

546 if palette: 

547 # a bytes palette 

548 if isinstance(palette, (bytes, bytearray, list)): 

549 source_palette = bytearray(palette[:768]) 

550 if isinstance(palette, ImagePalette.ImagePalette): 

551 source_palette = bytearray(palette.palette) 

552 

553 if im.mode == "P": 

554 if not source_palette: 

555 im_palette = im.getpalette(None) 

556 assert im_palette is not None 

557 source_palette = bytearray(im_palette) 

558 else: # L-mode 

559 if not source_palette: 

560 source_palette = bytearray(i // 3 for i in range(768)) 

561 im.palette = ImagePalette.ImagePalette("RGB", palette=source_palette) 

562 assert source_palette is not None 

563 

564 if palette: 

565 used_palette_colors: list[int | None] = [] 

566 assert im.palette is not None 

567 for i in range(0, len(source_palette), 3): 

568 source_color = tuple(source_palette[i : i + 3]) 

569 index = im.palette.colors.get(source_color) 

570 if index in used_palette_colors: 

571 index = None 

572 used_palette_colors.append(index) 

573 for i, index in enumerate(used_palette_colors): 

574 if index is None: 

575 for j in range(len(used_palette_colors)): 

576 if j not in used_palette_colors: 

577 used_palette_colors[i] = j 

578 break 

579 dest_map: list[int] = [] 

580 for index in used_palette_colors: 

581 assert index is not None 

582 dest_map.append(index) 

583 im = im.remap_palette(dest_map) 

584 else: 

585 optimized_palette_colors = _get_optimize(im, info) 

586 if optimized_palette_colors is not None: 

587 im = im.remap_palette(optimized_palette_colors, source_palette) 

588 if "transparency" in info: 

589 try: 

590 info["transparency"] = optimized_palette_colors.index( 

591 info["transparency"] 

592 ) 

593 except ValueError: 

594 del info["transparency"] 

595 return im 

596 

597 assert im.palette is not None 

598 im.palette.palette = source_palette 

599 return im 

600 

601 

602def _write_single_frame( 

603 im: Image.Image, 

604 fp: IO[bytes], 

605 palette: _Palette | None, 

606) -> None: 

607 im_out = _normalize_mode(im) 

608 for k, v in im_out.info.items(): 

609 if isinstance(k, str): 

610 im.encoderinfo.setdefault(k, v) 

611 im_out = _normalize_palette(im_out, palette, im.encoderinfo) 

612 

613 for s in _get_global_header(im_out, im.encoderinfo): 

614 fp.write(s) 

615 

616 # local image header 

617 flags = 0 

618 if get_interlace(im): 

619 flags = flags | 64 

620 _write_local_header(fp, im, (0, 0), flags) 

621 

622 im_out.encoderconfig = (8, get_interlace(im)) 

623 ImageFile._save( 

624 im_out, fp, [ImageFile._Tile("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])] 

625 ) 

626 

627 fp.write(b"\0") # end of image data 

628 

629 

630def _getbbox( 

631 base_im: Image.Image, im_frame: Image.Image 

632) -> tuple[Image.Image, tuple[int, int, int, int] | None]: 

633 palette_bytes = [ 

634 bytes(im.palette.palette) if im.palette else b"" for im in (base_im, im_frame) 

635 ] 

636 if palette_bytes[0] != palette_bytes[1]: 

637 im_frame = im_frame.convert("RGBA") 

638 base_im = base_im.convert("RGBA") 

639 delta = ImageChops.subtract_modulo(im_frame, base_im) 

640 return delta, delta.getbbox(alpha_only=False) 

641 

642 

643class _Frame(NamedTuple): 

644 im: Image.Image 

645 bbox: tuple[int, int, int, int] | None 

646 encoderinfo: dict[str, Any] 

647 

648 

649def _write_multiple_frames( 

650 im: Image.Image, fp: IO[bytes], palette: _Palette | None 

651) -> bool: 

652 duration = im.encoderinfo.get("duration") 

653 disposal = im.encoderinfo.get("disposal", im.info.get("disposal")) 

654 

655 im_frames: list[_Frame] = [] 

656 previous_im: Image.Image | None = None 

657 frame_count = 0 

658 background_im = None 

659 for imSequence in itertools.chain([im], im.encoderinfo.get("append_images", [])): 

660 for im_frame in ImageSequence.Iterator(imSequence): 

661 # a copy is required here since seek can still mutate the image 

662 im_frame = _normalize_mode(im_frame.copy()) 

663 if frame_count == 0: 

664 for k, v in im_frame.info.items(): 

665 if k == "transparency": 

666 continue 

667 if isinstance(k, str): 

668 im.encoderinfo.setdefault(k, v) 

669 

670 encoderinfo = im.encoderinfo.copy() 

671 if "transparency" in im_frame.info: 

672 encoderinfo.setdefault("transparency", im_frame.info["transparency"]) 

673 im_frame = _normalize_palette(im_frame, palette, encoderinfo) 

674 if isinstance(duration, (list, tuple)): 

675 encoderinfo["duration"] = duration[frame_count] 

676 elif duration is None and "duration" in im_frame.info: 

677 encoderinfo["duration"] = im_frame.info["duration"] 

678 if isinstance(disposal, (list, tuple)): 

679 encoderinfo["disposal"] = disposal[frame_count] 

680 frame_count += 1 

681 

682 diff_frame = None 

683 if im_frames and previous_im: 

684 # delta frame 

685 delta, bbox = _getbbox(previous_im, im_frame) 

686 if not bbox: 

687 # This frame is identical to the previous frame 

688 if encoderinfo.get("duration"): 

689 im_frames[-1].encoderinfo["duration"] += encoderinfo["duration"] 

690 continue 

691 if im_frames[-1].encoderinfo.get("disposal") == 2: 

692 if background_im is None: 

693 color = im.encoderinfo.get( 

694 "transparency", im.info.get("transparency", (0, 0, 0)) 

695 ) 

696 background = _get_background(im_frame, color) 

697 background_im = Image.new("P", im_frame.size, background) 

698 first_palette = im_frames[0].im.palette 

699 assert first_palette is not None 

700 background_im.putpalette(first_palette, first_palette.mode) 

701 bbox = _getbbox(background_im, im_frame)[1] 

702 elif encoderinfo.get("optimize") and im_frame.mode != "1": 

703 if "transparency" not in encoderinfo: 

704 assert im_frame.palette is not None 

705 try: 

706 encoderinfo["transparency"] = ( 

707 im_frame.palette._new_color_index(im_frame) 

708 ) 

709 except ValueError: 

710 pass 

711 if "transparency" in encoderinfo: 

712 # When the delta is zero, fill the image with transparency 

713 diff_frame = im_frame.copy() 

714 fill = Image.new("P", delta.size, encoderinfo["transparency"]) 

715 if delta.mode == "RGBA": 

716 r, g, b, a = delta.split() 

717 mask = ImageMath.lambda_eval( 

718 lambda args: args["convert"]( 

719 args["max"]( 

720 args["max"]( 

721 args["max"](args["r"], args["g"]), args["b"] 

722 ), 

723 args["a"], 

724 ) 

725 * 255, 

726 "1", 

727 ), 

728 r=r, 

729 g=g, 

730 b=b, 

731 a=a, 

732 ) 

733 else: 

734 if delta.mode == "P": 

735 # Convert to L without considering palette 

736 delta_l = Image.new("L", delta.size) 

737 delta_l.putdata(delta.getdata()) 

738 delta = delta_l 

739 mask = ImageMath.lambda_eval( 

740 lambda args: args["convert"](args["im"] * 255, "1"), 

741 im=delta, 

742 ) 

743 diff_frame.paste(fill, mask=ImageOps.invert(mask)) 

744 else: 

745 bbox = None 

746 previous_im = im_frame 

747 im_frames.append(_Frame(diff_frame or im_frame, bbox, encoderinfo)) 

748 

749 if len(im_frames) == 1: 

750 if "duration" in im.encoderinfo: 

751 # Since multiple frames will not be written, use the combined duration 

752 im.encoderinfo["duration"] = im_frames[0].encoderinfo["duration"] 

753 return False 

754 

755 for frame_data in im_frames: 

756 im_frame = frame_data.im