.WEBP File Format – Lossless (VP8L)

Header

A 2 by 3 image without alpha starts 2F 01 80 00 00.

Overall structure

image-stream           = optional-transform spatially-coded-image
optional-transform     = (%b1 transform optional-transform) / %b0
spatially-coded-image  = color-cache-info meta-prefix data
entropy-coded-image    = color-cache-info data
data                   = prefix-codes lz77-coded-image

The end of the image is implicit: decoding stops after width × height pixels. Entropy-coded images, used for the sub-resolution data of the transforms and the entropy image, have no transforms and no meta prefix.

Transforms

Each transform is announced by a 1 bit, then a 2-bit type, then its data; a 0 bit ends the list. Each type may appear at most once. Decoders undo them in the reverse of the order they were read.

A sub-resolution image has a width of ⌈image width ÷ 2^size_bits⌉, and the height likewise.

Predictor transform

The green channel of each pixel in the sub-resolution image selects a mode for that block. L is the pixel to the left, T above, TL above-left and TR above-right.

Average2(a, b)              = (a + b) / 2                 integer division, per channel
ClampAddSubtractFull(a,b,c) = clamp(a + b - c)
ClampAddSubtractHalf(a,b)   = clamp(a + (a - b) / 2)
clamp(x)                    = x limited to 0..255

Select(L, T, TL):
    e  = L + T - TL                         per channel
    dL = sum over A, R, G, B of |e - L|
    dT = sum over A, R, G, B of |e - T|
    return L if dL < dT, otherwise T

The final pixel is the stored residual plus the prediction, per channel, modulo 256.

Colour transform

Each block stores three signed 8-bit multipliers, packed into a pixel with alpha 255, red = red_to_blue, green = green_to_blue and blue = green_to_red.

delta(t, c) = (t * c) >> 5

red  = red + delta(green_to_red, green)
blue = blue + delta(green_to_blue, green)
blue = blue + delta(red_to_blue, red)         using the restored red

Subtract green

No data. The decoder adds green to red and to blue, modulo 256.

Colour indexing

The palette size is the 8-bit value plus 1, so 1 to 256 colours. The palette is stored as an image one pixel high, each entry delta-coded from the previous one per channel modulo 256. Pixels then hold indices in their green channel. An index at or past the end of the palette gives 0x00000000.

Small palettes bundle several pixels into one, and the image width becomes ⌈width ÷ 2^width_bits⌉.

Coding each pixel

Pixels are stored in scan-line order. The green prefix code gives a symbol S, which says what kind of pixel comes next.

LZ77 prefix coding

if prefix < 4:
    value = prefix + 1
else:
    extra  = (prefix - 2) >> 1
    offset = (2 + (prefix & 1)) << extra
    value  = offset + ReadBits(extra) + 1

Lengths use the first 24 prefix codes, for a maximum length of 4096. Distances use all 40.

A distance code above 120 is a scan-line distance of code − 120. Codes 1 to 120 are a table of nearby positions (x_i, y_i), and the distance is x_i + y_i × width, with a minimum of 1:

(0,1)  (1,0)  (1,1)  (-1,1) (0,2)  (2,0)  (1,2)  (-1,2) (2,1)  (-2,1)
(2,2)  (-2,2) (0,3)  (3,0)  (1,3)  (-1,3) (3,1)  (-3,1) (2,3)  (-2,3)
(3,2)  (-3,2) (0,4)  (4,0)  (1,4)  (-1,4) (4,1)  (-4,1) (3,3)  (-3,3)
(2,4)  (-2,4) (4,2)  (-4,2) (0,5)  (3,4)  (-3,4) (4,3)  (-4,3) (5,0)
(1,5)  (-1,5) (5,1)  (-5,1) (2,5)  (-2,5) (5,2)  (-5,2) (4,4)  (-4,4)
(3,5)  (-3,5) (5,3)  (-5,3) (0,6)  (6,0)  (1,6)  (-1,6) (6,1)  (-6,1)
(2,6)  (-2,6) (6,2)  (-6,2) (4,5)  (-4,5) (5,4)  (-5,4) (3,6)  (-3,6)
(6,3)  (-6,3) (0,7)  (7,0)  (1,7)  (-1,7) (5,5)  (-5,5) (7,1)  (-7,1)
(4,6)  (-4,6) (6,4)  (-6,4) (2,7)  (-2,7) (7,2)  (-7,2) (3,7)  (-3,7)
(7,3)  (-7,3) (5,6)  (-5,6) (6,5)  (-6,5) (8,0)  (4,7)  (-4,7) (7,4)
(-7,4) (8,1)  (8,2)  (6,6)  (-6,6) (8,3)  (5,7)  (-5,7) (7,5)  (-7,5)
(8,4)  (6,7)  (-6,7) (7,6)  (-7,6) (8,5)  (7,7)  (-7,7) (8,6)  (8,7)

The list reads left to right, so code 1 is (0,1), the pixel directly above; code 2 is (1,0), the pixel to the left; and code 3 is (1,1), the pixel above and to the left.

Colour cache

index = (0x1e35a7bd * color) >> (32 - color_cache_code_bits)     32-bit arithmetic

The cache starts zeroed and receives every pixel in stream order. There is a single lookup and no collision handling.

Prefix code groups

Each group has five canonical prefix codes.

The main ARGB image can use several groups. One bit says whether it does: 0 for one group, 1 for an entropy image. With an entropy image, 3 bits give prefix_bits = value + 2, and each pixel’s group is (entropy_pixel >> 8) & 0xffff. The number of groups is the largest index plus one.

Reading a prefix code

One bit selects the kind of code.

Simple code lengths (bit 1): one bit gives the number of symbols minus one, so one or two. One bit says whether the first symbol has 1 or 8 bits. The second symbol is always 8 bits. Each symbol gets length 1.

Normal code lengths (bit 0):

1. Read 4 bits and add 4 for the number of code-length code lengths. Each is 3 bits, in this order: 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.
2. One bit selects the symbol count: 0 means the alphabet size. With 1, read 3 bits x, then length_nbits = 2 + 2x, then max_symbol = 2 + ReadBits(length_nbits).
3. Decode the lengths with the table below.

The code must be complete, with a Kraft sum of exactly 1. The one exception is a single leaf with length 1.