> technical stuff > the file formats > images

images

images in .veado files are written from bottom to top, left to right.

the AIMG chunk

provides information on an image, static or animated.

then for each frame in n:

the ABMP chunk

provides texture data.

texture formats

the RAW. format

textures stored as raw are saved as RGBA, one byte per channel, 0 to 255, from bottom to top, then left to right.

the VDD. format

the VeadoDelta texture format is a sub-byte RLE encoding, meant to work well with multithreading (one thread per channel both for read and write). has small sizes for illustrations and vector images, not so much but still a lot better than raw for photos.

it stores everything in 4-byte unsigned integers (uint), and just like the raw format, each value ranges from 0 to 255, encoding from bottom to top, then left to right.

the first 4 uints in the buffer represent the length (in uints, so multiply that by 4 to get the length in bytes) of each channel, and then after those 4, each channel is encoded separately. alpha is encoded first, then R, G, and B.

if the length of a channel is at least 0xFFFFFF00, the length is considered to be zero, and the least-significant byte is used as the constant value of that channel throughout the entire image. for example, a length of 0xFFFFFF80 means this channel doesn’t have an uint buffer, and the channel value is 0x80 (aka 128) for all pixels.

when encoding a channel other than alpha, values where the corresponding pixel has an alpha of value zero are skipped.

to encode a channel, it first takes the value sequence and applies the difference between the current value and the previous one. for the first value, if we’re encoding the alpha channel, the delta value is the difference between the current value and 255; otherwise, the delta value is the same as the current value.

here’s an example:

the delta values are stored as signed bytes, meaning that they range from -128 to 127 and take advantage of byte overflows/underflows:

the delta values are then encoded as prefix codes of variable bit length:

the sign segment is 1 for positive, and0 for negative.

when 0 is repeated at least 7 times, instead of encoding it as multiple 10, it is instead encoded like this, where n is the number of zeroes, with a maximum value of 262:

let’s encode some values, as an example:

then each sequence is encoded into the uint buffer of the channel, where we can fit 32 bits, from the least to the most significant bits. any remaining bits in a sequence leak into the next uint, again starting on the least signficant bits.

let’s take our previous example and encode it as an uint buffer:

note that even though the sequence ordering will look reversed (due to adding each sequence to the least significant bits first), the order of bits inside each sequence is kept intact.

this channel would therefore be encoded as two uints: 0xF83B527B and 0xD40!

to parse each value in a channel, a similar but reverse process would be done: every time you need to read a delta value from the uint buffer, you’d read one bit from the current uint until it matches a prefix, then read a number of a certain bit length, and then read the sign bit if applicable.

the following pseudo-code explains the process of parsing each delta value, and how many times said value should be repeated:

delta = 0
repeat = 1

if readBits(1) == 1:
    if readBits(1) == 1:
    	delta = readBits(1) + 1
elif readBits(1) == 1:
	if readBits(1) == 0:
		delta = readBits(1) + 3
	else:
		delta = readBits(2) + 5
elif readBits(1) == 1:
	if readBits(1) == 0:
		delta = readBits(3) + 9
	else:
		delta = readBits(4) + 17
elif readBits(1) == 1:
	if readBits(1) == 0:
		delta = readBits(5) + 33
	else:
		delta = readBits(6) + 65
else:
	repeat = readBits(8) + 7

if delta != 0:
	if readBits(1) == 0:
		delta = -delta

in this example, readBits(n) is a function that consumes n bits from the uint buffer, starting from the least significant bits, and reading from the next uint if the remaining bits in the current uint aren’t enough.

this would yield the delta value sequence – from it, you can convert it into the absolute value sequence by accumulating it:

delta_sequence = [...] # assuming this is populated with delta values

current_value = 0 # or 255, if we're parsing the alpha channel
final_sequence = []
for delta in delta_sequence:
	current_value = current_value + delta
	current_value = modulo(current_value, 256) # ensure we're within byte range
	final_sequence.push(current_value)

when reading each channel, you may start by parsing the alpha channel before the other ones. this way, you know which pixels have an alpha value of zero, and thus you can parse the other channels directly into pixels by skipping the zero alpha ones.