Pillow/PIL/GifImagePlugin.py

806 lines
26 KiB
Python
Raw Normal View History

2010-07-31 06:52:47 +04:00
#
# The Python Imaging Library.
# $Id$
#
# GIF file handling
#
# History:
# 1995-09-01 fl Created
# 1996-12-14 fl Added interlace support
# 1996-12-30 fl Added animation support
# 1997-01-05 fl Added write support, fixed local colour map bug
# 1997-02-23 fl Make sure to load raster data in getdata()
# 1997-07-05 fl Support external decoder (0.4)
# 1998-07-09 fl Handle all modes when saving (0.5)
# 1998-07-15 fl Renamed offset attribute to avoid name clash
# 2001-04-16 fl Added rewind support (seek to frame 0) (0.6)
# 2001-04-17 fl Added palette optimization (0.7)
# 2002-06-06 fl Added transparency support for save (0.8)
# 2004-02-24 fl Disable interlacing for small images
#
# Copyright (c) 1997-2004 by Secret Labs AB
# Copyright (c) 1995-2004 by Fredrik Lundh
#
# See the README file for information on usage and redistribution.
#
2017-03-03 18:51:07 +03:00
from . import Image, ImageFile, ImagePalette, ImageChops, ImageSequence
from ._binary import i8, i16le as i16, o8, o16le as o16
2010-07-31 06:52:47 +04:00
import itertools
2010-07-31 06:52:47 +04:00
__version__ = "0.9"
# --------------------------------------------------------------------
# Identify/read GIF files
def _accept(prefix):
return prefix[:6] in [b"GIF87a", b"GIF89a"]
2010-07-31 06:52:47 +04:00
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
##
# Image plugin for GIF images. This plugin supports both GIF87 and
# GIF89 images.
class GifImageFile(ImageFile.ImageFile):
format = "GIF"
format_description = "Compuserve GIF"
_close_exclusive_fp_after_loading = False
2010-07-31 06:52:47 +04:00
global_palette = None
def data(self):
s = self.fp.read(1)
if s and i8(s):
return self.fp.read(i8(s))
2010-07-31 06:52:47 +04:00
return None
def _open(self):
# Screen
s = self.fp.read(13)
if s[:6] not in [b"GIF87a", b"GIF89a"]:
raise SyntaxError("not a GIF file")
2010-07-31 06:52:47 +04:00
self.info["version"] = s[:6]
self.size = i16(s[6:]), i16(s[8:])
self.tile = []
flags = i8(s[10])
2010-07-31 06:52:47 +04:00
bits = (flags & 7) + 1
if flags & 128:
# get global palette
self.info["background"] = i8(s[11])
2010-07-31 06:52:47 +04:00
# check if palette contains colour indices
2014-08-26 17:47:10 +04:00
p = self.fp.read(3 << bits)
2010-07-31 06:52:47 +04:00
for i in range(0, len(p), 3):
if not (i//3 == i8(p[i]) == i8(p[i+1]) == i8(p[i+2])):
2010-07-31 06:52:47 +04:00
p = ImagePalette.raw("RGB", p)
self.global_palette = self.palette = p
break
2014-08-26 17:47:10 +04:00
self.__fp = self.fp # FIXME: hack
2010-07-31 06:52:47 +04:00
self.__rewind = self.fp.tell()
self._n_frames = None
2015-06-30 06:25:00 +03:00
self._is_animated = None
self._seek(0) # get ready to read first frame
@property
def n_frames(self):
if self._n_frames is None:
current = self.tell()
try:
while True:
self.seek(self.tell() + 1)
except EOFError:
self._n_frames = self.tell() + 1
self.seek(current)
return self._n_frames
2010-07-31 06:52:47 +04:00
2015-06-30 06:25:00 +03:00
@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()
try:
self.seek(1)
self._is_animated = True
except EOFError:
self._is_animated = False
self.seek(current)
2015-06-30 06:25:00 +03:00
return self._is_animated
2010-07-31 06:52:47 +04:00
def seek(self, frame):
if frame == self.__frame:
return
if frame < self.__frame:
self._seek(0)
last_frame = self.__frame
for f in range(self.__frame + 1, frame + 1):
try:
self._seek(f)
except EOFError:
self.seek(last_frame)
raise EOFError("no more images in GIF file")
def _seek(self, frame):
2010-07-31 06:52:47 +04:00
if frame == 0:
# rewind
self.__offset = 0
self.dispose = None
2014-08-26 17:47:10 +04:00
self.dispose_extent = [0, 0, 0, 0] # x0, y0, x1, y1
2010-07-31 06:52:47 +04:00
self.__frame = -1
self.__fp.seek(self.__rewind)
self._prev_im = None
self.disposal_method = 0
else:
# ensure that the previous frame was loaded
if not self.im:
self.load()
2010-07-31 06:52:47 +04:00
if frame != self.__frame + 1:
raise ValueError("cannot seek to frame %d" % frame)
2010-07-31 06:52:47 +04:00
self.__frame = frame
self.tile = []
self.fp = self.__fp
if self.__offset:
# backup to last frame
self.fp.seek(self.__offset)
while self.data():
pass
self.__offset = 0
if self.dispose:
self.im.paste(self.dispose, self.dispose_extent)
2010-07-31 06:52:47 +04:00
from copy import copy
self.palette = copy(self.global_palette)
2010-07-31 06:52:47 +04:00
while True:
2010-07-31 06:52:47 +04:00
s = self.fp.read(1)
if not s or s == b";":
2010-07-31 06:52:47 +04:00
break
elif s == b"!":
2010-07-31 06:52:47 +04:00
#
# extensions
#
s = self.fp.read(1)
block = self.data()
if i8(s) == 249:
2010-07-31 06:52:47 +04:00
#
# graphic control extension
#
flags = i8(block[0])
2010-07-31 06:52:47 +04:00
if flags & 1:
self.info["transparency"] = i8(block[3])
2010-07-31 06:52:47 +04:00
self.info["duration"] = i16(block[1:3]) * 10
# disposal method - find the value of bits 4 - 6
dispose_bits = 0b00011100 & flags
dispose_bits = dispose_bits >> 2
if dispose_bits:
# only set the dispose if it is not
# unspecified. I'm not sure if this is
# correct, but it seems to prevent the last
# frame from looking odd for some animations
self.disposal_method = dispose_bits
elif i8(s) == 254:
#
# comment extension
#
self.info["comment"] = block
elif i8(s) == 255:
2010-07-31 06:52:47 +04:00
#
# application extension
#
self.info["extension"] = block, self.fp.tell()
if block[:11] == b"NETSCAPE2.0":
2010-07-31 06:52:47 +04:00
block = self.data()
if len(block) >= 3 and i8(block[0]) == 1:
2010-07-31 06:52:47 +04:00
self.info["loop"] = i16(block[1:3])
while self.data():
pass
elif s == b",":
2010-07-31 06:52:47 +04:00
#
# local image
#
s = self.fp.read(9)
# extent
x0, y0 = i16(s[0:]), i16(s[2:])
x1, y1 = x0 + i16(s[4:]), y0 + i16(s[6:])
self.dispose_extent = x0, y0, x1, y1
flags = i8(s[8])
2010-07-31 06:52:47 +04:00
interlace = (flags & 64) != 0
if flags & 128:
bits = (flags & 7) + 1
self.palette =\
2014-08-26 17:47:10 +04:00
ImagePalette.raw("RGB", self.fp.read(3 << bits))
2010-07-31 06:52:47 +04:00
# image data
bits = i8(self.fp.read(1))
2010-07-31 06:52:47 +04:00
self.__offset = self.fp.tell()
self.tile = [("gif",
(x0, y0, x1, y1),
self.__offset,
(bits, interlace))]
break
else:
pass
# raise IOError, "illegal GIF tag `%x`" % i8(s)
2010-07-31 06:52:47 +04:00
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 = Image.core.fill("P", self.size,
self.info["background"])
else:
# replace with previous contents
if self.im:
self.dispose = self.im.copy()
# only dispose the extent in this frame
if self.dispose:
self.dispose = self._crop(self.dispose, self.dispose_extent)
except (AttributeError, KeyError):
pass
2010-07-31 06:52:47 +04:00
if not self.tile:
# self.__fp = None
raise EOFError
2010-07-31 06:52:47 +04:00
self.mode = "L"
if self.palette:
self.mode = "P"
def tell(self):
return self.__frame
def load_end(self):
ImageFile.ImageFile.load_end(self)
# if the disposal method is 'do not dispose', transparent
# pixels should show the content of the previous frame
if self._prev_im and self.disposal_method == 1:
# we do this by pasting the updated area onto the previous
# frame which we then use as the current image content
updated = self._crop(self.im, self.dispose_extent)
2014-08-26 17:47:10 +04:00
self._prev_im.paste(updated, self.dispose_extent,
updated.convert('RGBA'))
self.im = self._prev_im
self._prev_im = self.im.copy()
2010-07-31 06:52:47 +04:00
# --------------------------------------------------------------------
# Write GIF files
RAWMODE = {
"1": "L",
"L": "L",
2017-01-28 03:45:59 +03:00
"P": "P"
2010-07-31 06:52:47 +04:00
}
2015-07-01 02:18:05 +03:00
def _normalize_mode(im, initial_call=False):
2017-03-03 18:51:07 +03:00
"""
Takes an image (or frame), returns an image in a mode that is appropriate
for saving in a Gif.
It may return the original image, or it may return an image converted to
palette or 'L' mode.
UNDONE: What is the point of mucking with the initial call palette, for
an image that shouldn't have a palette, or it would be a mode 'P' and
get returned in the RAWMODE clause.
2017-04-20 14:14:23 +03:00
2017-03-03 18:51:07 +03:00
:param im: Image object
:param initial_call: Default false, set to true for a single frame.
:returns: Image object
"""
if im.mode in RAWMODE:
2017-02-23 18:37:14 +03:00
im.load()
return im
2015-07-01 02:18:05 +03:00
if Image.getmodebase(im.mode) == "RGB":
2015-08-24 16:23:07 +03:00
if initial_call:
palette_size = 256
if im.palette:
palette_size = len(im.palette.getdata()[1]) // 3
return im.convert("P", palette=Image.ADAPTIVE, colors=palette_size)
2015-08-24 16:23:07 +03:00
else:
return im.convert("P")
2015-07-01 02:18:05 +03:00
return im.convert("L")
2017-04-20 14:14:23 +03:00
2017-03-03 18:51:31 +03:00
def _normalize_palette(im, palette, info):
"""
Normalizes the palette for image.
- Sets the palette to the incoming palette, if provided.
- Ensures that there's a palette for L mode images
- Optimizes the palette if necessary/desired.
:param im: Image object
:param palette: bytes object containing the source palette, or ....
2017-04-20 14:14:23 +03:00
:param info: encoderinfo
2017-03-03 18:51:31 +03:00
:returns: Image object
"""
source_palette = None
if palette:
# a bytes palette
if isinstance(palette, (bytes, bytearray, list)):
source_palette = bytearray(palette[:768])
if isinstance(palette, ImagePalette.ImagePalette):
source_palette = bytearray(itertools.chain.from_iterable(
zip(palette.palette[:256],
palette.palette[256:512],
palette.palette[512:768])))
2017-04-20 14:14:23 +03:00
2017-03-03 18:51:31 +03:00
if im.mode == "P":
if not source_palette:
2017-03-03 18:51:31 +03:00
source_palette = im.im.getpalette("RGB")[:768]
else: # L-mode
if not source_palette:
2017-03-03 18:51:31 +03:00
source_palette = bytearray(i//3 for i in range(768))
im.palette = ImagePalette.ImagePalette("RGB",
palette=source_palette)
used_palette_colors = _get_optimize(im, info)
if used_palette_colors is not None:
return im.remap_palette(used_palette_colors, source_palette)
im.palette.palette = source_palette
return im
2017-04-20 14:14:23 +03:00
def _write_single_frame(im, fp, palette):
im_out = _normalize_mode(im, True)
im_out = _normalize_palette(im_out, palette, im.encoderinfo)
for s in _get_global_header(im_out, im.encoderinfo):
fp.write(s)
# local image header
flags = 0
if get_interlace(im):
flags = flags | 64
_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])])
fp.write(b"\0") # end of image data
2017-04-20 14:14:23 +03:00
def _write_multiple_frames(im, fp, palette):
2017-02-23 18:37:14 +03:00
duration = im.encoderinfo.get("duration", None)
im_frames = []
frame_count = 0
for imSequence in [im]+im.encoderinfo.get("append_images", []):
for im_frame in ImageSequence.Iterator(imSequence):
2017-02-23 18:37:14 +03:00
# a copy is required here since seek can still mutate the image
im_frame = _normalize_mode(im_frame.copy())
2017-02-23 17:57:10 +03:00
im_frame = _normalize_palette(im_frame, palette, im.encoderinfo)
encoderinfo = im.encoderinfo.copy()
if isinstance(duration, (list, tuple)):
encoderinfo['duration'] = duration[frame_count]
frame_count += 1
if im_frames:
# delta frame
previous = im_frames[-1]
if _get_palette_bytes(im_frame) == _get_palette_bytes(previous['im']):
delta = ImageChops.subtract_modulo(im_frame,
previous['im'])
else:
delta = ImageChops.subtract_modulo(im_frame.convert('RGB'),
previous['im'].convert('RGB'))
bbox = delta.getbbox()
if not bbox:
# This frame is identical to the previous frame
if duration:
previous['encoderinfo']['duration'] += encoderinfo['duration']
continue
else:
bbox = None
im_frames.append({
2017-04-20 14:14:23 +03:00
'im': im_frame,
'bbox': bbox,
'encoderinfo': 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
frame_data['encoderinfo']['include_color_table'] = True
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
2015-07-01 02:18:05 +03:00
2017-04-20 14:14:23 +03:00
2015-06-30 11:02:48 +03:00
def _save_all(im, fp, filename):
_save(im, fp, filename, save_all=True)
2014-08-26 17:47:10 +04:00
2015-07-01 02:18:05 +03:00
2015-06-30 11:02:48 +03:00
def _save(im, fp, filename, save_all=False):
im.encoderinfo.update(im.info)
2010-07-31 06:52:47 +04:00
# header
try:
palette = im.encoderinfo["palette"]
except KeyError:
palette = None
im.encoderinfo["optimize"] = im.encoderinfo.get("optimize", True)
2013-05-23 17:45:11 +04:00
if not save_all or not _write_multiple_frames(im, fp, palette):
_write_single_frame(im, fp, palette)
2015-04-03 15:22:13 +03:00
fp.write(b";") # end of file
2010-07-31 06:52:47 +04:00
2015-12-09 07:47:53 +03:00
if hasattr(fp, "flush"):
2015-04-03 15:22:13 +03:00
fp.flush()
2010-07-31 06:52:47 +04:00
2015-04-23 16:40:42 +03:00
2015-04-03 15:22:13 +03:00
def get_interlace(im):
interlace = im.encoderinfo.get("interlace", 1)
2010-07-31 06:52:47 +04:00
# workaround for @PIL153
if min(im.size) < 16:
interlace = 0
2015-04-03 15:22:13 +03:00
return interlace
2010-07-31 06:52:47 +04:00
def _write_local_header(fp, im, offset, flags):
2015-04-03 15:22:13 +03:00
transparent_color_exists = False
2010-07-31 06:52:47 +04:00
try:
transparency = im.encoderinfo["transparency"]
except KeyError:
pass
else:
transparency = int(transparency)
# optimize the block away if transparent color is not used
2015-04-01 16:47:01 +03:00
transparent_color_exists = True
2010-07-31 06:52:47 +04:00
used_palette_colors = _get_optimize(im, im.encoderinfo)
if used_palette_colors is not None:
# adjust the transparency index after optimize
2016-12-28 01:48:16 +03:00
try:
transparency = used_palette_colors.index(transparency)
except ValueError:
transparent_color_exists = False
2015-04-04 02:32:17 +03:00
if "duration" in im.encoderinfo:
2015-04-04 03:45:30 +03:00
duration = int(im.encoderinfo["duration"] / 10)
2015-04-03 15:22:13 +03:00
else:
duration = 0
if transparent_color_exists or duration != 0:
transparency_flag = 1 if transparent_color_exists else 0
if not transparent_color_exists:
transparency = 0
2015-04-23 16:40:42 +03:00
2015-04-03 15:22:13 +03:00
fp.write(b"!" +
2015-04-23 16:40:42 +03:00
o8(249) + # extension intro
o8(4) + # length
o8(transparency_flag) + # packed fields
2015-04-23 16:40:42 +03:00
o16(duration) + # duration
o8(transparency) + # transparency index
2015-04-03 15:22:13 +03:00
o8(0))
if "comment" in im.encoderinfo and 1 <= len(im.encoderinfo["comment"]) <= 255:
fp.write(b"!" +
o8(254) + # extension intro
o8(len(im.encoderinfo["comment"])) +
im.encoderinfo["comment"] +
o8(0))
2015-04-04 02:32:17 +03:00
if "loop" in im.encoderinfo:
number_of_loops = im.encoderinfo["loop"]
fp.write(b"!" +
2015-04-23 16:40:42 +03:00
o8(255) + # extension intro
2015-04-04 03:45:30 +03:00
o8(11) +
2015-04-04 02:32:17 +03:00
b"NETSCAPE2.0" +
o8(3) +
o8(1) +
2015-04-23 16:40:42 +03:00
o16(number_of_loops) + # number of loops
2015-04-04 02:32:17 +03:00
o8(0))
include_color_table = im.encoderinfo.get('include_color_table')
if include_color_table:
palette = im.encoderinfo.get("palette", None)
palette_bytes = _get_palette_bytes(im)
color_table_size = _get_color_table_size(palette_bytes)
if color_table_size:
flags = flags | 128 # local color table flag
flags = flags | color_table_size
fp.write(b"," +
2015-04-23 16:40:42 +03:00
o16(offset[0]) + # offset
2015-04-03 15:22:13 +03:00
o16(offset[1]) +
2015-04-23 16:40:42 +03:00
o16(im.size[0]) + # size
2010-07-31 06:52:47 +04:00
o16(im.size[1]) +
o8(flags)) # flags
if include_color_table and color_table_size:
fp.write(_get_header_palette(palette_bytes))
fp.write(o8(8)) # bits
2013-05-23 17:45:11 +04:00
2010-07-31 06:52:47 +04:00
def _save_netpbm(im, fp, filename):
2017-01-26 05:51:20 +03:00
# Unused by default.
# To use, uncomment the register_save call at the end of the file.
2010-07-31 06:52:47 +04:00
#
# If you need real GIF compression and/or RGB quantization, you
# can use the external NETPBM/PBMPLUS utilities. See comments
# below for information on how to enable this.
import os
2014-06-27 19:02:36 +04:00
from subprocess import Popen, check_call, PIPE, CalledProcessError
2010-07-31 06:52:47 +04:00
file = im._dump()
2016-12-28 01:54:10 +03:00
with open(filename, 'wb') as f:
if im.mode != "RGB":
with open(os.devnull, 'wb') as devnull:
check_call(["ppmtogif", file], stdout=f, stderr=devnull)
2016-12-28 01:54:10 +03:00
else:
2014-06-27 19:02:36 +04:00
# Pipe ppmquant output into ppmtogif
# "ppmquant 256 %s | ppmtogif > %s" % (file, filename)
quant_cmd = ["ppmquant", "256", file]
togif_cmd = ["ppmtogif"]
with open(os.devnull, 'wb') as devnull:
quant_proc = Popen(quant_cmd, stdout=PIPE, stderr=devnull)
2016-12-28 01:54:10 +03:00
togif_proc = Popen(togif_cmd, stdin=quant_proc.stdout,
stdout=f, stderr=devnull)
2014-08-26 17:47:10 +04:00
2014-06-27 19:02:36 +04:00
# Allow ppmquant to receive SIGPIPE if ppmtogif exits
quant_proc.stdout.close()
retcode = quant_proc.wait()
if retcode:
raise CalledProcessError(retcode, quant_cmd)
retcode = togif_proc.wait()
if retcode:
raise CalledProcessError(retcode, togif_cmd)
try:
os.unlink(file)
2015-12-02 08:23:49 +03:00
except OSError:
pass
2010-07-31 06:52:47 +04:00
# Force optimization so that we can test performance against
# cases where it took lots of memory and time previously.
_FORCE_OPTIMIZE = False
2017-04-20 14:14:23 +03:00
def _get_optimize(im, info):
"""
Palette optimization is a potentially expensive operation.
This function determines if the palette should be optimized using
some heuristics, then returns the list of palette entries in use.
:param im: Image object
: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):
# Potentially expensive operation.
# The palette saves 3 bytes per color not used, but palette
# lengths are restricted to 3*(2**N) bytes. Max saving would
# be 768 -> 6 bytes if we went all the way down to 2 colors.
# * If we're over 128 colors, we can't save any space.
# * If there aren't any holes, it's not worth collapsing.
# * If we have a 'large' image, the palette is in the noise.
# create the new palette if not every color is used
optimise = _FORCE_OPTIMIZE or im.mode == 'L'
if optimise or im.width * im.height < 512 * 512:
# check which colors are used
used_palette_colors = []
for i, count in enumerate(im.histogram()):
if count:
used_palette_colors.append(i)
if optimise or (len(used_palette_colors) <= 128 and
2017-04-20 14:14:23 +03:00
max(used_palette_colors) > len(used_palette_colors)):
return used_palette_colors
2017-04-20 14:14:23 +03:00
def _get_color_table_size(palette_bytes):
# calculate the palette size for the header
import math
color_table_size = int(math.ceil(math.log(len(palette_bytes)//3, 2)))-1
if color_table_size < 0:
color_table_size = 0
return color_table_size
2017-04-20 14:14:23 +03:00
def _get_header_palette(palette_bytes):
2017-02-23 18:58:30 +03:00
"""
Returns the palette, null padded to the next power of 2 (*3) bytes
suitable for direct inclusion in the GIF header
:param palette_bytes: Unpadded palette bytes, in RGBRGB form
:returns: Null padded palette
"""
color_table_size = _get_color_table_size(palette_bytes)
# add the missing amount of bytes
# the palette has to be 2<<n in size
actual_target_size_diff = (2 << color_table_size) - len(palette_bytes)//3
if actual_target_size_diff > 0:
palette_bytes += o8(0) * 3 * actual_target_size_diff
return palette_bytes
2013-05-23 17:45:11 +04:00
2017-04-20 14:14:23 +03:00
def _get_palette_bytes(im):
2017-04-20 14:14:23 +03:00
"""
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
def _get_global_header(im, info):
"""Return a list of strings representing a GIF header"""
# Header Block
# http://www.matthewflickinger.com/lab/whatsinagif/bits_and_bytes.asp
version = b"87a"
for extensionKey in ["transparency", "duration", "loop", "comment"]:
if info and extensionKey in info:
if ((extensionKey == "duration" and info[extensionKey] == 0) or
2017-04-20 14:14:23 +03:00
(extensionKey == "comment" and not (1 <= len(info[extensionKey]) <= 255))):
continue
version = b"89a"
break
else:
if im.info.get("version") == b"89a":
version = b"89a"
palette_bytes = _get_palette_bytes(im)
color_table_size = _get_color_table_size(palette_bytes)
background = info["background"] if "background" in info else 0
return [
b"GIF"+version + # signature + version
o16(im.size[0]) + # canvas width
o16(im.size[1]), # canvas height
# Logical Screen Descriptor
# size of global color table + global color table flag
o8(color_table_size + 128), # packed fields
# background + reserved/aspect
2017-04-20 14:14:23 +03:00
o8(background) + o8(0),
# Global Color Table
_get_header_palette(palette_bytes)
]
2017-04-20 14:14:23 +03:00
def _write_frame_data(fp, im_frame, offset, params):
try:
im_frame.encoderinfo = params
# local image header
_write_local_header(fp, im_frame, offset, 0)
ImageFile._save(im_frame, fp, [("gif", (0, 0)+im_frame.size, 0,
RAWMODE[im_frame.mode])])
fp.write(b"\0") # end of image data
finally:
del im_frame.encoderinfo
# --------------------------------------------------------------------
# Legacy GIF utilities
2017-04-20 14:14:23 +03:00
2017-03-07 12:32:01 +03:00
def getheader(im, palette=None, info=None):
2017-02-23 18:58:30 +03:00
"""
Legacy Method to get Gif data from image.
Warning:: May modify image data.
:param im: Image object
:param palette: bytes object containing the source palette, or ....
2017-04-20 14:14:23 +03:00
:param info: encoderinfo
2017-02-23 18:58:30 +03:00
:returns: tuple of(list of header items, optimized palette)
"""
used_palette_colors = _get_optimize(im, info)
2017-03-07 12:32:01 +03:00
if info is None:
info = {}
2017-04-20 14:14:23 +03:00
if "background" not in info and "background" in im.info:
info["background"] = im.info["background"]
2017-02-23 18:59:06 +03:00
im_mod = _normalize_palette(im, palette, info)
im.palette = im_mod.palette
im.im = im_mod.im
header = _get_global_header(im, info)
2013-05-23 17:45:11 +04:00
2015-04-01 16:47:01 +03:00
return header, used_palette_colors
2013-05-23 17:45:11 +04:00
2017-04-20 14:14:23 +03:00
# To specify duration, add the time in milliseconds to getdata(),
# e.g. getdata(im_frame, duration=1000)
2014-08-26 17:47:10 +04:00
def getdata(im, offset=(0, 0), **params):
2017-02-25 05:50:49 +03:00
"""
Legacy Method
Return a list of strings representing this image.
The first string is a local image header, the rest contains
encoded image data.
2010-07-31 06:52:47 +04:00
:param im: Image object
:param offset: Tuple of (x, y) pixels. Defaults to (0,0)
2017-09-20 13:47:35 +03:00
:param \**params: E.g. duration or other encoder info parameters
:returns: List of Bytes containing gif encoded frame data
2017-02-25 05:50:49 +03:00
"""
2015-05-26 17:07:21 +03:00
class Collector(object):
2010-07-31 06:52:47 +04:00
data = []
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
def write(self, data):
self.data.append(data)
2014-08-26 17:47:10 +04:00
im.load() # make sure raster data is available
2010-07-31 06:52:47 +04:00
2015-04-01 16:47:01 +03:00
fp = Collector()
2010-07-31 06:52:47 +04:00
_write_frame_data(fp, im, offset, params)
2010-07-31 06:52:47 +04:00
return fp.data
# --------------------------------------------------------------------
# Registry
Image.register_open(GifImageFile.format, GifImageFile, _accept)
Image.register_save(GifImageFile.format, _save)
2015-06-30 11:02:48 +03:00
Image.register_save_all(GifImageFile.format, _save_all)
2010-07-31 06:52:47 +04:00
Image.register_extension(GifImageFile.format, ".gif")
Image.register_mime(GifImageFile.format, "image/gif")
#
# Uncomment the following line if you wish to use NETPBM/PBMPLUS
# instead of the built-in "uncompressed" GIF encoder
# Image.register_save(GifImageFile.format, _save_netpbm)