Determining the size of a PNG from raw bytes - python-imaging-library

Question

I'm trying to load a sequence of PNG images concatenated together as bytes; I know the number of images, but not their individual file sizes.
Loading the first image is easy with something like
import io
from PIL import Image
buffer = io.BytesIO(image_bytearray)
image = Image.open(buffer)
image.load()
However, I'm not sure how to handle the subsequent images. Two approaches that seem to work but might be too brittle:
Split the bytes based on the PNG header e.g. image_bytearray.split(b"\x89PNG\r\n\x1a\n"). This seems to work, but I'm worried in some edge cases this could appear in a non-header location.
Use BytesIO.tell() to determine how much of the stream was read. This appears to be 4 bytes less than the actual file size; I can add 4 to account for this, but I'm not this won't change in a later version.
Here's a simple example that illustrates the two approaches:
import io
import sys
from PIL import Image
import PIL
def setup_bytes():
"""
Concatenate the bytes of some images. The actual images don't matter
"""
files = ["Tests/images/hopper.png", "Tests/images/test-card.png"]
bytes_out = bytes()
for file in files:
im = Image.open(file)
buffer = io.BytesIO()
im.save(buffer, format="PNG")
print(f"writing {len(buffer.getvalue())} bytes")
bytes_out += buffer.getvalue()
return bytes_out
def read_split(bytes_in):
png_header = b"\x89PNG\r\n\x1a\n"
images_out = []
image_byte_splits = bytes_in.split(png_header)
for image_bytes in image_byte_splits:
if len(image_bytes) == 0:
continue
# add back the header
image = Image.open(io.BytesIO(png_header + image_bytes))
image.load()
print(f"read {len(png_header) + len(image_bytes)} bytes")
images_out.append(image)
return images_out
def read_streaming(bytes_in):
images_out = []
bytes_read = 0
# Read the images back from the bytes (without knowing the sizes).
while bytes_read < len(bytes_in):
buffer = io.BytesIO(bytes_in[bytes_read:])
image = Image.open(buffer)
image.load()
images_out.append(image)
# Start the next read at the end of the current image.
# These extra 4 bytes appear necessary.
read = buffer.tell() + 4
print(f"read {read} bytes?")
bytes_read += read
return images_out
def main():
print(f"python sys.version = {sys.version}")
print(f"Pillow version = {PIL.__version__}")
b = setup_bytes()
read_split(b)
read_streaming(b)
main()
My questions are:
Is splitting safe? Is there a chance that the header could also appear in the body of an image?
Is adding an offset to tell() safe? Is there a way to get the image loading to leave the position at the actual end of the file?
Is there a better way to do this in general? Some of the classes in PngImagePlugin.py look like they'd be useful to examine the chunks without actually decompressing.