package vendor:stb/image

Source

Io_Callbacks :: struct {
	read: proc "c" (user: rawptr, data: [^]u8, size: i32) -> i32,
	// fill 'data' with 'size' u8s.  return number of u8s actually read
	skip: proc "c" (user: rawptr, n: i32),
	// skip the next 'n' u8s, or 'unget' the last -n u8s if negative
	eof:  proc "c" (user: rawptr) -> i32,
}

datatype :: enum i32 {
	UINT8            = 0, 
	UINT8_SRGB       = 1, 
	UINT8_SRGB_ALPHA = 2, // alpha channel, when present, should also be SRGB (this is very unusual)
	UINT16           = 3, 
	FLOAT            = 4, 
	HALF_FLOAT       = 5, 
}

edge :: enum i32 {
	CLAMP   = 0, 
	REFLECT = 1, 
	WRAP    = 2, // this edge mode is slower and uses more memory
	ZERO    = 3, 
}

filter :: enum i32 {
	DEFAULT            = 0,  // use same filter type that the easy-to-use API chooses
	BOX                = 1,  // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios
	TRIANGLE           = 2,  // On upsampling, produces same results as bilinear texture filtering
	CUBICBSPLINE       = 3,  // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque
	CATMULLROM         = 4,  // An interpolating cubic spline (the default when upsampling)
	MITCHELL           = 5,  // Mitchell-Netrevalli filter with B=1/3, C=1/3 (the default when downsampling)
	POINT_SAMPLE       = 6,  // Simple point sampling
	MITCHELL_QUARTER   = 7,  // Mitchell-Netrevalli with B=1/4, C=3/8 (Robidoux), a little sharper than Mitchell
	MITCHELL_SIXTH     = 8,  // Mitchell-Netrevalli with B=1/6, C=5/12, sharper still
	MITCHELL_NEG_SIXTH = 9,  // Mitchell-Netrevalli with B=-1/6, C=7/12, over-sharpening
	MITCHELL_NEG_THIRD = 10, // Mitchell-Netrevalli with B=-1/3, C=2/3, more over-sharpening
	LANCZOS4           = 11, // Lanczos with 2 lobes (4 taps at 1:1), sharp, some ringing on hard edges
	LANCZOS5           = 12, // Lanczos with 2.5 lobes (5 taps at 1:1), very sharp, often ringy
	MURATORI6          = 13, // Casey Muratori's Bink 2 kernel (1 -4 19 19 -4 1)/32, stable under repeated half pixel shifts with 8-bit pixels
	OTHER              = 14, // User callback specified (keep last: the built-ins are everything below it)
}

input_callback :: proc "c" (optional_output: rawptr, input_ptr: rawptr, num_pixels: i32, x, y: i32, ctx: rawptr) -> rawptr

kernel_callback :: proc "c" (x, scale: f32, user_data: rawptr) -> f32

kernel_callback_new :: proc "c" (x, scale: f64, user_data: rawptr) -> f64

output_callback :: proc "c" (output_ptr: rawptr, num_pixels: i32, x, y: i32, ctx: rawptr)

pixel_layout :: enum i32 {
	BGR       = 0,  // 3 channels, with the order specified (for channel flipping)
	CHANNEL_1 = 1, 
	CHANNEL_2 = 2, 
	RGB       = 3,  // 3 channels, with the order specified (for channel flipping)
	RGBA      = 4,  // alpha formats, where alpha is NOT premultiplied into the color channels
	CHANNEL_4 = 5, 
	BGRA      = 6, 
	ARGB      = 7, 
	ABGR      = 8, 
	RA        = 9, 
	AR        = 10, 
	RGBA_PM   = 11, // alpha formats, where alpha IS premultiplied into the color channels
	BGRA_PM   = 12, 
	ARGB_PM   = 13, 
	ABGR_PM   = 14, 
	RA_PM     = 15, 
	AR_PM     = 16, 
}

radius_callback_new :: proc "c" (scale, inv_scale: f64, is_upsample: i32, user_data: rawptr) -> f64

