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

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

Row_Filter :: sPLT

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

load_from_file :: PLTE_Entry

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

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

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_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}

load :: MAX_CHUNK_SIZE

ADAM7_X_ORIG: []int = …

ADAM7_X_SPACING: []int = …

ADAM7_Y_SPACING: []int = …

hIST :: ADAM7_Y_ORIG

ADAM7_X_SPACING :: text

CIE_1931_Raw :: defilter_16

MAX_CHUNK_SIZE :: core_time

Options :: phys

Options :: destroy

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

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

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

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

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 :: sbit

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_to_dpi :: proc(p: pHYs) -> (x_dpi, y_dpi: f32) {…}

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

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

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_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,
}