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 C# code generated by Kaitai Struct depends on the Kaitai Struct runtime library for C#. You must add this dependency to your project before you can parse or serialize any data.
The C# runtime library is available in the NuGet Gallery. Installation instructions can also be found there.
Parse a local file and get structure in memory:
var data = Webp.FromFile("path/to/local/file.webp");
Or parse structure from a byte array:
byte[] someArray = new byte[] { ... };
var data = new Webp(new KaitaiStream(someArray));
After that, one can get various attributes from the structure by accessing properties like:
data.Magic // => get magic
// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
using System;
using System.Collections.Generic;
namespace Kaitai
{
/// <remarks>
/// Reference: <a href="https://developers.google.com/speed/webp/docs/riff_container">Source</a>
/// </remarks>
public partial class Webp : KaitaiStruct
{
public static Webp FromFile(string fileName)
{
return new Webp(new KaitaiStream(fileName));
}
public enum ChunkNames
{
XmpVar = 5262680,
Vp8 = 540561494,
Xmp = 542133592,
Exif = 1179211845,
Anmf = 1179471425,
Alph = 1213221953,
Vp8l = 1278758998,
Frgm = 1296519750,
Anim = 1296649793,
Iccp = 1346585417,
Vp8x = 1480085590,
}
public enum CompressionMethod
{
None = 0,
WebpLossless = 1,
}
public enum FilteringMethod
{
None = 0,
Horizontal = 1,
Vertical = 2,
Gradient = 3,
}
public enum Preprocessing
{
None = 0,
LevelReduction = 1,
}
public Webp(KaitaiStream p__io, KaitaiStruct p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root ?? this;
_read();
}
private void _read()
{
_magic = m_io.ReadBytes(4);
if (!((KaitaiStream.ByteArrayCompare(_magic, new byte[] { 82, 73, 70, 70 }) == 0)))
{
throw new ValidationNotEqualError(new byte[] { 82, 73, 70, 70 }, _magic, m_io, "/seq/0");
}
_lenData = m_io.ReadU4le();
_webp = m_io.ReadBytes(4);
if (!((KaitaiStream.ByteArrayCompare(_webp, new byte[] { 87, 69, 66, 80 }) == 0)))
{
throw new ValidationNotEqualError(new byte[] { 87, 69, 66, 80 }, _webp, m_io, "/seq/2");
}
__raw_payload = m_io.ReadBytes(LenData - 4);
var io___raw_payload = new KaitaiStream(__raw_payload);
_payload = new Chunks(io___raw_payload, this, m_root);
}
public partial class Alph : KaitaiStruct
{
public static Alph FromFile(string fileName)
{
return new Alph(new KaitaiStream(fileName));
}
public Alph(KaitaiStream p__io, Webp.Chunk p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
private void _read()
{
_reserved = m_io.ReadBitsIntBe(2);
if (!(_reserved == 0))
{
throw new ValidationNotEqualError(0, _reserved, m_io, "/types/alph/seq/0");
}
_preprocessing = ((Webp.Preprocessing) m_io.ReadBitsIntBe(2));
if (!Enum.IsDefined(typeof(Preprocessing), _preprocessing))
{
throw new ValidationNotInEnumError(_preprocessing, m_io, "/types/alph/seq/1");
}
_filtering = ((Webp.FilteringMethod) m_io.ReadBitsIntBe(2));
_compression = ((Webp.CompressionMethod) m_io.ReadBitsIntBe(2));
if (!Enum.IsDefined(typeof(CompressionMethod), _compression))
{
throw new ValidationNotInEnumError(_compression, m_io, "/types/alph/seq/3");
}
m_io.AlignToByte();
_data = m_io.ReadBytesFull();
}
private ulong _reserved;
private Preprocessing _preprocessing;
private FilteringMethod _filtering;
private CompressionMethod _compression;
private byte[] _data;
private Webp m_root;
private Webp.Chunk m_parent;
public ulong Reserved { get { return _reserved; } }
public Preprocessing Preprocessing { get { return _preprocessing; } }
public FilteringMethod Filtering { get { return _filtering; } }
public CompressionMethod Compression { get { return _compression; } }
public byte[] Data { get { return _data; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunk M_Parent { get { return m_parent; } }
}
/// <remarks>
/// Reference: <a href="https://developers.google.com/speed/webp/docs/riff_container#animation">Source</a>
/// </remarks>
public partial class Anim : KaitaiStruct
{
public static Anim FromFile(string fileName)
{
return new Anim(new KaitaiStream(fileName));
}
public Anim(KaitaiStream p__io, Webp.Chunk p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
private void _read()
{
_backgroundColor = new BgColor(m_io, this, m_root);
_loopCount = m_io.ReadU2le();
}
public partial class BgColor : KaitaiStruct
{
public static BgColor FromFile(string fileName)
{
return new BgColor(new KaitaiStream(fileName));
}
public BgColor(KaitaiStream p__io, Webp.Anim p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
private void _read()
{
_blue = m_io.ReadU1();
_green = m_io.ReadU1();
_red = m_io.ReadU1();
_alpha = m_io.ReadU1();
}
private byte _blue;
private byte _green;
private byte _red;
private byte _alpha;
private Webp m_root;
private Webp.Anim m_parent;
public byte Blue { get { return _blue; } }
public byte Green { get { return _green; } }
public byte Red { get { return _red; } }
public byte Alpha { get { return _alpha; } }
public Webp M_Root { get { return m_root; } }
public Webp.Anim M_Parent { get { return m_parent; } }
}
private BgColor _backgroundColor;
private ushort _loopCount;
private Webp m_root;
private Webp.Chunk m_parent;
public BgColor BackgroundColor { get { return _backgroundColor; } }
public ushort LoopCount { get { return _loopCount; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunk M_Parent { get { return m_parent; } }
}
public partial class Anmf : KaitaiStruct
{
public static Anmf FromFile(string fileName)
{
return new Anmf(new KaitaiStream(fileName));
}
public Anmf(KaitaiStream p__io, Webp.Chunk p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
f_frameHeight = false;
f_frameWidth = false;
f_frameX = false;
f_frameY = false;
_read();
}
private void _read()
{
_frameXDiv2 = m_io.ReadBitsIntLe(24);
_frameYDiv2 = m_io.ReadBitsIntLe(24);
_frameWidthMinus1 = m_io.ReadBitsIntLe(24);
_frameHeightMinus1 = m_io.ReadBitsIntLe(24);
_duration = m_io.ReadBitsIntLe(24);
_reserved = m_io.ReadBitsIntBe(6);
if (!(_reserved == 0))
{
throw new ValidationNotEqualError(0, _reserved, m_io, "/types/anmf/seq/5");
}
_blendingMethod = m_io.ReadBitsIntBe(1) != 0;
_disposalMethod = m_io.ReadBitsIntBe(1) != 0;
m_io.AlignToByte();
_data = m_io.ReadBytesFull();
}
private bool f_frameHeight;
private int _frameHeight;
public int FrameHeight
{
get
{
if (f_frameHeight)
return _frameHeight;
f_frameHeight = true;
_frameHeight = (int) (FrameHeightMinus1 + 1);
return _frameHeight;
}
}
private bool f_frameWidth;
private int _frameWidth;
public int FrameWidth
{
get
{
if (f_frameWidth)
return _frameWidth;
f_frameWidth = true;
_frameWidth = (int) (FrameWidthMinus1 + 1);
return _frameWidth;
}
}
private bool f_frameX;
private int _frameX;
public int FrameX
{
get
{
if (f_frameX)
return _frameX;
f_frameX = true;
_frameX = (int) (FrameXDiv2 * 2);
return _frameX;
}
}
private bool f_frameY;
private int _frameY;
public int FrameY
{
get
{
if (f_frameY)
return _frameY;
f_frameY = true;
_frameY = (int) (FrameYDiv2 * 2);
return _frameY;
}
}
private ulong _frameXDiv2;
private ulong _frameYDiv2;
private ulong _frameWidthMinus1;
private ulong _frameHeightMinus1;
private ulong _duration;
private ulong _reserved;
private bool _blendingMethod;
private bool _disposalMethod;
private byte[] _data;
private Webp m_root;
private Webp.Chunk m_parent;
public ulong FrameXDiv2 { get { return _frameXDiv2; } }
public ulong FrameYDiv2 { get { return _frameYDiv2; } }
public ulong FrameWidthMinus1 { get { return _frameWidthMinus1; } }
public ulong FrameHeightMinus1 { get { return _frameHeightMinus1; } }
public ulong Duration { get { return _duration; } }
public ulong Reserved { get { return _reserved; } }
public bool BlendingMethod { get { return _blendingMethod; } }
public bool DisposalMethod { get { return _disposalMethod; } }
public byte[] Data { get { return _data; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunk M_Parent { get { return m_parent; } }
}
public partial class Chunk : KaitaiStruct
{
public static Chunk FromFile(string fileName)
{
return new Chunk(new KaitaiStream(fileName));
}
public Chunk(KaitaiStream p__io, Webp.Chunks p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
private void _read()
{
_name = ((Webp.ChunkNames) m_io.ReadU4le());
if (!Enum.IsDefined(typeof(ChunkNames), _name))
{
throw new ValidationNotInEnumError(_name, m_io, "/types/chunk/seq/0");
}
_lenData = m_io.ReadU4le();
switch (Name) {
case Webp.ChunkNames.Alph: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Alph(io___raw_data, this, m_root);
break;
}
case Webp.ChunkNames.Anim: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Anim(io___raw_data, this, m_root);
break;
}
case Webp.ChunkNames.Anmf: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Anmf(io___raw_data, this, m_root);
break;
}
case Webp.ChunkNames.Vp8: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Vp8(io___raw_data, this, m_root);
break;
}
case Webp.ChunkNames.Vp8l: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Vp8l(io___raw_data, this, m_root);
break;
}
case Webp.ChunkNames.Vp8x: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Vp8x(io___raw_data, this, m_root);
break;
}
case Webp.ChunkNames.Xmp: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Xmp(io___raw_data, this, m_root);
break;
}
case Webp.ChunkNames.XmpVar: {
__raw_data = m_io.ReadBytes(LenData);
var io___raw_data = new KaitaiStream(__raw_data);
_data = new Xmp(io___raw_data, this, m_root);
break;
}
default: {
_data = m_io.ReadBytes(LenData);
break;
}
}
if (KaitaiStream.Mod(LenData, 2) != 0) {
_padding = m_io.ReadBytes(1);
if (!((KaitaiStream.ByteArrayCompare(_padding, new byte[] { 0 }) == 0)))
{
throw new ValidationNotEqualError(new byte[] { 0 }, _padding, m_io, "/types/chunk/seq/3");
}
}
}
private ChunkNames _name;
private uint _lenData;
private object _data;
private byte[] _padding;
private Webp m_root;
private Webp.Chunks m_parent;
private byte[] __raw_data;
public ChunkNames Name { get { return _name; } }
public uint LenData { get { return _lenData; } }
public object Data { get { return _data; } }
public byte[] Padding { get { return _padding; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunks M_Parent { get { return m_parent; } }
public byte[] M_RawData { get { return __raw_data; } }
}
public partial class Chunks : KaitaiStruct
{
public static Chunks FromFile(string fileName)
{
return new Chunks(new KaitaiStream(fileName));
}
public Chunks(KaitaiStream p__io, Webp p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
private void _read()
{
_chunks = new List<Chunk>();
{
var i = 0;
while (!m_io.IsEof) {
_chunks.Add(new Chunk(m_io, this, m_root));
i++;
}
}
}
private List<Chunk> _chunks;
private Webp m_root;
private Webp m_parent;
public List<Chunk> Chunks { get { return _chunks; } }
public Webp M_Root { get { return m_root; } }
public Webp M_Parent { get { return m_parent; } }
}
/// <remarks>
/// Reference: <a href="https://www.rfc-editor.org/rfc/rfc6386#section-9.1">Source</a>
/// </remarks>
public partial class Vp8 : KaitaiStruct
{
public static Vp8 FromFile(string fileName)
{
return new Vp8(new KaitaiStream(fileName));
}
public Vp8(KaitaiStream p__io, Webp.Chunk p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
private void _read()
{
_frameType = m_io.ReadBitsIntLe(1) != 0;
if (!(_frameType == false))
{
throw new ValidationNotEqualError(false, _frameType, m_io, "/types/vp8/seq/0");
}
_version = m_io.ReadBitsIntLe(3);
if (!(_version <= 3))
{
throw new ValidationGreaterThanError(3, _version, m_io, "/types/vp8/seq/1");
}
_showFrame = m_io.ReadBitsIntLe(1) != 0;
_lenFirstPartition = m_io.ReadBitsIntLe(19);
m_io.AlignToByte();
_startCode = m_io.ReadBytes(3);
if (!((KaitaiStream.ByteArrayCompare(_startCode, new byte[] { 157, 1, 42 }) == 0)))
{
throw new ValidationNotEqualError(new byte[] { 157, 1, 42 }, _startCode, m_io, "/types/vp8/seq/4");
}
_width = m_io.ReadBitsIntLe(14);
_horizontalScale = m_io.ReadBitsIntLe(2);
_height = m_io.ReadBitsIntLe(14);
_verticalScale = m_io.ReadBitsIntLe(2);
m_io.AlignToByte();
_data = m_io.ReadBytesFull();
}
private bool _frameType;
private ulong _version;
private bool _showFrame;
private ulong _lenFirstPartition;
private byte[] _startCode;
private ulong _width;
private ulong _horizontalScale;
private ulong _height;
private ulong _verticalScale;
private byte[] _data;
private Webp m_root;
private Webp.Chunk m_parent;
public bool FrameType { get { return _frameType; } }
public ulong Version { get { return _version; } }
public bool ShowFrame { get { return _showFrame; } }
public ulong LenFirstPartition { get { return _lenFirstPartition; } }
public byte[] StartCode { get { return _startCode; } }
public ulong Width { get { return _width; } }
public ulong HorizontalScale { get { return _horizontalScale; } }
public ulong Height { get { return _height; } }
public ulong VerticalScale { get { return _verticalScale; } }
public byte[] Data { get { return _data; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunk M_Parent { get { return m_parent; } }
}
/// <remarks>
/// Reference: <a href="https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification">Source</a>
/// </remarks>
public partial class Vp8l : KaitaiStruct
{
public static Vp8l FromFile(string fileName)
{
return new Vp8l(new KaitaiStream(fileName));
}
public Vp8l(KaitaiStream p__io, Webp.Chunk p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
f_imageHeight = false;
f_imageWidth = false;
_read();
}
private void _read()
{
_signature = m_io.ReadU1();
if (!(_signature == 47))
{
throw new ValidationNotEqualError(47, _signature, m_io, "/types/vp8l/seq/0");
}
_imageWidthMinus1 = m_io.ReadBitsIntLe(14);
_imageHeightMinus1 = m_io.ReadBitsIntLe(14);
_alphaIsUsed = m_io.ReadBitsIntLe(1) != 0;
_versionNumber = m_io.ReadBitsIntLe(3);
if (!(_versionNumber == 0))
{
throw new ValidationNotEqualError(0, _versionNumber, m_io, "/types/vp8l/seq/4");
}
m_io.AlignToByte();
_data = m_io.ReadBytesFull();
}
private bool f_imageHeight;
private int _imageHeight;
public int ImageHeight
{
get
{
if (f_imageHeight)
return _imageHeight;
f_imageHeight = true;
_imageHeight = (int) (ImageHeightMinus1 + 1);
return _imageHeight;
}
}
private bool f_imageWidth;
private int _imageWidth;
public int ImageWidth
{
get
{
if (f_imageWidth)
return _imageWidth;
f_imageWidth = true;
_imageWidth = (int) (ImageWidthMinus1 + 1);
return _imageWidth;
}
}
private byte _signature;
private ulong _imageWidthMinus1;
private ulong _imageHeightMinus1;
private bool _alphaIsUsed;
private ulong _versionNumber;
private byte[] _data;
private Webp m_root;
private Webp.Chunk m_parent;
public byte Signature { get { return _signature; } }
public ulong ImageWidthMinus1 { get { return _imageWidthMinus1; } }
public ulong ImageHeightMinus1 { get { return _imageHeightMinus1; } }
/// <summary>
/// A hint only - it should not impact decoding. It should be `false` when
/// all alpha values are 255 in the picture, and `true` otherwise.
/// </summary>
public bool AlphaIsUsed { get { return _alphaIsUsed; } }
public ulong VersionNumber { get { return _versionNumber; } }
public byte[] Data { get { return _data; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunk M_Parent { get { return m_parent; } }
}
public partial class Vp8x : KaitaiStruct
{
public static Vp8x FromFile(string fileName)
{
return new Vp8x(new KaitaiStream(fileName));
}
public Vp8x(KaitaiStream p__io, Webp.Chunk p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
f_canvasHeight = false;
f_canvasWidth = false;
_read();
}
private void _read()
{
_reserved1 = m_io.ReadBitsIntBe(2);
if (!(_reserved1 == 0))
{
throw new ValidationNotEqualError(0, _reserved1, m_io, "/types/vp8x/seq/0");
}
_iccProfile = m_io.ReadBitsIntBe(1) != 0;
_alpha = m_io.ReadBitsIntBe(1) != 0;
_exif = m_io.ReadBitsIntBe(1) != 0;
_xmp = m_io.ReadBitsIntBe(1) != 0;
_animation = m_io.ReadBitsIntBe(1) != 0;
_reserved2 = m_io.ReadBitsIntBe(1) != 0;
if (!(_reserved2 == false))
{
throw new ValidationNotEqualError(false, _reserved2, m_io, "/types/vp8x/seq/6");
}
_reserved3 = m_io.ReadBitsIntBe(24);
if (!(_reserved3 == 0))
{
throw new ValidationNotEqualError(0, _reserved3, m_io, "/types/vp8x/seq/7");
}
_canvasWidthMinus1 = m_io.ReadBitsIntLe(24);
_canvasHeightMinus1 = m_io.ReadBitsIntLe(24);
if (!(_canvasHeightMinus1 <= 4294967295 / CanvasWidth - 1))
{
throw new ValidationGreaterThanError(4294967295 / CanvasWidth - 1, _canvasHeightMinus1, m_io, "/types/vp8x/seq/9");
}
}
private bool f_canvasHeight;
private int _canvasHeight;
public int CanvasHeight
{
get
{
if (f_canvasHeight)
return _canvasHeight;
f_canvasHeight = true;
_canvasHeight = (int) (CanvasHeightMinus1 + 1);
return _canvasHeight;
}
}
private bool f_canvasWidth;
private int _canvasWidth;
public int CanvasWidth
{
get
{
if (f_canvasWidth)
return _canvasWidth;
f_canvasWidth = true;
_canvasWidth = (int) (CanvasWidthMinus1 + 1);
return _canvasWidth;
}
}
private ulong _reserved1;
private bool _iccProfile;
private bool _alpha;
private bool _exif;
private bool _xmp;
private bool _animation;
private bool _reserved2;
private ulong _reserved3;
private ulong _canvasWidthMinus1;
private ulong _canvasHeightMinus1;
private Webp m_root;
private Webp.Chunk m_parent;
public ulong Reserved1 { get { return _reserved1; } }
public bool IccProfile { get { return _iccProfile; } }
public bool Alpha { get { return _alpha; } }
public bool Exif { get { return _exif; } }
public bool Xmp { get { return _xmp; } }
public bool Animation { get { return _animation; } }
public bool Reserved2 { get { return _reserved2; } }
public ulong Reserved3 { get { return _reserved3; } }
public ulong CanvasWidthMinus1 { get { return _canvasWidthMinus1; } }
public ulong CanvasHeightMinus1 { get { return _canvasHeightMinus1; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunk M_Parent { get { return m_parent; } }
}
public partial class Xmp : KaitaiStruct
{
public static Xmp FromFile(string fileName)
{
return new Xmp(new KaitaiStream(fileName));
}
public Xmp(KaitaiStream p__io, Webp.Chunk p__parent = null, Webp p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
private void _read()
{
_data = System.Text.Encoding.GetEncoding("UTF-8").GetString(m_io.ReadBytesFull());
}
private string _data;
private Webp m_root;
private Webp.Chunk m_parent;
public string Data { get { return _data; } }
public Webp M_Root { get { return m_root; } }
public Webp.Chunk M_Parent { get { return m_parent; } }
}
private byte[] _magic;
private uint _lenData;
private byte[] _webp;
private Chunks _payload;
private Webp m_root;
private KaitaiStruct m_parent;
private byte[] __raw_payload;
public byte[] Magic { get { return _magic; } }
public uint LenData { get { return _lenData; } }
public byte[] Webp { get { return _webp; } }
public Chunks Payload { get { return _payload; } }
public Webp M_Root { get { return m_root; } }
public KaitaiStruct M_Parent { get { return m_parent; } }
public byte[] M_RawPayload { get { return __raw_payload; } }
}
}