resizer :: struct {
	user_data:                     rawptr,
	input_pixels:                  rawptr,
	input_w:                       i32,
	input_h:                       i32,
	input_s0:                      f64,
	input_t0:                      f64,
	input_s1:                      f64,
	input_t1:                      f64,
	input_s_n0:                    i32,
	input_s_n1:                    i32,
	input_s_d:                     i32,
	input_t_n0:                    i32,
	input_t_n1:                    i32,
	input_t_d:                     i32,
	input_cb:                      input_callback,
	output_pixels:                 rawptr,
	output_w:                      i32,
	output_h:                      i32,
	output_subx:                   i32,
	output_suby:                   i32,
	output_subw:                   i32,
	output_subh:                   i32,
	output_cb:                     output_callback,
	input_stride_in_bytes:         i64,
	output_stride_in_bytes:        i64,
	splits:                        i32,
	fast_alpha:                    i32,
	needs_rebuild:                 i32,
	called_alloc:                  i32,
	input_pixel_layout_public:     pixel_layout,
	output_pixel_layout_public:    pixel_layout,
	input_data_type:               datatype,
	output_data_type:              datatype,
	horizontal_filter:             filter,
	vertical_filter:               filter,
	horizontal_edge:               edge,
	vertical_edge:                 edge,
	horizontal_filter_kernel:      kernel_callback,
	horizontal_filter_support:     support_callback,
	vertical_filter_kernel:        kernel_callback,
	vertical_filter_support:       support_callback,
	horizontal_filter_kernel_new:  kernel_callback_new,
	horizontal_filter_support_new: support_callback_new,
	horizontal_filter_radius:      radius_callback_new,
	vertical_filter_kernel_new:    kernel_callback_new,
	vertical_filter_support_new:   support_callback_new,
	vertical_filter_radius:        radius_callback_new,
	samplers:                      rawptr,
}

support_callback :: proc "c" (scale: f32, user_data: rawptr) -> f32

support_callback_new :: proc "c" (scale: f64, user_data: rawptr) -> f64

write_func :: proc "c" (ctx: rawptr, data: rawptr, size: i32)

NO_STDIO :: ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32

PIXEL_LAYOUT_ABGR_NO_AW :: pixel_layout.ABGR_PM

PIXEL_LAYOUT_ARGB_NO_AW :: pixel_layout.ARGB_PM

PIXEL_LAYOUT_AR_NO_AW :: pixel_layout.AR_PM

PIXEL_LAYOUT_BGRA_NO_AW :: pixel_layout.BGRA_PM

PIXEL_LAYOUT_RA_NO_AW :: pixel_layout.RA_PM

PIXEL_LAYOUT_RGBA_NO_AW :: pixel_layout.RGBA_PM

build_samplers :: proc "c" (resize: ^resizer) -> i32 ---

build_samplers_with_splits :: proc "c" (resize: ^resizer, try_splits: i32) -> i32 ---

convert_iphone_png_to_rgb :: proc "c" (flag_true_if_should_convert: i32) ---

convert_iphone_png_to_rgb_thread :: proc "c" (flag_true_if_should_convert: b32) ---

failure_reason :: proc "c" () -> cstring ---

flip_vertically_on_write :: proc "c" (flip_boolean: b32) ---

free_samplers :: proc "c" (resize: ^resizer) ---

hdr_to_ldr_gamma :: proc "c" (gamma: f32) ---

hdr_to_ldr_scale :: proc "c" (scale: f32) ---

image_free :: proc "c" (retval_from_load: rawptr) ---

info :: proc "c" (filename: cstring, x, y, comp: ^i32) -> i32 ---

info_from_callbacks :: proc "c" (clbk: ^Io_Callbacks, user: rawptr, x, y, comp: ^i32) -> i32 ---

info_from_file :: proc "c" (f: ^c.FILE, x, y, comp: ^i32) -> i32 ---

info_from_memory :: proc "c" (buffer: [^]u8, len: i32, x, y, comp: ^i32) -> i32 ---

is_16_bit :: proc "c" (filename: cstring) -> b32 ---

is_16_bit_from_file :: proc "c" (f: ^c.FILE) -> b32 ---

is_16_bit_from_memory :: proc "c" (buffer: [^]u8, len: i32) -> i32 ---

is_hdr :: proc "c" (filename: cstring) -> i32 ---

is_hdr_from_callbacks :: proc "c" (clbk: ^Io_Callbacks, user: rawptr) -> i32 ---

is_hdr_from_file :: proc "c" (f: ^c.FILE) -> i32 ---

is_hdr_from_memory :: proc "c" (buffer: [^]u8, len: i32) -> i32 ---

ldr_to_hdr_gamma :: proc "c" (gamma: f32) ---

ldr_to_hdr_scale :: proc "c" (scale: f32) ---

