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

Exif :: struct {
	byte_order: enum int {
		little_endian, 
		big_endian, 
	},
	data:       []u8,
}

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 = 9894494448401390090, 
}

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 {…}

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: 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, allocator: runtime.Allocator) -> (img: ^image.Image, err: image.Error) {…}

load_from_context :: proc(ctx: ^$T, 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: ^$T) -> (chunk: image.PNG_Chunk, err: image.Error) {…}

read_header :: proc(ctx: ^$T) -> (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,
}