[image] Add QOI load/save.

Additionally:
- Firm up PNG loader with some additional checks.
- Add helper functions to `core:image` to expand grayscale to RGB(A), and so on.

TODO: Possibly replace PNG's post-processing steps with calls to the new helper functions.

1 files changed, 407 insertions, 0 deletions

diff --git a/core/image/qoi/qoi.odin b/core/image/qoi/qoi.odin
new file mode 100644
index 000000000..c157e8099
--- /dev/null
+++ b/core/image/qoi/qoi.odin
@@ -0,0 +1,407 @@
+/*

+	Copyright 2022 Jeroen van Rijn <nom@duclavier.com>.

+	Made available under Odin's BSD-3 license.

+

+	List of contributors:

+		Jeroen van Rijn: Initial implementation.

+*/

+

+

+// package qoi implements a QOI image reader

+//

+// The QOI specification is at https://qoiformat.org.

+package qoi

+

+import "core:mem"

+import "core:image"

+import "core:compress"

+import "core:bytes"

+import "core:os"

+

+Error   :: image.Error

+General :: compress.General_Error

+Image   :: image.Image

+Options :: image.Options

+

+RGB_Pixel  :: image.RGB_Pixel

+RGBA_Pixel :: image.RGBA_Pixel

+

+save_to_memory  :: proc(output: ^bytes.Buffer, img: ^Image, options := Options{}, allocator := context.allocator) -> (err: Error) {

+	context.allocator = allocator

+

+	if img == nil {

+		return .Invalid_Input_Image

+	}

+

+	if output == nil {

+		return .Invalid_Output

+	}

+

+	pixels := img.width * img.height

+	if pixels == 0 || pixels > image.MAX_DIMENSIONS {

+		return .Invalid_Input_Image

+	}

+

+	// QOI supports only 8-bit images with 3 or 4 channels.

+	if img.depth != 8 || img.channels < 3 || img.channels > 4 {

+		return .Invalid_Input_Image

+	}

+

+	if img.channels * pixels != len(img.pixels.buf) {

+		return .Invalid_Input_Image

+	}

+

+	written := 0

+

+	// Calculate and allocate maximum size. We'll reclaim space to actually written output at the end.

+	max_size := pixels * (img.channels + 1) + size_of(image.QOI_Header) + size_of(u64be)

+

+	if !resize(&output.buf, max_size) {

+		return General.Resize_Failed

+	}

+

+	header := image.QOI_Header{

+		magic       = image.QOI_Magic,

+		width       = u32be(img.width),

+		height      = u32be(img.height),

+		channels    = u8(img.channels),

+		color_space = .Linear if .qoi_all_channels_linear in options else .sRGB,

+	}

+	header_bytes := transmute([size_of(image.QOI_Header)]u8)header

+

+	copy(output.buf[written:], header_bytes[:])

+	written += size_of(image.QOI_Header)

+

+	/*

+		Encode loop starts here.

+	*/

+	seen: [64]RGBA_Pixel

+	pix  := RGBA_Pixel{0, 0, 0, 255}

+	prev := pix

+

+	seen[qoi_hash(pix)] = pix

+

+	input := img.pixels.buf[:]

+	run   := u8(0)

+

+	for len(input) > 0 {

+		if img.channels == 4 {

+			pix     = (^RGBA_Pixel)(raw_data(input))^

+		} else {

+			pix.rgb = (^RGB_Pixel)(raw_data(input))^

+		}

+		input = input[img.channels:]

+

+		if pix == prev {

+			run += 1

+			// As long as the pixel matches the last one, accumulate the run total.

+			// If we reach the max run length or the end of the image, write the run.

+			if run == 62 || len(input) == 0 {

+				// Encode and write run

+				output.buf[written] = u8(QOI_Opcode_Tag.RUN) | (run - 1)

+				written += 1

+				run = 0

+			}

+		} else {

+			if run > 0 {

+				// The pixel differs from the previous one, but we still need to write the pending run.

+				// Encode and write run

+				output.buf[written] = u8(QOI_Opcode_Tag.RUN) | (run - 1)

+				written += 1

+				run = 0

+			}

+

+			index := qoi_hash(pix)

+

+			if seen[index] == pix {

+				// Write indexed pixel

+				output.buf[written] = u8(QOI_Opcode_Tag.INDEX) | index

+				written += 1

+			} else {

+				// Add pixel to index

+				seen[index] = pix

+

+				// If the alpha matches the previous pixel's alpha, we don't need to write a full RGBA literal.

+				if pix.a == prev.a {

+					// Delta

+					d  := pix.rgb - prev.rgb

+

+					// DIFF, biased and modulo 256

+					_d := d + 2

+

+					// LUMA, biased and modulo 256

+					_l := RGB_Pixel{ d.r - d.g + 8, d.g + 32, d.b - d.g + 8 }

+

+					if _d.r < 4 && _d.g < 4 && _d.b < 4 {

+						// Delta is between -2 and 1 inclusive

+						output.buf[written] = u8(QOI_Opcode_Tag.DIFF) | _d.r << 4 | _d.g << 2 | _d.b

+						written += 1

+					} else if _l.r < 16 && _l.g < 64 && _l.b < 16 {

+						// Biased luma is between {-8..7, -32..31, -8..7}

+						output.buf[written    ] = u8(QOI_Opcode_Tag.LUMA) | _l.g

+						output.buf[written + 1] = _l.r << 4 | _l.b

+						written += 2

+					} else {

+						// Write RGB literal

+						output.buf[written] = u8(QOI_Opcode_Tag.RGB)

+						pix_bytes := transmute([4]u8)pix

+						copy(output.buf[written + 1:], pix_bytes[:3])

+						written += 4

+					}

+				} else {

+					// Write RGBA literal

+					output.buf[written] = u8(QOI_Opcode_Tag.RGBA)

+					pix_bytes := transmute([4]u8)pix

+					copy(output.buf[written + 1:], pix_bytes[:])

+					written += 5

+				}

+			}

+		}

+		prev = pix

+	}

+

+	trailer := []u8{0, 0, 0, 0, 0, 0, 0, 1}

+	copy(output.buf[written:], trailer[:])

+	written += len(trailer)

+

+	resize(&output.buf, written)

+	return nil

+}

