mirror of
https://github.com/python-pillow/Pillow.git
synced 2025-10-30 23:47:27 +03:00
remove extra i8 calls where input is proved bytes[] or int
This commit is contained in:
Alexander
Andrew Murray
parent
85d61ca7d5
commit
3757b8c748
|
|
@ -25,7 +25,6 @@
|
|||
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import i32le as i32
|
||||
from ._binary import o8
|
||||
|
|
@ -97,7 +96,7 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
# --------------------------------------------- Windows Bitmap v2 to v5
|
||||
# v3, OS/2 v2, v4, v5
|
||||
elif file_info["header_size"] in (40, 64, 108, 124):
|
||||
file_info["y_flip"] = i8(header_data[7]) == 0xFF
|
||||
file_info["y_flip"] = header_data[7] == 0xFF
|
||||
file_info["direction"] = 1 if file_info["y_flip"] else -1
|
||||
file_info["width"] = i32(header_data[0:4])
|
||||
file_info["height"] = (
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@
|
|||
# See the README file for information on usage and redistribution.
|
||||
#
|
||||
from . import BmpImagePlugin, Image
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import i32le as i32
|
||||
|
||||
|
|
@ -52,7 +51,7 @@ class CurImageFile(BmpImagePlugin.BmpImageFile):
|
|||
s = self.fp.read(16)
|
||||
if not m:
|
||||
m = s
|
||||
elif i8(s[0]) > i8(m[0]) and i8(s[1]) > i8(m[1]):
|
||||
elif s[0] > m[0] and s[1] > m[1]:
|
||||
m = s
|
||||
if not m:
|
||||
raise TypeError("No cursors were found")
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import i32le as i32
|
||||
from ._binary import o8
|
||||
|
|
@ -102,15 +101,15 @@ class FliImageFile(ImageFile.ImageFile):
|
|||
i = 0
|
||||
for e in range(i16(self.fp.read(2))):
|
||||
s = self.fp.read(2)
|
||||
i = i + i8(s[0])
|
||||
n = i8(s[1])
|
||||
i = i + s[0]
|
||||
n = s[1]
|
||||
if n == 0:
|
||||
n = 256
|
||||
s = self.fp.read(n * 3)
|
||||
for n in range(0, len(s), 3):
|
||||
r = i8(s[n]) << shift
|
||||
g = i8(s[n + 1]) << shift
|
||||
b = i8(s[n + 2]) << shift
|
||||
r = s[n] << shift
|
||||
g = s[n + 1] << shift
|
||||
b = s[n + 2] << shift
|
||||
palette[i] = (r, g, b)
|
||||
i += 1
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@
|
|||
import olefile
|
||||
|
||||
from . import Image, ImageFile
|
||||
from ._binary import i8
|
||||
from ._binary import i32le as i32
|
||||
|
||||
# we map from colour field tuples to (mode, rawmode) descriptors
|
||||
|
|
@ -181,8 +180,8 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
|
||||
elif compression == 2:
|
||||
|
||||
internal_color_conversion = i8(s[14])
|
||||
jpeg_tables = i8(s[15])
|
||||
internal_color_conversion = s[14]
|
||||
jpeg_tables = s[15]
|
||||
rawmode = self.rawmode
|
||||
|
||||
if internal_color_conversion:
|
||||
|
|
|
|||
|
|
@ -28,7 +28,6 @@
|
|||
|
||||
|
||||
from . import ImageFile, ImagePalette, UnidentifiedImageError
|
||||
from ._binary import i8
|
||||
from ._binary import i16be as i16
|
||||
from ._binary import i32be as i32
|
||||
|
||||
|
|
@ -55,7 +54,7 @@ class GdImageFile(ImageFile.ImageFile):
|
|||
self.mode = "L" # FIXME: "P"
|
||||
self._size = i16(s[2:4]), i16(s[4:6])
|
||||
|
||||
trueColor = i8(s[6])
|
||||
trueColor = s[6]
|
||||
trueColorOffset = 2 if trueColor else 0
|
||||
|
||||
# transparency index
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@ import os
|
|||
import subprocess
|
||||
|
||||
from . import Image, ImageChops, ImageFile, ImagePalette, ImageSequence
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import o8
|
||||
from ._binary import o16le as o16
|
||||
|
|
@ -58,8 +57,8 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
|
||||
def data(self):
|
||||
s = self.fp.read(1)
|
||||
if s and i8(s):
|
||||
return self.fp.read(i8(s))
|
||||
if s and s[0]:
|
||||
return self.fp.read(s[0])
|
||||
return None
|
||||
|
||||
def _open(self):
|
||||
|
|
@ -72,16 +71,16 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
self.info["version"] = s[:6]
|
||||
self._size = i16(s[6:]), i16(s[8:])
|
||||
self.tile = []
|
||||
flags = i8(s[10])
|
||||
flags = s[10]
|
||||
bits = (flags & 7) + 1
|
||||
|
||||
if flags & 128:
|
||||
# get global palette
|
||||
self.info["background"] = i8(s[11])
|
||||
self.info["background"] = s[11]
|
||||
# check if palette contains colour indices
|
||||
p = self.fp.read(3 << bits)
|
||||
for i in range(0, len(p), 3):
|
||||
if not (i // 3 == i8(p[i]) == i8(p[i + 1]) == i8(p[i + 2])):
|
||||
if not (i // 3 == p[i] == p[i + 1] == p[i + 2]):
|
||||
p = ImagePalette.raw("RGB", p)
|
||||
self.global_palette = self.palette = p
|
||||
break
|
||||
|
|
@ -187,13 +186,13 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
#
|
||||
s = self.fp.read(1)
|
||||
block = self.data()
|
||||
if i8(s) == 249:
|
||||
if s[0] == 249:
|
||||
#
|
||||
# graphic control extension
|
||||
#
|
||||
flags = i8(block[0])
|
||||
flags = block[0]
|
||||
if flags & 1:
|
||||
info["transparency"] = i8(block[3])
|
||||
info["transparency"] = block[3]
|
||||
info["duration"] = i16(block[1:3]) * 10
|
||||
|
||||
# disposal method - find the value of bits 4 - 6
|
||||
|
|
@ -205,7 +204,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
# correct, but it seems to prevent the last
|
||||
# frame from looking odd for some animations
|
||||
self.disposal_method = dispose_bits
|
||||
elif i8(s) == 254:
|
||||
elif s[0] == 254:
|
||||
#
|
||||
# comment extension
|
||||
#
|
||||
|
|
@ -216,14 +215,14 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
info["comment"] = block
|
||||
block = self.data()
|
||||
continue
|
||||
elif i8(s) == 255:
|
||||
elif s[0] == 255:
|
||||
#
|
||||
# application extension
|
||||
#
|
||||
info["extension"] = block, self.fp.tell()
|
||||
if block[:11] == b"NETSCAPE2.0":
|
||||
block = self.data()
|
||||
if len(block) >= 3 and i8(block[0]) == 1:
|
||||
if len(block) >= 3 and block[0] == 1:
|
||||
info["loop"] = i16(block[1:3])
|
||||
while self.data():
|
||||
pass
|
||||
|
|
@ -240,7 +239,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
if x1 > self.size[0] or y1 > self.size[1]:
|
||||
self._size = max(x1, self.size[0]), max(y1, self.size[1])
|
||||
self.dispose_extent = x0, y0, x1, y1
|
||||
flags = i8(s[8])
|
||||
flags = s[8]
|
||||
|
||||
interlace = (flags & 64) != 0
|
||||
|
||||
|
|
@ -249,7 +248,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
self.palette = ImagePalette.raw("RGB", self.fp.read(3 << bits))
|
||||
|
||||
# image data
|
||||
bits = i8(self.fp.read(1))
|
||||
bits = self.fp.read(1)[0]
|
||||
self.__offset = self.fp.tell()
|
||||
self.tile = [
|
||||
("gif", (x0, y0, x1, y1), self.__offset, (bits, interlace))
|
||||
|
|
@ -258,7 +257,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
|
||||
else:
|
||||
pass
|
||||
# raise OSError, "illegal GIF tag `%x`" % i8(s)
|
||||
# raise OSError, "illegal GIF tag `%x`" % s[0]
|
||||
|
||||
try:
|
||||
if self.disposal_method < 2:
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@
|
|||
#
|
||||
|
||||
from . import Image, ImageFile
|
||||
from ._binary import i8
|
||||
|
||||
_handler = None
|
||||
|
||||
|
|
@ -30,7 +29,7 @@ def register_handler(handler):
|
|||
|
||||
|
||||
def _accept(prefix):
|
||||
return prefix[0:4] == b"GRIB" and i8(prefix[7]) == 1
|
||||
return prefix[0:4] == b"GRIB" and prefix[7] == 1
|
||||
|
||||
|
||||
class GribStubImageFile(ImageFile.StubImageFile):
|
||||
|
|
|
|||
|
|
@ -24,7 +24,6 @@ import sys
|
|||
import tempfile
|
||||
|
||||
from PIL import Image, ImageFile, PngImagePlugin, features
|
||||
from PIL._binary import i8
|
||||
|
||||
enable_jpeg2k = features.check_codec("jpg_2000")
|
||||
if enable_jpeg2k:
|
||||
|
|
@ -70,7 +69,7 @@ def read_32(fobj, start_length, size):
|
|||
byte = fobj.read(1)
|
||||
if not byte:
|
||||
break
|
||||
byte = i8(byte)
|
||||
byte = byte[0]
|
||||
if byte & 0x80:
|
||||
blocksize = byte - 125
|
||||
byte = fobj.read(1)
|
||||
|
|
|
|||
|
|
@ -28,7 +28,6 @@ from io import BytesIO
|
|||
from math import ceil, log
|
||||
|
||||
from . import BmpImagePlugin, Image, ImageFile, PngImagePlugin
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import i32le as i32
|
||||
|
||||
|
|
@ -110,10 +109,10 @@ class IcoFile:
|
|||
s = buf.read(16)
|
||||
|
||||
icon_header = {
|
||||
"width": i8(s[0]),
|
||||
"height": i8(s[1]),
|
||||
"nb_color": i8(s[2]), # No. of colors in image (0 if >=8bpp)
|
||||
"reserved": i8(s[3]),
|
||||
"width": s[0],
|
||||
"height": s[1],
|
||||
"nb_color": s[2], # No. of colors in image (0 if >=8bpp)
|
||||
"reserved": s[3],
|
||||
"planes": i16(s[4:]),
|
||||
"bpp": i16(s[6:]),
|
||||
"size": i32(s[8:]),
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@ import os
|
|||
import re
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i8
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
# Standard tags
|
||||
|
|
@ -223,14 +222,14 @@ class ImImageFile(ImageFile.ImageFile):
|
|||
linear = 1 # linear greyscale palette
|
||||
for i in range(256):
|
||||
if palette[i] == palette[i + 256] == palette[i + 512]:
|
||||
if i8(palette[i]) != i:
|
||||
if palette[i] != i:
|
||||
linear = 0
|
||||
else:
|
||||
greyscale = 0
|
||||
if self.mode in ["L", "LA", "P", "PA"]:
|
||||
if greyscale:
|
||||
if not linear:
|
||||
self.lut = [i8(c) for c in palette[:256]]
|
||||
self.lut = list(palette[:256])
|
||||
else:
|
||||
if self.mode in ["L", "P"]:
|
||||
self.mode = self.rawmode = "P"
|
||||
|
|
@ -240,7 +239,7 @@ class ImImageFile(ImageFile.ImageFile):
|
|||
self.palette = ImagePalette.raw("RGB;L", palette)
|
||||
elif self.mode == "RGB":
|
||||
if not greyscale or not linear:
|
||||
self.lut = [i8(c) for c in palette]
|
||||
self.lut = list(palette)
|
||||
|
||||
self.frame = 0
|
||||
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ from . import (
|
|||
_plugins,
|
||||
_raise_version_warning,
|
||||
)
|
||||
from ._binary import i8, i32le
|
||||
from ._binary import i32le
|
||||
from ._util import deferred_error, isPath
|
||||
|
||||
if sys.version_info >= (3, 7):
|
||||
|
|
@ -1378,7 +1378,7 @@ class Image:
|
|||
|
||||
self.load()
|
||||
x, y = self.im.getprojection()
|
||||
return [i8(c) for c in x], [i8(c) for c in y]
|
||||
return list(x), list(y)
|
||||
|
||||
def histogram(self, mask=None, extrema=None):
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -62,14 +62,14 @@ class IptcImageFile(ImageFile.ImageFile):
|
|||
if not len(s):
|
||||
return None, 0
|
||||
|
||||
tag = i8(s[1]), i8(s[2])
|
||||
tag = s[1], s[2]
|
||||
|
||||
# syntax
|
||||
if i8(s[0]) != 0x1C or tag[0] < 1 or tag[0] > 9:
|
||||
if s[0] != 0x1C or tag[0] < 1 or tag[0] > 9:
|
||||
raise SyntaxError("invalid IPTC/NAA file")
|
||||
|
||||
# field size
|
||||
size = i8(s[3])
|
||||
size = s[3]
|
||||
if size > 132:
|
||||
raise OSError("illegal field length in IPTC/NAA file")
|
||||
elif size == 128:
|
||||
|
|
|
|||
|
|
@ -41,7 +41,6 @@ import tempfile
|
|||
import warnings
|
||||
|
||||
from . import Image, ImageFile, TiffImagePlugin
|
||||
from ._binary import i8
|
||||
from ._binary import i16be as i16
|
||||
from ._binary import i32be as i32
|
||||
from ._binary import o8
|
||||
|
|
@ -75,7 +74,7 @@ def APP(self, marker):
|
|||
self.info["jfif_version"] = divmod(version, 256)
|
||||
# extract JFIF properties
|
||||
try:
|
||||
jfif_unit = i8(s[7])
|
||||
jfif_unit = s[7]
|
||||
jfif_density = i16(s, 8), i16(s, 10)
|
||||
except Exception:
|
||||
pass
|
||||
|
|
@ -115,7 +114,7 @@ def APP(self, marker):
|
|||
code = i16(s, offset)
|
||||
offset += 2
|
||||
# resource name (usually empty)
|
||||
name_len = i8(s[offset])
|
||||
name_len = s[offset]
|
||||
# name = s[offset+1:offset+1+name_len]
|
||||
offset += 1 + name_len
|
||||
offset += offset & 1 # align
|
||||
|
|
@ -140,7 +139,7 @@ def APP(self, marker):
|
|||
self.info["adobe"] = i16(s, 5)
|
||||
# extract Adobe custom properties
|
||||
try:
|
||||
adobe_transform = i8(s[1])
|
||||
adobe_transform = s[1]
|
||||
except Exception:
|
||||
pass
|
||||
else:
|
||||
|
|
@ -197,11 +196,11 @@ def SOF(self, marker):
|
|||
s = ImageFile._safe_read(self.fp, n)
|
||||
self._size = i16(s[3:]), i16(s[1:])
|
||||
|
||||
self.bits = i8(s[0])
|
||||
self.bits = s[0]
|
||||
if self.bits != 8:
|
||||
raise SyntaxError(f"cannot handle {self.bits}-bit layers")
|
||||
|
||||
self.layers = i8(s[5])
|
||||
self.layers = s[5]
|
||||
if self.layers == 1:
|
||||
self.mode = "L"
|
||||
elif self.layers == 3:
|
||||
|
|
@ -217,7 +216,7 @@ def SOF(self, marker):
|
|||
if self.icclist:
|
||||
# fixup icc profile
|
||||
self.icclist.sort() # sort by sequence number
|
||||
if i8(self.icclist[0][13]) == len(self.icclist):
|
||||
if self.icclist[0][13] == len(self.icclist):
|
||||
profile = []
|
||||
for p in self.icclist:
|
||||
profile.append(p[14:])
|
||||
|
|
@ -230,7 +229,7 @@ def SOF(self, marker):
|
|||
for i in range(6, len(s), 3):
|
||||
t = s[i : i + 3]
|
||||
# 4-tuples: id, vsamp, hsamp, qtable
|
||||
self.layer.append((t[0], i8(t[1]) // 16, i8(t[1]) & 15, i8(t[2])))
|
||||
self.layer.append((t[0], t[1] // 16, t[1] & 15, t[2]))
|
||||
|
||||
|
||||
def DQT(self, marker):
|
||||
|
|
@ -244,7 +243,7 @@ def DQT(self, marker):
|
|||
n = i16(self.fp.read(2)) - 2
|
||||
s = ImageFile._safe_read(self.fp, n)
|
||||
while len(s):
|
||||
v = i8(s[0])
|
||||
v = s[0]
|
||||
precision = 1 if (v // 16 == 0) else 2 # in bytes
|
||||
qt_length = 1 + precision * 64
|
||||
if len(s) < qt_length:
|
||||
|
|
@ -362,7 +361,7 @@ class JpegImageFile(ImageFile.ImageFile):
|
|||
|
||||
while True:
|
||||
|
||||
i = i8(s)
|
||||
i = s[0]
|
||||
if i == 0xFF:
|
||||
s = s + self.fp.read(1)
|
||||
i = i16(s)
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@ import io
|
|||
import struct
|
||||
|
||||
from . import Image, ImageFile
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import o16le as o16
|
||||
|
||||
|
|
@ -133,7 +132,7 @@ class MspDecoder(ImageFile.PyDecoder):
|
|||
)
|
||||
idx = 0
|
||||
while idx < rowlen:
|
||||
runtype = i8(row[idx])
|
||||
runtype = row[idx]
|
||||
idx += 1
|
||||
if runtype == 0:
|
||||
(runcount, runval) = struct.unpack_from("Bc", row, idx)
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@
|
|||
|
||||
|
||||
from . import Image, ImageFile
|
||||
from ._binary import i8
|
||||
|
||||
##
|
||||
# Image plugin for PhotoCD images. This plugin only reads the 768x512
|
||||
|
|
@ -38,7 +37,7 @@ class PcdImageFile(ImageFile.ImageFile):
|
|||
if s[:4] != b"PCD_":
|
||||
raise SyntaxError("not a PCD file")
|
||||
|
||||
orientation = i8(s[1538]) & 3
|
||||
orientation = s[1538] & 3
|
||||
self.tile_post_rotate = None
|
||||
if orientation == 1:
|
||||
self.tile_post_rotate = 90
|
||||
|
|
|
|||
|
|
@ -29,7 +29,6 @@ import io
|
|||
import logging
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import o8
|
||||
from ._binary import o16le as o16
|
||||
|
|
@ -38,7 +37,7 @@ logger = logging.getLogger(__name__)
|
|||
|
||||
|
||||
def _accept(prefix):
|
||||
return i8(prefix[0]) == 10 and i8(prefix[1]) in [0, 2, 3, 5]
|
||||
return prefix[0] == 10 and prefix[1] in [0, 2, 3, 5]
|
||||
|
||||
|
||||
##
|
||||
|
|
@ -64,9 +63,9 @@ class PcxImageFile(ImageFile.ImageFile):
|
|||
logger.debug("BBox: %s %s %s %s", *bbox)
|
||||
|
||||
# format
|
||||
version = i8(s[1])
|
||||
bits = i8(s[3])
|
||||
planes = i8(s[65])
|
||||
version = s[1]
|
||||
bits = s[3]
|
||||
planes = s[65]
|
||||
stride = i16(s, 66)
|
||||
logger.debug(
|
||||
"PCX version %s, bits %s, planes %s, stride %s",
|
||||
|
|
@ -91,7 +90,7 @@ class PcxImageFile(ImageFile.ImageFile):
|
|||
# FIXME: hey, this doesn't work with the incremental loader !!!
|
||||
self.fp.seek(-769, io.SEEK_END)
|
||||
s = self.fp.read(769)
|
||||
if len(s) == 769 and i8(s[0]) == 12:
|
||||
if len(s) == 769 and s[0] == 12:
|
||||
# check if the palette is linear greyscale
|
||||
for i in range(256):
|
||||
if s[i * 3 + 1 : i * 3 + 4] != o8(i) * 3:
|
||||
|
|
|
|||
|
|
@ -39,7 +39,6 @@ import warnings
|
|||
import zlib
|
||||
|
||||
from . import Image, ImageChops, ImageFile, ImagePalette, ImageSequence
|
||||
from ._binary import i8
|
||||
from ._binary import i16be as i16
|
||||
from ._binary import i32be as i32
|
||||
from ._binary import o8
|
||||
|
|
@ -193,7 +192,7 @@ class ChunkStream:
|
|||
# Skip CRC checks for ancillary chunks if allowed to load truncated
|
||||
# images
|
||||
# 5th byte of first char is 1 [specs, section 5.4]
|
||||
if ImageFile.LOAD_TRUNCATED_IMAGES and (i8(cid[0]) >> 5 & 1):
|
||||
if ImageFile.LOAD_TRUNCATED_IMAGES and (cid[0] >> 5 & 1):
|
||||
self.crc_skip(cid, data)
|
||||
return
|
||||
|
||||
|
|
@ -390,8 +389,8 @@ class PngStream(ChunkStream):
|
|||
# Compressed profile n bytes (zlib with deflate compression)
|
||||
i = s.find(b"\0")
|
||||
logger.debug("iCCP profile name %r", s[:i])
|
||||
logger.debug("Compression method %s", i8(s[i]))
|
||||
comp_method = i8(s[i])
|
||||
logger.debug("Compression method %s", s[i])
|
||||
comp_method = s[i]
|
||||
if comp_method != 0:
|
||||
raise SyntaxError(f"Unknown compression method {comp_method} in iCCP chunk")
|
||||
try:
|
||||
|
|
@ -412,12 +411,12 @@ class PngStream(ChunkStream):
|
|||
s = ImageFile._safe_read(self.fp, length)
|
||||
self.im_size = i32(s), i32(s[4:])
|
||||
try:
|
||||
self.im_mode, self.im_rawmode = _MODES[(i8(s[8]), i8(s[9]))]
|
||||
self.im_mode, self.im_rawmode = _MODES[(s[8], s[9])]
|
||||
except Exception:
|
||||
pass
|
||||
if i8(s[12]):
|
||||
if s[12]:
|
||||
self.im_info["interlace"] = 1
|
||||
if i8(s[11]):
|
||||
if s[11]:
|
||||
raise SyntaxError("unknown filter category")
|
||||
return s
|
||||
|
||||
|
|
@ -491,7 +490,7 @@ class PngStream(ChunkStream):
|
|||
# 3 absolute colorimetric
|
||||
|
||||
s = ImageFile._safe_read(self.fp, length)
|
||||
self.im_info["srgb"] = i8(s)
|
||||
self.im_info["srgb"] = s[0]
|
||||
return s
|
||||
|
||||
def chunk_pHYs(self, pos, length):
|
||||
|
|
@ -499,7 +498,7 @@ class PngStream(ChunkStream):
|
|||
# pixels per unit
|
||||
s = ImageFile._safe_read(self.fp, length)
|
||||
px, py = i32(s), i32(s[4:])
|
||||
unit = i8(s[8])
|
||||
unit = s[8]
|
||||
if unit == 1: # meter
|
||||
dpi = int(px * 0.0254 + 0.5), int(py * 0.0254 + 0.5)
|
||||
self.im_info["dpi"] = dpi
|
||||
|
|
@ -537,7 +536,7 @@ class PngStream(ChunkStream):
|
|||
k = s
|
||||
v = b""
|
||||
if v:
|
||||
comp_method = i8(v[0])
|
||||
comp_method = v[0]
|
||||
else:
|
||||
comp_method = 0
|
||||
if comp_method != 0:
|
||||
|
|
@ -571,7 +570,7 @@ class PngStream(ChunkStream):
|
|||
return s
|
||||
if len(r) < 2:
|
||||
return s
|
||||
cf, cm, r = i8(r[0]), i8(r[1]), r[2:]
|
||||
cf, cm, r = r[0], r[1], r[2:]
|
||||
try:
|
||||
lang, tk, v = r.split(b"\0", 2)
|
||||
except ValueError:
|
||||
|
|
@ -641,8 +640,8 @@ class PngStream(ChunkStream):
|
|||
if delay_den == 0:
|
||||
delay_den = 100
|
||||
self.im_info["duration"] = float(delay_num) / float(delay_den) * 1000
|
||||
self.im_info["disposal"] = i8(s[24])
|
||||
self.im_info["blend"] = i8(s[25])
|
||||
self.im_info["disposal"] = s[24]
|
||||
self.im_info["blend"] = s[25]
|
||||
return s
|
||||
|
||||
def chunk_fdAT(self, pos, length):
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@ import os
|
|||
import struct
|
||||
|
||||
from . import Image, ImageFile
|
||||
from ._binary import i8
|
||||
from ._binary import i16be as i16
|
||||
from ._binary import o8
|
||||
|
||||
|
|
@ -64,10 +63,10 @@ class SgiImageFile(ImageFile.ImageFile):
|
|||
raise ValueError("Not an SGI image file")
|
||||
|
||||
# compression : verbatim or RLE
|
||||
compression = i8(s[2])
|
||||
compression = s[2]
|
||||
|
||||
# bpc : 1 or 2 bytes (8bits or 16bits)
|
||||
bpc = i8(s[3])
|
||||
bpc = s[3]
|
||||
|
||||
# dimension : 1, 2 or 3 (depending on xsize, ysize and zsize)
|
||||
dimension = i16(s[4:])
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@
|
|||
import warnings
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i8
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import o8
|
||||
from ._binary import o16le as o16
|
||||
|
|
@ -56,14 +55,14 @@ class TgaImageFile(ImageFile.ImageFile):
|
|||
# process header
|
||||
s = self.fp.read(18)
|
||||
|
||||
id_len = i8(s[0])
|
||||
id_len = s[0]
|
||||
|
||||
colormaptype = i8(s[1])
|
||||
imagetype = i8(s[2])
|
||||
colormaptype = s[1]
|
||||
imagetype = s[2]
|
||||
|
||||
depth = i8(s[16])
|
||||
depth = s[16]
|
||||
|
||||
flags = i8(s[17])
|
||||
flags = s[17]
|
||||
|
||||
self._size = i16(s[12:]), i16(s[14:])
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ from fractions import Fraction
|
|||
from numbers import Number, Rational
|
||||
|
||||
from . import Image, ImageFile, ImagePalette, TiffTags
|
||||
from ._binary import i8, o8
|
||||
from ._binary import o8
|
||||
from .TiffTags import TYPES
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
|
@ -1518,7 +1518,7 @@ def _save(im, fp, filename):
|
|||
|
||||
if im.mode in ["P", "PA"]:
|
||||
lut = im.im.getpalette("RGB", "RGB;L")
|
||||
ifd[COLORMAP] = tuple(i8(v) * 256 for v in lut)
|
||||
ifd[COLORMAP] = tuple(v * 256 for v in lut)
|
||||
# data orientation
|
||||
stride = len(bits) * ((im.size[0] * bits[0] + 7) // 8)
|
||||
ifd[ROWSPERSTRIP] = im.size[1]
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
#
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i8, o8
|
||||
from ._binary import o8
|
||||
|
||||
_MAGIC = b"P7 332"
|
||||
|
||||
|
|
@ -59,7 +59,7 @@ class XVThumbImageFile(ImageFile.ImageFile):
|
|||
s = self.fp.readline()
|
||||
if not s:
|
||||
raise SyntaxError("Unexpected EOF reading XV thumbnail file")
|
||||
if i8(s[0]) != 35: # ie. when not a comment: '#'
|
||||
if s[0] != 35: # ie. when not a comment: '#'
|
||||
break
|
||||
|
||||
# parse header line (already read)
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
import re
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i8, o8
|
||||
from ._binary import o8
|
||||
|
||||
# XPM header
|
||||
xpm_head = re.compile(b'"([0-9]*) ([0-9]*) ([0-9]*) ([0-9]*)')
|
||||
|
|
@ -72,7 +72,7 @@ class XpmImageFile(ImageFile.ImageFile):
|
|||
elif s[-1:] in b"\r\n":
|
||||
s = s[:-1]
|
||||
|
||||
c = i8(s[1])
|
||||
c = s[1]
|
||||
s = s[2:-2].split()
|
||||
|
||||
for i in range(0, len(s), 2):
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user