package core:image/png

Source

CIE_1931 :: struct #packed {
	x: f32,
	y: f32,
}

CIE_1931_Raw :: struct #packed {
	x: u32be,
	y: u32be,
}

Error :: image.Error

Filter_Params :: struct #packed {
	src:      []u8,
	dest:     []u8,
	width:    int,
	height:   int,
	depth:    int,
	channels: int,
	rescale:  bool,
}

Image :: image.Image

Options :: image.Options

PLTE :: struct #packed {
	entries: [256][3]u8,
	used:    u16,
}

PLTE_Entry :: [3]u8

Row_Filter :: enum u8 {
	None    = 0, 
	Sub     = 1, 
	Up      = 2, 
	Average = 3, 
	Paeth   = 4, 
}

Signature :: enum u64be {
	// 0x89504e470d0a1a0a
	PNG = 0x89 << 56 | 'P' << 48 | 'N' << 40 | 'G' << 32 | '\r' << 24 | '\n' << 16 | 0x1a << 8 | '\n', 
}

Text :: struct {
	keyword:           string,
	keyword_localized: string,
	language:          string,
	text:              string,
}

cHRM :: struct #packed {
	w: CIE_1931,
	r: CIE_1931,
	g: CIE_1931,
	b: CIE_1931,
}

cHRM_Raw :: struct #packed {
	w: CIE_1931_Raw,
	r: CIE_1931_Raw,
	g: CIE_1931_Raw,
	b: CIE_1931_Raw,
}

gAMA :: struct {
	gamma_100k: u32be,
}

hIST :: struct #packed {
	entries: [256]u16,
	used:    u16,
}

iCCP :: struct {
	name:    string,
	profile: []u8,
}

pHYs :: struct #packed {
	ppu_x: u32be,
	ppu_y: u32be,
	unit:  pHYs_Unit,
}

pHYs_Unit :: enum u8 {
	Unknown = 0, 
	Meter   = 1, 
}

sPLT :: struct #packed {
	name:    string,
	depth:   u8,
	entries: union {
		[][4]u8, 
		[][4]u16, 
	},
	used:    u16,
}

sRGB :: struct #packed {
	intent: sRGB_Rendering_Intent,
}

sRGB_Rendering_Intent :: enum u8 {
	Perceptual            = 0, 
	Relative_colorimetric = 1, 
	Saturation            = 2, 
	Absolute_colorimetric = 3, 
}

tIME :: struct #packed {
	year:   u16be,
	month:  u8,
	day:    u8,
	hour:   u8,
	minute: u8,
	second: u8,
}

INCHES_PER_METER :: 1000.0 / 25.4

MAX_CHUNK_SIZE :: min(#config(PNG_MAX_CHUNK_SIZE, 16_777_216), 268_435_456)

MAX_IDAT_SIZE :: min(#config(PNG_MAX_IDAT_SIZE, _MAX_IDAT_DEFAULT), _MAX_IDAT)

depth_scale_table: []u8 : []u8{0, 0xff, 0x55, 0, 0x11, 0, 0, 0, 0x01}

ADAM7_X_ORIG: []int = …

ADAM7_X_SPACING: []int = …

ADAM7_Y_ORIG: []int = …

ADAM7_Y_SPACING: []int = …

append_chunk :: proc(
	list:      ^[dynamic]image.PNG_Chunk, 
	src:       image.PNG_Chunk, 
	allocator := context.allocator, 
) -> (err: image.Error) {…}

chrm :: proc(c: image.PNG_Chunk) -> (res: cHRM, ok: bool) {…}

chunk_type_to_name :: proc(type: ^image.PNG_Chunk_Type) -> string {…}

compute_buffer_size :: image.compute_buffer_size

copy_chunk :: proc(
	src:       image.PNG_Chunk, 
	allocator := context.allocator, 
) -> (dest: image.PNG_Chunk, err: image.Error) {…}

core_time :: proc(c: image.PNG_Chunk) -> (t: time.Time, ok: bool) {…}

defilter :: proc(
	img:          ^image.Image, 
	filter_bytes: ^bytes.Buffer, 
	header:       ^image.PNG_IHDR, 
	options:      image.Options, 
) -> (err: image.Error) {…}

defilter_16 :: proc(params: ^Filter_Params) -> bool {…}

defilter_8 :: proc(params: ^Filter_Params) -> (ok: bool) {…}

defilter_less_than_8 :: proc(params: ^Filter_Params) -> bool {…}

destroy :: proc(img: ^image.Image) {…}

exif :: proc(c: image.PNG_Chunk) -> (res: image.Exif, ok: bool) {…}

filter_paeth :: proc(left, up, up_left: u8) -> u8 {…}

gamma :: proc(c: image.PNG_Chunk) -> (res: f32, ok: bool) {…}

hist :: proc(c: image.PNG_Chunk) -> (res: hIST, ok: bool) {…}

iccp :: proc(c: image.PNG_Chunk) -> (res: iCCP, ok: bool) {…}

iccp_destroy :: proc(i: iCCP) {…}

load_from_bytes :: proc(
	data:      []u8, 
	options:   image.Options = Options{}, 
	allocator := context.allocator, 
) -> (img: ^image.Image, err: image.Error) {…}

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

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

phys :: proc(c: image.PNG_Chunk) -> (res: pHYs, ok: bool) {…}

phys_to_dpi :: proc(p: pHYs) -> (x_dpi, y_dpi: f32) {…}

plte :: proc(c: image.PNG_Chunk) -> (res: PLTE, ok: bool) {…}

read_chunk :: proc(ctx: ^$C) -> (chunk: image.PNG_Chunk, err: image.Error) {…}

read_header :: proc(ctx: ^$C) -> (image.PNG_IHDR, image.Error) {…}

sbit :: proc(c: image.PNG_Chunk) -> (res: [4]u8, ok: bool) {…}

splt :: proc(c: image.PNG_Chunk) -> (res: sPLT, ok: bool) {…}

splt_destroy :: proc(s: sPLT) {…}

srgb :: proc(c: image.PNG_Chunk) -> (res: sRGB, ok: bool) {…}

text :: proc(c: image.PNG_Chunk) -> (res: Text, ok: bool) {…}

text_destroy :: proc(text: Text) {…}

time :: proc(c: image.PNG_Chunk) -> (res: tIME, ok: bool) {…}

load :: proc{
	load_from_file,
	load_from_bytes,
	load_from_context,
}