+

+save_to_file :: proc(output: string, img: ^Image, options := Options{}, allocator := context.allocator) -> (err: Error) {

+	context.allocator = allocator

+

+	out := &bytes.Buffer{}

+	defer bytes.buffer_destroy(out)

+

+	save_to_memory(out, img, options) or_return

+	write_ok := os.write_entire_file(output, out.buf[:])

+

+	return nil if write_ok else General.Cannot_Open_File

+}

+

+save :: proc{save_to_memory, save_to_file}

+

+load_from_slice :: proc(slice: []u8, options := Options{}, allocator := context.allocator) -> (img: ^Image, err: Error) {

+	ctx := &compress.Context_Memory_Input{

+		input_data = slice,

+	}

+

+	img, err = load_from_context(ctx, options, allocator)

+	return img, err

+}

+

+load_from_file :: proc(filename: string, options := Options{}, allocator := context.allocator) -> (img: ^Image, err: Error) {

+	context.allocator = allocator

+

+	data, ok := os.read_entire_file(filename)

+	defer delete(data)

+

+	if ok {

+		return load_from_slice(data, options)

+	} else {

+		img = new(Image)

+		return img, compress.General_Error.File_Not_Found

+	}

+}

+

+@(optimization_mode="speed")

+load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.allocator) -> (img: ^Image, err: Error) {

+	context.allocator = allocator

+	options := options

+

+	if .alpha_drop_if_present in options || .alpha_premultiply in options {

+		// TODO: Implement.

+		// As stated in image/common, unimplemented options are ignored.

+	}

+

+	if .info in options {

+		options |= {.return_metadata, .do_not_decompress_image}

+		options -= {.info}

+	}

+

+	if .return_header in options && .return_metadata in options {

+		options -= {.return_header}

+	}

+

+	header := image.read_data(ctx, image.QOI_Header) or_return

+	if header.magic != image.QOI_Magic {

+		return img, .Invalid_QOI_Signature

+	}

+

+	if img == nil {

+		img = new(Image)

+	}

+

+	if .return_metadata in options {

+		info := new(image.QOI_Info)

+		info.header  = header

+		img.metadata = info		

+	}

+

+	if header.channels != 3 && header.channels != 4 {

+		return img, .Invalid_Number_Of_Channels

+	}

+

+	if header.color_space != .sRGB && header.color_space != .Linear {

+		return img, .Invalid_Color_Space

+	}

+

+	if header.width == 0 || header.height == 0 {

+		return img, .Invalid_Image_Dimensions

+	}

+

+	total_pixels := header.width * header.height

+	if total_pixels > image.MAX_DIMENSIONS {

+		return img, .Image_Dimensions_Too_Large

+	}

+

+	img.width    = int(header.width)

+	img.height   = int(header.height)

+	img.channels = 4

+	img.depth    = 8

+

+	if .do_not_decompress_image in options {

+		return

+	}

+

+	bytes_needed := image.compute_buffer_size(int(header.width), int(header.height), 4, 8)

+

+	if !resize(&img.pixels.buf, bytes_needed) {

+	 	return img, mem.Allocator_Error.Out_Of_Memory

+	}

+	pixels := mem.slice_data_cast([]RGBA_Pixel, img.pixels.buf[:])

+

+	/*

+		Decode loop starts here.

+	*/

+	seen: [64]RGBA_Pixel

+	pix := RGBA_Pixel{0, 0, 0, 255}

+	seen[qoi_hash(pix)] = pix

+

+	decode: for len(pixels) > 0 {

+		data := image.read_u8(ctx) or_return

+

+		tag := QOI_Opcode_Tag(data)

+		#partial switch tag {

+		case .RGB:

+			pix.rgb = image.read_data(ctx, RGB_Pixel) or_return

+

+			#no_bounds_check {

+				seen[qoi_hash(pix)] = pix	

+			}

+

+		case .RGBA:

+			pix = image.read_data(ctx, RGBA_Pixel) or_return

+

+			#no_bounds_check {

+				seen[qoi_hash(pix)] = pix	

+			}