load :: proc "c" (
	filename:               cstring, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u8 ---

load_16 :: proc "c" (
	filename:               cstring, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u16 ---

load_16_from_callbacks :: proc "c" (
	clbk:                   ^Io_Callbacks, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u16 ---

load_16_from_file :: proc "c" (
	f:                      ^c.FILE, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u16 ---

load_16_from_memory :: proc "c" (
	buffer:                 [^]u8, 
	len:                    i32, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u16 ---

load_from_callbacks :: proc "c" (
	clbk:                   ^Io_Callbacks, 
	user:                   rawptr, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u8 ---

load_from_file :: proc "c" (
	f:                      ^c.FILE, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u8 ---

load_from_memory :: proc "c" (
	buffer:                 [^]u8, 
	len:                    i32, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]u8 ---

load_gif_from_memory :: proc "c" (
	buffer:        [^]u8, 
	len:           i32, 
	delays:        ^[^]i32, 
	x, y, z, comp: ^i32, 
	req_comp:      i32, 
) -> [^]u8 ---

loadf :: proc "c" (
	filename:               cstring, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]f32 ---

loadf_from_callbacks :: proc "c" (
	clbk:                   ^Io_Callbacks, 
	user:                   rawptr, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]f32 ---

loadf_from_file :: proc "c" (
	f:                      ^c.FILE, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]f32 ---

loadf_from_memory :: proc "c" (
	buffer:                 [^]u8, 
	len:                    i32, 
	x, y, channels_in_file: ^i32, 
	desired_channels:       i32, 
) -> [^]f32 ---

resize :: proc "c" (
	input_pixels:                               rawptr, 
	input_w, input_h, input_stride_in_bytes:    i64, 
	output_pixels:                              rawptr, 
	output_w, output_h, output_stride_in_bytes: i64, 
	pixel_layout:                               pixel_layout, 
	data_type:                                  datatype, 
	edge:                                       edge, 
	filter:                                     filter, 
) -> rawptr ---

resize_extended :: proc "c" (resize: ^resizer) -> i32 ---

resize_extended_split :: proc "c" (resize: ^resizer, split_start, split_count: i32) -> i32 ---

resize_float_linear :: proc "c" (
	input_pixels:                               [^]f32, 
	input_w, input_h, input_stride_in_bytes:    i64, 
	output_pixels:                              [^]f32, 
	output_w, output_h, output_stride_in_bytes: i64, 
	pixel_type:                                 pixel_layout, 
) -> [^]f32 ---

resize_init :: proc "c" (
	resize:                                     ^resizer, 
	input_pixels:                               rawptr, 
	input_w, input_h, input_stride_in_bytes:    i64, 
	output_pixels:                              rawptr, 
	output_w, output_h, output_stride_in_bytes: i64, 
	pixel_layout:                               pixel_layout, 
	data_type:                                  datatype, 
) ---

resize_uint8_linear :: proc "c" (
	input_pixels:                               [^]u8, 
	input_w, input_h, input_stride_in_bytes:    i64, 
	output_pixels:                              [^]u8, 
	output_w, output_h, output_stride_in_bytes: i64, 
	pixel_type:                                 pixel_layout, 
) -> [^]u8 ---

resize_uint8_srgb :: proc "c" (
	input_pixels:                               [^]u8, 
	input_w, input_h, input_stride_in_bytes:    i64, 
	output_pixels:                              [^]u8, 
	output_w, output_h, output_stride_in_bytes: i64, 
	pixel_type:                                 pixel_layout, 
) -> [^]u8 ---

set_buffer_ptrs :: proc "c" (
	resize:                 ^resizer, 
	input_pixels:           rawptr, 
	input_stride_in_bytes:  i64, 
	output_pixels:          rawptr, 
	output_stride_in_bytes: i64, 
) ---

set_datatypes :: proc "c" (resize: ^resizer, input_type, output_type: datatype) ---

set_edgemodes :: proc "c" (resize: ^resizer, horizontal_edge, vertical_edge: edge) -> i32 ---

set_filter_callbacks :: proc "c" (
	resize:             ^resizer, 
	horizontal_filter:  kernel_callback, 
	horizontal_support: support_callback, 
	vertical_filter:    kernel_callback, 
	vertical_support:   support_callback, 
) -> i32 ---

set_filter_callbacks_new :: proc "c" (
	resize:             ^resizer, 
	horizontal_filter:  kernel_callback_new, 
	horizontal_support: support_callback_new, 
	horizontal_radius:  radius_callback_new, 
	vertical_filter:    kernel_callback_new, 
	vertical_support:   support_callback_new, 
	vertical_radius:    radius_callback_new, 
) -> i32 ---

set_filters :: proc "c" (resize: ^resizer, horizontal_filter, vertical_filter: filter) -> i32 ---

set_flip_vertically_on_load :: proc "c" (flag_true_if_should_flip: i32) ---

set_flip_vertically_on_load_thread :: proc "c" (flag_true_if_should_flip: b32) ---

set_input_subrect :: proc "c" (resize: ^resizer, s0, t0, s1, t1: f64) -> i32 ---

set_non_pm_alpha_speed_over_quality :: proc "c" (
	resize:                           ^resizer, 
	non_pma_alpha_speed_over_quality: i32, 
) -> i32 ---

set_output_pixel_subrect :: proc "c" (resize: ^resizer, subx, suby, subw, subh: i32) -> i32 ---

set_pixel_callbacks :: proc "c" (
	resize:    ^resizer, 
	input_cb:  input_callback, 
	output_cb: output_callback, 
) ---

set_pixel_layouts :: proc "c" (
	resize:                                  ^resizer, 
	input_pixel_layout, output_pixel_layout: pixel_layout, 
) -> i32 ---

set_pixel_subrect :: proc "c" (resize: ^resizer, subx, suby, subw, subh: i32) -> i32 ---

set_unpremultiply_on_load :: proc "c" (flag_true_if_should_unpremultiply: i32) ---

set_unpremultiply_on_load_thread :: proc "c" (flag_true_if_should_unpremultiply: b32) ---

set_user_data :: proc "c" (resize: ^resizer, user_data: rawptr) ---

write_bmp :: proc "c" (filename: cstring, w, h, comp: i32, data: rawptr) -> i32 ---

write_bmp_to_func :: proc "c" (
	func:       write_func, 
	ctx:        rawptr, 
	w, h, comp: i32, 
	data:       rawptr, 
) -> i32 ---

write_hdr :: proc "c" (filename: cstring, w, h, comp: i32, data: [^]f32) -> i32 ---

write_hdr_to_func :: proc "c" (
	func:       write_func, 
	ctx:        rawptr, 
	w, h, comp: i32, 
	data:       [^]f32, 
) -> i32 ---

write_jpg :: proc "c" (
	filename:   cstring, 
	w, h, comp: i32, 
	data:       rawptr, 
	quality:    i32, 
) -> i32 ---

write_jpg_to_func :: proc "c" (
	func:       write_func, 
	ctx:        rawptr, 
	x, y, comp: i32, 
	data:       rawptr, 
	quality:    i32, 
) -> i32 ---

write_png :: proc "c" (
	filename:        cstring, 
	w, h, comp:      i32, 
	data:            rawptr, 
	stride_in_bytes: i32, 
) -> i32 ---

write_png_to_func :: proc "c" (
	func:            write_func, 
	ctx:             rawptr, 
	w, h, comp:      i32, 
	data:            rawptr, 
	stride_in_bytes: i32, 
) -> i32 ---

write_tga :: proc "c" (filename: cstring, w, h, comp: i32, data: rawptr) -> i32 ---

write_tga_to_func :: proc "c" (
	func:       write_func, 
	ctx:        rawptr, 
	w, h, comp: i32, 
	data:       rawptr, 
) -> i32 ---

zlib_decode_buffer :: proc "c" (obuffer: [^]u8, olen: i32, ibuffer: [^]u8, ilen: i32) -> i32 ---

zlib_decode_malloc :: proc "c" (buffer: [^]u8, len: i32, outlen: ^i32) -> [^]u8 ---

zlib_decode_malloc_guesssize :: proc "c" (
	buffer:       [^]u8, 
	len:          i32, 
	initial_size: i32, 
	outlen:       ^i32, 
) -> [^]u8 ---

zlib_decode_malloc_guesssize_headerflag :: proc "c" (
	buffer:       [^]u8, 
	len:          i32, 
	initial_size: i32, 
	outlen:       ^i32, 
	parse_header: b32, 
) -> [^]u8 ---

zlib_decode_noheader_buffer :: proc "c" (
	obuffer: [^]u8, 
	olen:    i32, 
	ibuffer: [^]u8, 
	ilen:    i32, 
) -> i32 ---

zlib_decode_noheader_malloc :: proc "c" (buffer: [^]u8, len: i32, outlen: ^i32) -> [^]u8 ---