This page hosts a formal specification of WebP using Kaitai Struct. This specification can be automatically translated into a variety of programming languages to get a parsing library.
All Python code generated by Kaitai Struct depends on the Kaitai Struct runtime library for Python. You must add this dependency to your project before you can parse or serialize any data.
The Python runtime library can be installed from PyPI:
python3 -m pip install kaitaistructParse a local file and get structure in memory:
data = Webp.from_file("path/to/local/file.webp")
Or parse structure from a bytes:
from kaitaistruct import KaitaiStream, BytesIO
raw = b"\x00\x01\x02..."
data = Webp(KaitaiStream(BytesIO(raw)))
After that, one can get various attributes from the structure by invoking getter methods like:
data.magic # => get magic
# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
# type: ignore
import kaitaistruct
from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
from enum import IntEnum
if getattr(kaitaistruct, 'API_VERSION', (0, 9)) < (0, 11):
raise Exception("Incompatible Kaitai Struct Python API: 0.11 or later is required, but you have %s" % (kaitaistruct.__version__))
class Webp(KaitaiStruct):
"""
.. seealso::
Source - https://developers.google.com/speed/webp/docs/riff_container
"""
class ChunkNames(IntEnum):
xmp_var = 5262680
vp8 = 540561494
xmp = 542133592
exif = 1179211845
anmf = 1179471425
alph = 1213221953
vp8l = 1278758998
frgm = 1296519750
anim = 1296649793
iccp = 1346585417
vp8x = 1480085590
class CompressionMethod(IntEnum):
none = 0
webp_lossless = 1
class FilteringMethod(IntEnum):
none = 0
horizontal = 1
vertical = 2
gradient = 3
class Preprocessing(IntEnum):
none = 0
level_reduction = 1
def __init__(self, _io, _parent=None, _root=None):
super(Webp, self).__init__(_io)
self._parent = _parent
self._root = _root or self
self._read()
def _read(self):
self.magic = self._io.read_bytes(4)
if not self.magic == b"\x52\x49\x46\x46":
raise kaitaistruct.ValidationNotEqualError(b"\x52\x49\x46\x46", self.magic, self._io, u"/seq/0")
self.len_data = self._io.read_u4le()
self.webp = self._io.read_bytes(4)
if not self.webp == b"\x57\x45\x42\x50":
raise kaitaistruct.ValidationNotEqualError(b"\x57\x45\x42\x50", self.webp, self._io, u"/seq/2")
self._raw_payload = self._io.read_bytes(self.len_data - 4)
_io__raw_payload = KaitaiStream(BytesIO(self._raw_payload))
self.payload = Webp.Chunks(_io__raw_payload, self, self._root)
def _fetch_instances(self):
pass
self.payload._fetch_instances()
class Alph(KaitaiStruct):
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Alph, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.reserved = self._io.read_bits_int_be(2)
if not self.reserved == 0:
raise kaitaistruct.ValidationNotEqualError(0, self.reserved, self._io, u"/types/alph/seq/0")
self.preprocessing = KaitaiStream.resolve_enum(Webp.Preprocessing, self._io.read_bits_int_be(2))
if not isinstance(self.preprocessing, Webp.Preprocessing):
raise kaitaistruct.ValidationNotInEnumError(self.preprocessing, self._io, u"/types/alph/seq/1")
self.filtering = KaitaiStream.resolve_enum(Webp.FilteringMethod, self._io.read_bits_int_be(2))
self.compression = KaitaiStream.resolve_enum(Webp.CompressionMethod, self._io.read_bits_int_be(2))
if not isinstance(self.compression, Webp.CompressionMethod):
raise kaitaistruct.ValidationNotInEnumError(self.compression, self._io, u"/types/alph/seq/3")
self.data = self._io.read_bytes_full()
def _fetch_instances(self):
pass
class Anim(KaitaiStruct):
"""
.. seealso::
Source - https://developers.google.com/speed/webp/docs/riff_container#animation
"""
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Anim, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.background_color = Webp.Anim.BgColor(self._io, self, self._root)
self.loop_count = self._io.read_u2le()
def _fetch_instances(self):
pass
self.background_color._fetch_instances()
class BgColor(KaitaiStruct):
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Anim.BgColor, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.blue = self._io.read_u1()
self.green = self._io.read_u1()
self.red = self._io.read_u1()
self.alpha = self._io.read_u1()
def _fetch_instances(self):
pass
class Anmf(KaitaiStruct):
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Anmf, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.frame_x_div_2 = self._io.read_bits_int_le(24)
self.frame_y_div_2 = self._io.read_bits_int_le(24)
self.frame_width_minus_1 = self._io.read_bits_int_le(24)
self.frame_height_minus_1 = self._io.read_bits_int_le(24)
self.duration = self._io.read_bits_int_le(24)
self.reserved = self._io.read_bits_int_be(6)
if not self.reserved == 0:
raise kaitaistruct.ValidationNotEqualError(0, self.reserved, self._io, u"/types/anmf/seq/5")
self.blending_method = self._io.read_bits_int_be(1) != 0
self.disposal_method = self._io.read_bits_int_be(1) != 0
self.data = self._io.read_bytes_full()
def _fetch_instances(self):
pass
@property
def frame_height(self):
if hasattr(self, '_m_frame_height'):
return self._m_frame_height
self._m_frame_height = self.frame_height_minus_1 + 1
return getattr(self, '_m_frame_height', None)
@property
def frame_width(self):
if hasattr(self, '_m_frame_width'):
return self._m_frame_width
self._m_frame_width = self.frame_width_minus_1 + 1
return getattr(self, '_m_frame_width', None)
@property
def frame_x(self):
if hasattr(self, '_m_frame_x'):
return self._m_frame_x
self._m_frame_x = self.frame_x_div_2 * 2
return getattr(self, '_m_frame_x', None)
@property
def frame_y(self):
if hasattr(self, '_m_frame_y'):
return self._m_frame_y
self._m_frame_y = self.frame_y_div_2 * 2
return getattr(self, '_m_frame_y', None)
class Chunk(KaitaiStruct):
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Chunk, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.name = KaitaiStream.resolve_enum(Webp.ChunkNames, self._io.read_u4le())
if not isinstance(self.name, Webp.ChunkNames):
raise kaitaistruct.ValidationNotInEnumError(self.name, self._io, u"/types/chunk/seq/0")
self.len_data = self._io.read_u4le()
_on = self.name
if _on == Webp.ChunkNames.alph:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Alph(_io__raw_data, self, self._root)
elif _on == Webp.ChunkNames.anim:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Anim(_io__raw_data, self, self._root)
elif _on == Webp.ChunkNames.anmf:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Anmf(_io__raw_data, self, self._root)
elif _on == Webp.ChunkNames.vp8:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Vp8(_io__raw_data, self, self._root)
elif _on == Webp.ChunkNames.vp8l:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Vp8l(_io__raw_data, self, self._root)
elif _on == Webp.ChunkNames.vp8x:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Vp8x(_io__raw_data, self, self._root)
elif _on == Webp.ChunkNames.xmp:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Xmp(_io__raw_data, self, self._root)
elif _on == Webp.ChunkNames.xmp_var:
pass
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Webp.Xmp(_io__raw_data, self, self._root)
else:
pass
self.data = self._io.read_bytes(self.len_data)
if self.len_data % 2 != 0:
pass
self.padding = self._io.read_bytes(1)
if not self.padding == b"\x00":
raise kaitaistruct.ValidationNotEqualError(b"\x00", self.padding, self._io, u"/types/chunk/seq/3")
def _fetch_instances(self):
pass
_on = self.name
if _on == Webp.ChunkNames.alph:
pass
self.data._fetch_instances()
elif _on == Webp.ChunkNames.anim:
pass
self.data._fetch_instances()
elif _on == Webp.ChunkNames.anmf:
pass
self.data._fetch_instances()
elif _on == Webp.ChunkNames.vp8:
pass
self.data._fetch_instances()
elif _on == Webp.ChunkNames.vp8l:
pass
self.data._fetch_instances()
elif _on == Webp.ChunkNames.vp8x:
pass
self.data._fetch_instances()
elif _on == Webp.ChunkNames.xmp:
pass
self.data._fetch_instances()
elif _on == Webp.ChunkNames.xmp_var:
pass
self.data._fetch_instances()
else:
pass
if self.len_data % 2 != 0:
pass
class Chunks(KaitaiStruct):
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Chunks, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.chunks = []
i = 0
while not self._io.is_eof():
self.chunks.append(Webp.Chunk(self._io, self, self._root))
i += 1
def _fetch_instances(self):
pass
for i in range(len(self.chunks)):
pass
self.chunks[i]._fetch_instances()
class Vp8(KaitaiStruct):
"""
.. seealso::
Source - https://www.rfc-editor.org/rfc/rfc6386#section-9.1
"""
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Vp8, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.frame_type = self._io.read_bits_int_le(1) != 0
if not self.frame_type == False:
raise kaitaistruct.ValidationNotEqualError(False, self.frame_type, self._io, u"/types/vp8/seq/0")
self.version = self._io.read_bits_int_le(3)
if not self.version <= 3:
raise kaitaistruct.ValidationGreaterThanError(3, self.version, self._io, u"/types/vp8/seq/1")
self.show_frame = self._io.read_bits_int_le(1) != 0
self.len_first_partition = self._io.read_bits_int_le(19)
self.start_code = self._io.read_bytes(3)
if not self.start_code == b"\x9D\x01\x2A":
raise kaitaistruct.ValidationNotEqualError(b"\x9D\x01\x2A", self.start_code, self._io, u"/types/vp8/seq/4")
self.width = self._io.read_bits_int_le(14)
self.horizontal_scale = self._io.read_bits_int_le(2)
self.height = self._io.read_bits_int_le(14)
self.vertical_scale = self._io.read_bits_int_le(2)
self.data = self._io.read_bytes_full()
def _fetch_instances(self):
pass
class Vp8l(KaitaiStruct):
"""
.. seealso::
Source - https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification
"""
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Vp8l, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.signature = self._io.read_u1()
if not self.signature == 47:
raise kaitaistruct.ValidationNotEqualError(47, self.signature, self._io, u"/types/vp8l/seq/0")
self.image_width_minus_1 = self._io.read_bits_int_le(14)
self.image_height_minus_1 = self._io.read_bits_int_le(14)
self.alpha_is_used = self._io.read_bits_int_le(1) != 0
self.version_number = self._io.read_bits_int_le(3)
if not self.version_number == 0:
raise kaitaistruct.ValidationNotEqualError(0, self.version_number, self._io, u"/types/vp8l/seq/4")
self.data = self._io.read_bytes_full()
def _fetch_instances(self):
pass
@property
def image_height(self):
if hasattr(self, '_m_image_height'):
return self._m_image_height
self._m_image_height = self.image_height_minus_1 + 1
return getattr(self, '_m_image_height', None)
@property
def image_width(self):
if hasattr(self, '_m_image_width'):
return self._m_image_width
self._m_image_width = self.image_width_minus_1 + 1
return getattr(self, '_m_image_width', None)
class Vp8x(KaitaiStruct):
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Vp8x, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.reserved1 = self._io.read_bits_int_be(2)
if not self.reserved1 == 0:
raise kaitaistruct.ValidationNotEqualError(0, self.reserved1, self._io, u"/types/vp8x/seq/0")
self.icc_profile = self._io.read_bits_int_be(1) != 0
self.alpha = self._io.read_bits_int_be(1) != 0
self.exif = self._io.read_bits_int_be(1) != 0
self.xmp = self._io.read_bits_int_be(1) != 0
self.animation = self._io.read_bits_int_be(1) != 0
self.reserved2 = self._io.read_bits_int_be(1) != 0
if not self.reserved2 == False:
raise kaitaistruct.ValidationNotEqualError(False, self.reserved2, self._io, u"/types/vp8x/seq/6")
self.reserved3 = self._io.read_bits_int_be(24)
if not self.reserved3 == 0:
raise kaitaistruct.ValidationNotEqualError(0, self.reserved3, self._io, u"/types/vp8x/seq/7")
self.canvas_width_minus_1 = self._io.read_bits_int_le(24)
self.canvas_height_minus_1 = self._io.read_bits_int_le(24)
if not self.canvas_height_minus_1 <= 4294967295 // self.canvas_width - 1:
raise kaitaistruct.ValidationGreaterThanError(4294967295 // self.canvas_width - 1, self.canvas_height_minus_1, self._io, u"/types/vp8x/seq/9")
def _fetch_instances(self):
pass
@property
def canvas_height(self):
if hasattr(self, '_m_canvas_height'):
return self._m_canvas_height
self._m_canvas_height = self.canvas_height_minus_1 + 1
return getattr(self, '_m_canvas_height', None)
@property
def canvas_width(self):
if hasattr(self, '_m_canvas_width'):
return self._m_canvas_width
self._m_canvas_width = self.canvas_width_minus_1 + 1
return getattr(self, '_m_canvas_width', None)
class Xmp(KaitaiStruct):
def __init__(self, _io, _parent=None, _root=None):
super(Webp.Xmp, self).__init__(_io)
self._parent = _parent
self._root = _root
self._read()
def _read(self):
self.data = (self._io.read_bytes_full()).decode(u"UTF-8")
def _fetch_instances(self):
pass