+

+		case:

+			// 2-bit tag

+			tag = QOI_Opcode_Tag(data & QOI_Opcode_Mask)

+			#partial switch tag {

+				case .INDEX:

+					pix = seen[data & 63]

+

+				case .DIFF:

+					diff_r := ((data >> 4) & 3) - 2

+					diff_g := ((data >> 2) & 3) - 2

+					diff_b := ((data >> 0) & 3) - 2

+

+					pix += {diff_r, diff_g, diff_b, 0}

+

+					#no_bounds_check {

+						seen[qoi_hash(pix)] = pix	

+					}

+

+				case .LUMA:

+					data2 := image.read_u8(ctx) or_return

+

+					diff_g := (data & 63) - 32

+					diff_r := diff_g - 8 + ((data2 >> 4) & 15)

+					diff_b := diff_g - 8 + (data2 & 15)

+

+					pix += {diff_r, diff_g, diff_b, 0}

+

+					#no_bounds_check {

+						seen[qoi_hash(pix)] = pix	

+					}

+

+				case .RUN:

+					if length := int(data & 63) + 1; length > len(pixels) {

+						return img, .Corrupt

+					} else {

+						#no_bounds_check for i in 0..<length {

+							pixels[i] = pix

+						}

+						pixels = pixels[length:]

+					}

+

+					continue decode

+

+				case:

+					unreachable()

+			}

+		}

+

+		#no_bounds_check {

+			pixels[0] = pix

+			pixels = pixels[1:]

+		}

+	}

+

+	// The byte stream's end is marked with 7 0x00 bytes followed by a single 0x01 byte.

+	trailer, trailer_err := compress.read_data(ctx, u64be)

+	if trailer_err != nil || trailer != 0x1 {

+		return img, .Missing_Or_Corrupt_Trailer

+	}

+	return

+}

+

+load :: proc{load_from_file, load_from_slice, load_from_context}

+

+/*

+	Cleanup of image-specific data.

+*/

+destroy :: proc(img: ^Image) {

+	if img == nil {

+		/*

+			Nothing to do.

+			Load must've returned with an error.

+		*/

+		return

+	}

+

+	bytes.buffer_destroy(&img.pixels)

+

+	if v, ok := img.metadata.(^image.QOI_Info); ok {

+	 	free(v)

+	}

+	free(img)

+}

+

+QOI_Opcode_Tag :: enum u8 {

+	// 2-bit tags

+	INDEX = 0b0000_0000, // 6-bit index into color array follows

+	DIFF  = 0b0100_0000, // 3x (RGB) 2-bit difference follows (-2..1), bias of 2.

+	LUMA  = 0b1000_0000, // Luma difference

+	RUN   = 0b1100_0000, // Run length encoding, bias -1

+

+	// 8-bit tags

+	RGB   = 0b1111_1110, // Raw RGB  pixel follows

+	RGBA  = 0b1111_1111, // Raw RGBA pixel follows

+}

+

+QOI_Opcode_Mask :: 0b1100_0000

+QOI_Data_Mask   :: 0b0011_1111

+

+qoi_hash :: #force_inline proc(pixel: RGBA_Pixel) -> (index: u8) {

+	i1 := u16(pixel.r) * 3

+	i2 := u16(pixel.g) * 5

+	i3 := u16(pixel.b) * 7

+	i4 := u16(pixel.a) * 11

+

+	return u8((i1 + i2 + i3 + i4) & 63)

+}
\ No newline at end of file