package vendor:OpenEXRCore

Source

attr_box2f_t :: struct #packed {
	min: attr_v2f_t,
	max: attr_v2f_t,
}

attr_box2i_t :: struct #packed {
	min: attr_v2i_t,
	max: attr_v2i_t,
}

attr_chlist_entry_t :: struct {
	name:       attr_string_t,
	// Data representation for these pixels: uint, half, float. 
	pixel_type: pixel_type_t,
	// Possible values are 0 and 1 per docs perceptual_treatment_t. 
	p_linear:   u8,
	reserved:   [3]u8,
	x_sampling: i32,
	y_sampling: i32,
}

attr_chlist_t :: struct {
	num_channels: i32,
	num_alloced:  i32,
	entries:      [^]attr_chlist_entry_t,
}

attr_chromaticities_t :: struct #packed {
	red_x:   f32,
	red_y:   f32,
	green_x: f32,
	green_y: f32,
	blue_x:  f32,
	blue_y:  f32,
	white_x: f32,
	white_y: f32,
}

attr_float_vector_t :: struct {
	length:     i32,
	// If this is non-zero, the float vector owns the data, if 0, is a const ref. 
	alloc_size: i32,
	arr:        [^]f32,
}

attr_keycode_t :: struct #packed {
	film_mfc_code:   i32,
	film_type:       i32,
	prefix:          i32,
	count:           i32,
	perf_offset:     i32,
	perfs_per_frame: i32,
	perfs_per_count: i32,
}

attr_list_access_mode_t :: enum i32 {
	FILE_ORDER,   // *< Order they appear in the file
	SORTED_ORDER, // *< Alphabetically sorted
}

attr_m33d_t :: struct #packed {
	m: [9]f64,
}

attr_m33f_t :: struct #packed {
	m: [9]f32,
}

attr_m44d_t :: struct #packed {
	m: [16]f64,
}

attr_m44f_t :: struct #packed {
	m: [16]f32,
}

attr_opaquedata_t :: struct {
	size:                      i32,
	unpacked_size:             i32,
	// If this is non-zero, the struct owns the data, if 0, is a const ref. 
	packed_alloc_size:         i32,
	pad:                       [4]u8,
	packed_data:               rawptr,
	// When an application wants to have custom data, they can store
	// 	 * an unpacked form here which will be requested to be destroyed
	// 	 * upon destruction of the attribute.
	unpacked_data:             rawptr,
	// An application can register an attribute handler which then
	// 	 * fills in these function pointers. This allows a user to delay
	// 	 * the expansion of the custom type until access is desired, and
	// 	 * similarly, to delay the packing of the data until write time.
	unpack_func_ptr:           proc "c" (ctxt: context_t, data: rawptr, attrsize: i32, outsize: ^i32, outbuffer: ^rawptr) -> result_t,
	pack_func_ptr:             proc "c" (ctxt: context_t, data: rawptr, datasize: i32, outsize: ^i32, outbuffer: rawptr) -> result_t,
	destroy_unpacked_func_ptr: proc "c" (ctxt: context_t, data: rawptr, attrsize: i32),
}

attr_preview_t :: struct {
	width:      u32,
	height:     u32,
	// If this is non-zero, the preview owns the data, if 0, is a const ref. 
	alloc_size: uint,
	rgba:       [^]u8,
}

attr_rational_t :: struct #packed {
	num:   i32,
	denom: u32,
}

attr_string_t :: struct {
	length:     i32,
	// If this is non-zero, the string owns the data, if 0, is a const ref to a static string. 
	alloc_size: i32,
	str:        cstring,
}

attr_string_vector_t :: struct {
	n_strings:  i32,
	// If this is non-zero, the string vector owns the data, if 0, is a const ref. 
	alloc_size: i32,
	strings:    [^]attr_string_t,
}

attr_tiledesc_t :: struct #packed {
	x_size:          u32,
	y_size:          u32,
	level_and_round: u8,
}

attr_timecode_t :: struct #packed {
	time_and_flags: u32,
	user_data:      u32,
}

attr_v2d_t :: distinct [2]f64

attr_v2f_t :: distinct [2]f32

attr_v2i_t :: distinct [2]i32

attr_v3d_t :: distinct [3]f64

attr_v3f_t :: distinct [3]f32

attr_v3i_t :: distinct [3]i32

attribute_t :: struct {
	// Name of the attribute. 
	name:             cstring,
	// String type name of the attribute. 
	type_name:        cstring,
	// Length of name string (short flag is 31 max, long allows 255). 
	name_length:      u8,
	// Length of type string (short flag is 31 max, long allows 255). 
	type_name_length: u8,
	pad:              [2]u8,
	// Enum of the attribute type. 
	type:             attribute_type_t,
	// Union of pointers of different types that can be used to type
	// 	 * pun to an appropriate type for builtins. Do note that while
	// 	 * this looks like a big thing, it is only the size of a single
	// 	 * pointer.  These are all pointers into some other data block
	// 	 * storing the value you want, with the exception of the pod types
	// 	 * which are just put in place (i.e. small value optimization).
	// 	 *
	// 	 * The attribute type \c type should directly correlate to one
	// 	 * of these entries.
	using _:          struct #raw_union {
		// NB: not pointers for POD types
		uc:             u8,
		d:              f64,
		f:              f32,
		i:              i32,
		box2i:          ^attr_box2i_t,
		box2f:          ^attr_box2f_t,
		chlist:         ^attr_chlist_t,
		chromaticities: ^attr_chromaticities_t,
		keycode:        ^attr_keycode_t,
		floatvector:    ^attr_float_vector_t,
		m33f:           ^attr_m33f_t,
		m33d:           ^attr_m33d_t,
		m44f:           ^attr_m44f_t,
		m44d:           ^attr_m44d_t,
		preview:        ^attr_preview_t,
		rational:       ^attr_rational_t,
		string:         ^attr_string_t,
		stringvector:   ^attr_string_vector_t,
		tiledesc:       ^attr_tiledesc_t,
		timecode:       ^attr_timecode_t,
		v2i:            ^attr_v2i_t,
		v2f:            ^attr_v2f_t,
		v2d:            ^attr_v2d_t,
		v3i:            ^attr_v3i_t,
		v3f:            ^attr_v3f_t,
		v3d:            ^attr_v3d_t,
		opaque:         ^attr_opaquedata_t,
		rawptr:         ^u8,
	},
}

attribute_type_t :: enum i32 {
	UNKNOWN          = 0, // Type indicating an error or uninitialized attribute.
	BOX2I,                // Integer region definition. @see attr_box2i_t.
	BOX2F,                // Float region definition. @see attr_box2f_t.
	CHLIST,               // Definition of channels in file @see chlist_entry.
	CHROMATICITIES,       // Values to specify color space of colors in file @see attr_chromaticities_t.
	COMPRESSION,          // ``u8`` declaring compression present.
	DOUBLE,               // Double precision floating point number.
	ENVMAP,               // ``u8`` declaring environment map type.
	FLOAT,                // Normal (4 byte) precision floating point number.
	FLOAT_VECTOR,         // List of normal (4 byte) precision floating point numbers.
	INT,                  // 32-bit signed integer value.
	KEYCODE,              // Struct recording keycode @see attr_keycode_t.
	LINEORDER,            // ``u8`` declaring scanline ordering.
	M33F,                 // 9 32-bit floats representing a 3x3 matrix.
	M33D,                 // 9 64-bit floats representing a 3x3 matrix.
	M44F,                 // 16 32-bit floats representing a 4x4 matrix.
	M44D,                 // 16 64-bit floats representing a 4x4 matrix.
	PREVIEW,              // 2 ``unsigned ints`` followed by 4 x w x h ``u8`` image.
	RATIONAL,             // \c int followed by ``unsigned int``
	STRING,               // ``int`` (length) followed by char string data.
	STRING_VECTOR,        // 0 or more text strings (int + string). number is based on attribute size.
	TILEDESC,             // 2 ``unsigned ints`` ``xSize``, ``ySize`` followed by mode.
	TIMECODE,             // 2 ``unsigned ints`` time and flags, user data.
	V2I,                  // Pair of 32-bit integers.
	V2F,                  // Pair of 32-bit floats.
	V2D,                  // Pair of 64-bit floats.
	V3I,                  // Set of 3 32-bit integers.
	V3F,                  // Set of 3 32-bit floats.
	V3D,                  // Set of 3 64-bit floats.
	DEEP_IMAGE_STATE,     // ``uint8_t`` declaring deep image state.
	OPAQUE,               // User/unknown provided type.
}

chunk_info_t :: struct {
	idx:                      i32,
	// For tiles, this is the tilex; for scans it is the x. 
	start_x:                  i32,
	// For tiles, this is the tiley; for scans it is the scanline y. 
	start_y:                  i32,
	height:                   i32,
	// *< For this chunk. 
	width:                    i32,
	// *< For this chunk. 
	level_x:                  u8,
	// *< For tiled files. 
	level_y:                  u8,
	// *< For tiled files. 
	type:                     u8,
	compression:              u8,
	data_offset:              u64,
	packed_size:              u64,
	unpacked_size:            u64,
	sample_count_data_offset: u64,
	sample_count_table_size:  u64,
}

coding_channel_info_t :: struct {
	// Channel name.
	// 	 *
	// 	 * This is provided as a convenient reference. Do not free, this
	// 	 * refers to the internal data structure in the context.
	channel_name:           cstring,
	// Number of lines for this channel in this chunk.
	// 	 *
	// 	 * May be 0 or less than overall image height based on sampling
	// 	 * (i.e. when in 4:2:0 type sampling)
	height:                 i32,
	// Width in pixel count.
	// 	 *
	// 	 * May be 0 or less than overall image width based on sampling
	// 	 * (i.e. 4:2:2 will have some channels have fewer values).
	width:                  i32,
	// Horizontal subsampling information. 
	x_samples:              i32,
	// Vertical subsampling information. 
	y_samples:              i32,
	// Linear flag from channel definition (used by b44). 
	p_linear:               u8,
	// How many bytes per pixel this channel consumes (2 for float16,
	// 	 * 4 for float32/uint32).
	bytes_per_element:      i8,
	// Small form of exr_pixel_type_t enum (EXR_PIXEL_UINT/HALF/FLOAT). 
	data_type:              u16,
	// How many bytes per pixel the input is or output should be
	// 	 * (2 for float16, 4 for float32/uint32). Defaults to same
	// 	 * size as input.
	user_bytes_per_element: i16,
	// Small form of exr_pixel_type_t enum
	// 	 * (EXR_PIXEL_UINT/HALF/FLOAT). Defaults to same type as input.
	user_data_type:         u16,
	user_pixel_stride:      i32,
	// When \c lines > 1 for a chunk, this is the increment used to get
	// 	 * from beginning of line to beginning of next line.
	// 	 *
	// 	 * This is in bytes. Must be specified when the decode pointer is
	// 	 * specified (and always for encode).
	user_line_stride:       i32,
	// This data member has different requirements reading vs
	// 	 * writing. When reading, if this is left as `NULL`, the channel
	// 	 * will be skipped during read and not filled in.  During a write
	// 	 * operation, this pointer is considered const and not
	// 	 * modified. To make this more clear, a union is used here.
	using _:                struct #raw_union {
		decode_to_ptr:   ^u8,
		encode_from_ptr: ^u8,
	},
}

compression_t :: enum i32 {
	NONE  = 0, 
	RLE   = 1, 
	ZIPS  = 2, 
	ZIP   = 3, 
	PIZ   = 4, 
	PXR24 = 5, 
	B44   = 6, 
	B44A  = 7, 
	DWAA  = 8, 
	DWAB  = 9, 
}

const_context_t :: context_t

context_initializer_t :: struct {
	// Size member to tag initializer for version stability.
	// 	 *
	// 	 * This should be initialized to the size of the current
	// 	 * structure. This allows EXR to add functions or other
	// 	 * initializers in the future, and retain version compatibility
	size:             uint,
	// Error callback function pointer
	// 	 *
	// 	 * The error callback is allowed to be `NULL`, and will use a
	// 	 * default print which outputs to \c stderr.
	// 	 *
	// 	 * @sa exr_error_handler_cb_t
	error_handler_fn: error_handler_cb_t,
	// Custom allocator, if `NULL`, will use malloc. @sa memory_allocation_func_t 
	alloc_fn:         memory_allocation_func_t,
	// Custom deallocator, if `NULL`, will use free. @sa memory_free_func_t 
	free_fn:          memory_free_func_t,
	// Blind data passed to custom read, size, write, destroy
	// 	 * functions below. Up to user to manage this pointer.
	user_data:        rawptr,
	// Custom read routine.
	// 	 *
	// 	 * This is only used during read or update contexts. If this is
	// 	 * provided, it is expected that the caller has previously made
	// 	 * the stream available, and placed whatever stream/file data
	// 	 * into \c user_data above.
	// 	 *
	// 	 * If this is `NULL`, and the context requested is for reading an
	// 	 * exr file, an internal implementation is provided for reading
	// 	 * from normal filesystem files, and the filename provided is
	// 	 * attempted to be opened as such.
	// 	 *
	// 	 * Expected to be `NULL` for a write-only operation, but is ignored
	// 	 * if it is provided.
	// 	 *
	// 	 * For update contexts, both read and write functions must be
	// 	 * provided if either is.
	// 	 *
	// 	 * @sa exr_read_func_ptr_t
	read_fn:          read_func_ptr_t,
	// Custom size query routine.
	// 	 *
	// 	 * Used to provide validation when reading header values. If this
	// 	 * is not provided, but a custom read routine is provided, this
	// 	 * will disable some of the validation checks when parsing the
	// 	 * image header.
	// 	 *
	// 	 * Expected to be `NULL` for a write-only operation, but is ignored
	// 	 * if it is provided.
	// 	 *
	// 	 * @sa exr_query_size_func_ptr_t
	size_fn:          query_size_func_ptr_t,
	// Custom write routine.
	// 	 *
	// 	 * This is only used during write or update contexts. If this is
	// 	 * provided, it is expected that the caller has previously made
	// 	 * the stream available, and placed whatever stream/file data
	// 	 * into \c user_data above.
	// 	 *
	// 	 * If this is `NULL`, and the context requested is for writing an
	// 	 * exr file, an internal implementation is provided for reading
	// 	 * from normal filesystem files, and the filename provided is
	// 	 * attempted to be opened as such.
	// 	 *
	// 	 * For update contexts, both read and write functions must be
	// 	 * provided if either is.
	// 	 *
	// 	 * @sa exr_write_func_ptr_t
	write_fn:         write_func_ptr_t,
	// Optional function to destroy the user data block of a custom stream.
	// 	 *
	// 	 * Allows one to free any user allocated data, and close any handles.
	// 	 *
	// 	 * @sa exr_destroy_stream_func_ptr_t
	// 	 * 
	destroy_fn:       destroy_stream_func_ptr_t,
	// Initialize a field specifying what the maximum image width
	// 	 * allowed by the context is. See exr_set_default_maximum_image_size() to
	// 	 * understand how this interacts with global defaults.
	max_image_width:  i32,
	// Initialize a field specifying what the maximum image height
	// 	 * allowed by the context is. See exr_set_default_maximum_image_size() to
	// 	 * understand how this interacts with global defaults.
	max_image_height: i32,
	// Initialize a field specifying what the maximum tile width
	// 	 * allowed by the context is. See exr_set_default_maximum_tile_size() to
	// 	 * understand how this interacts with global defaults.
	max_tile_width:   i32,
	// Initialize a field specifying what the maximum tile height
	// 	 * allowed by the context is. See exr_set_default_maximum_tile_size() to
	// 	 * understand how this interacts with global defaults.
	max_tile_height:  i32,
	// Initialize a field specifying what the default zip compression level should be
	// 	 * for this context. See exr_set_default_zip_compresion_level() to
	// 	 * set it for all contexts.
	zip_level:        i32,
	// Initialize the default dwa compression quality. See
	// 	 * exr_set_default_dwa_compression_quality() to set the default
	// 	 * for all contexts.
	dwa_quality:      f32,
	// Initialize with a bitwise or of the various context flags
	flags:            i32,
	pad:              [4]u8,
}

context_t :: distinct rawptr

decode_pipeline_t :: struct {
	// Used for versioning the decode pipeline in the future.
	// 	 *
	// 	 * \ref EXR_DECODE_PIPELINE_INITIALIZER
	pipe_size:                      uint,
	// The output channel information for this chunk.
	// 	 *
	// 	 * User is expected to fill the channel pointers for the desired
	// 	 * output channels (any that are `NULL` will be skipped) if you are
	// 	 * going to use exr_decoding_choose_default_routines(). If all that is
	// 	 * desired is to read and decompress the data, this can be left
	// 	 * uninitialized.
	// 	 *
	// 	 * Describes the channel information. This information is
	// 	 * allocated dynamically during exr_decoding_initialize().
	channels:                       [^]coding_channel_info_t,
	channel_count:                  i16,
	// Decode flags to control the behavior. 
	decode_flags:                   u16,
	// Copy of the parameters given to the initialize/update for
	// 	 * convenience.
	part_index:                     i32,
	ctx:                            context_t,
	chunk:                          chunk_info_t,
	// How many lines of the chunk to skip filling, assumes the
	// 	 * pointer is at the beginning of data (i.e. includes this
	// 	 * skip so does not need to be adjusted
	user_line_begin_skip:           i32,
	// How many lines of the chunk to ignore at the end, assumes the
	// 	 * output is meant to be N lines smaller
	user_line_end_ignore:           i32,
	// How many bytes were actually decoded when items compressed 
	bytes_decompressed:             u64,
	// Can be used by the user to pass custom context data through
	// 	 * the decode pipeline.
	decoding_user_data:             rawptr,
	// The (compressed) buffer.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	packed_buffer:                  rawptr,
	// Used when re-using the same decode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough.
	packed_alloc_size:              uint,
	// The decompressed buffer (unpacked_size from the chunk block
	// 	 * info), but still packed into storage order, only needed for
	// 	 * compressed files.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	unpacked_buffer:                rawptr,
	// Used when re-using the same decode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough.
	unpacked_alloc_size:            uint,
	// For deep or other non-image data: packed sample table
	// 	 * (compressed, raw on disk representation).
	packed_sample_count_table:      rawptr,
	packed_sample_count_alloc_size: uint,
	// Usable, native sample count table. Depending on the flag set
	// 	 * above, will be decoded to either a cumulative list (n, n+m,
	// 	 * n+m+o, ...), or an individual table (n, m, o, ...). As an
	// 	 * optimization, if the latter individual count table is chosen,
	// 	 * an extra int32_t will be allocated at the end of the table to
	// 	 * contain the total count of samples, so the table will be n+1
	// 	 * samples in size.
	sample_count_table:             [^]i32,
	sample_count_alloc_size:        uint,
	// A scratch buffer of unpacked_size for intermediate results.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	scratch_buffer_1:               rawptr,
	// Used when re-using the same decode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough.
	scratch_alloc_size_1:           uint,
	// Some decompression routines may need a second scratch buffer (zlib).
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	scratch_buffer_2:               rawptr,
	// Used when re-using the same decode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough.
	scratch_alloc_size_2:           uint,
	// Enable a custom allocator for the different buffers (if
	// 	 * decoding on a GPU). If `NULL`, will use the allocator from the
	// 	 * context.
	alloc_fn:                       proc "c" (transcoding_pipeline_buffer_id_t, uint) -> rawptr,
	// Enable a custom allocator for the different buffers (if
	// 	 * decoding on a GPU). If `NULL`, will use the allocator from the
	// 	 * context.
	free_fn:                        proc "c" (transcoding_pipeline_buffer_id_t, rawptr),
	// Function chosen to read chunk data from the context.
	// 	 *
	// 	 * Initialized to a default generic read routine, may be updated
	// 	 * based on channel information when
	// 	 * exr_decoding_choose_default_routines() is called. This is done such that
	// 	 * if the file is uncompressed and the output channel data is
	// 	 * planar and the same type, the read function can read straight
	// 	 * into the output channels, getting closer to a zero-copy
	// 	 * operation. Otherwise a more traditional read, decompress, then
	// 	 * unpack pipeline will be used with a default reader.
	// 	 *
	// 	 * This is allowed to be overridden, but probably is not necessary
	// 	 * in most scenarios.
	read_fn:                        proc "c" (pipeline: ^decode_pipeline_t) -> result_t,
	// Function chosen based on the compression type of the part to
	// 	 * decompress data.
	// 	 *
	// 	 * If the user has a custom decompression method for the
	// 	 * compression on this part, this can be changed after
	// 	 * initialization.
	// 	 *
	// 	 * If only compressed data is desired, then assign this to `NULL`
	// 	 * after initialization.
	decompress_fn:                  proc "c" (pipeline: ^decode_pipeline_t) -> result_t,
	// Function which can be provided if you have bespoke handling for
	// 	 * non-image data and need to re-allocate the data to handle the
	// 	 * about-to-be unpacked data.
	// 	 *
	// 	 * If left `NULL`, will assume the memory pointed to by the channel
	// 	 * pointers is sufficient.
	realloc_nonimage_data_fn:       proc "c" (pipeline: ^decode_pipeline_t) -> result_t,
	// Function chosen based on the output layout of the channels of the part to
	// 	 * decompress data.
	// 	 *
	// 	 * This will be `NULL` after initialization, until the user
	// 	 * specifies a custom routine, or initializes the channel data and
	// 	 * calls exr_decoding_choose_default_routines().
	// 	 *
	// 	 * If only compressed data is desired, then leave or assign this
	// 	 * to `NULL` after initialization.
	unpack_and_convert_fn:          proc "c" (pipeline: ^decode_pipeline_t) -> result_t,
	// Small stash of channel info values. This is faster than calling
	// 	 * malloc when the channel count in the part is small (RGBAZ),
	// 	 * which is super common, however if there are a large number of
	// 	 * channels, it will allocate space for that, so do not rely on
	// 	 * this being used.
	_quick_chan_store:              [5]coding_channel_info_t,
}

deep_image_state_t :: enum i32 {
	MESSY           = 0, 
	SORTED          = 1, 
	NON_OVERLAPPING = 2, 
	TIDY            = 3, 
}

default_write_mode_t :: enum i32 {
	WRITE_FILE_DIRECTLY    = 0, // *< Overwrite filename provided directly, deleted upon error.
	INTERMEDIATE_TEMP_FILE = 1, // *< Create a temporary file, renaming it upon successful write, leaving original upon error
}

destroy_stream_func_ptr_t :: proc "c" (ctxt: context_t, userdata: rawptr, failed: i32)

encode_pipeline_t :: struct {
	// Used for versioning the decode pipeline in the future
	// 	 *
	// 	 * \ref EXR_ENCODE_PIPELINE_INITIALIZER
	pipe_size:                      uint,
	// The output channel information for this chunk.
	// 	 *
	// 	 * User is expected to fill the channel pointers for the input
	// 	 * channels. For writing, all channels must be initialized prior
	// 	 * to using exr_encoding_choose_default_routines(). If a custom pack routine
	// 	 * is written, that is up to the implementor.
	// 	 *
	// 	 * Describes the channel information. This information is
	// 	 * allocated dynamically during exr_encoding_initialize().
	channels:                       [^]coding_channel_info_t,
	channel_count:                  i16,
	// Encode flags to control the behavior. 
	encode_flags:                   u16,
	// Copy of the parameters given to the initialize/update for convenience. 
	part_index:                     i32,
	ctx:                            context_t,
	chunk:                          chunk_info_t,
	// Can be used by the user to pass custom context data through
	// 	 * the encode pipeline.
	encoding_user_data:             rawptr,
	// The packed buffer where individual channels have been put into here.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	packed_buffer:                  rawptr,
	// Differing from the allocation size, the number of actual bytes 
	packed_bytes:                   u64,
	// Used when re-using the same encode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	packed_alloc_size:              uint,
	// For deep data. NB: the members NOT const because we need to
	// 	 * temporarily swap it to xdr order and restore it (to avoid a
	// 	 * duplicate buffer allocation).
	// 	 *
	// 	 * Depending on the flag set above, will be treated either as a
	// 	 * cumulative list (n, n+m, n+m+o, ...), or an individual table
	// 	 * (n, m, o, ...). 
	sample_count_table:             [^]i32,
	// Allocated table size (to avoid re-allocations). Number of
	// 	 * samples must always be width * height for the chunk.
	sample_count_alloc_size:        uint,
	// Packed sample table (compressed, raw on disk representation)
	// 	 * for deep or other non-image data.
	packed_sample_count_table:      rawptr,
	// Number of bytes to write (actual size) for the
	// 	 * packed_sample_count_table.
	packed_sample_count_bytes:      uint,
	// Allocated size (to avoid re-allocations) for the
	// 	 * packed_sample_count_table.
	packed_sample_count_alloc_size: uint,
	// The compressed buffer, only needed for compressed files.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	compressed_buffer:              rawptr,
	// Must be filled in as the pipeline runs to inform the writing
	// 	 * software about the compressed size of the chunk (if it is an
	// 	 * uncompressed file or the compression would make the file
	// 	 * larger, it is expected to be the packed_buffer)
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to zero here. Be cognizant of any
	// 	 * custom allocators.
	compressed_bytes:               uint,
	// Used when re-using the same encode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to zero here. Be cognizant of any
	// 	 * custom allocators.
	compressed_alloc_size:          uint,
	// A scratch buffer for intermediate results.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	scratch_buffer_1:               rawptr,
	// Used when re-using the same encode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	scratch_alloc_size_1:           uint,
	// Some compression routines may need a second scratch buffer.
	// 	 *
	// 	 * If `NULL`, will be allocated during the run of the pipeline when
	// 	 * needed.
	// 	 *
	// 	 * If the caller wishes to take control of the buffer, simple
	// 	 * adopt the pointer and set it to `NULL` here. Be cognizant of any
	// 	 * custom allocators.
	scratch_buffer_2:               rawptr,
	// Used when re-using the same encode pipeline struct to know if
	// 	 * chunk is changed size whether current buffer is large enough.
	scratch_alloc_size_2:           uint,
	// Enable a custom allocator for the different buffers (if
	// 	 * encoding on a GPU). If `NULL`, will use the allocator from the
	// 	 * context.
	alloc_fn:                       proc "c" (transcoding_pipeline_buffer_id_t, uint) -> rawptr,
	// Enable a custom allocator for the different buffers (if
	// 	 * encoding on a GPU). If `NULL`, will use the allocator from the
	// 	 * context.
	free_fn:                        proc "c" (transcoding_pipeline_buffer_id_t, rawptr),
	// Function chosen based on the output layout of the channels of the part to
	// 	 * decompress data.
	// 	 *
	// 	 * If the user has a custom method for the
	// 	 * compression on this part, this can be changed after
	// 	 * initialization.
	convert_and_pack_fn:            proc "c" (pipeline: ^encode_pipeline_t) -> result_t,
	// Function chosen based on the compression type of the part to
	// 	 * compress data.
	// 	 *
	// 	 * If the user has a custom compression method for the compression
	// 	 * type on this part, this can be changed after initialization.
	compress_fn:                    proc "c" (pipeline: ^encode_pipeline_t) -> result_t,
	// This routine is used when waiting for other threads to finish
	// 	 * writing previous chunks such that this thread can write this
	// 	 * chunk. This is used for parts which have a specified chunk
	// 	 * ordering (increasing/decreasing y) and the chunks can not be
	// 	 * written randomly (as could be true for uncompressed).
	// 	 *
	// 	 * This enables the calling application to contribute thread time
	// 	 * to other computation as needed, or just use something like
	// 	 * pthread_yield().
	// 	 *
	// 	 * By default, this routine will be assigned to a function which
	// 	 * returns an error, failing the encode immediately. In this way,
	// 	 * it assumes that there is only one thread being used for
	// 	 * writing.
	// 	 *
	// 	 * It is up to the user to provide an appropriate routine if
	// 	 * performing multi-threaded writing.
	yield_until_ready_fn:           proc "c" (pipeline: ^encode_pipeline_t) -> result_t,
	// Function chosen to write chunk data to the context.
	// 	 *
	// 	 * This is allowed to be overridden, but probably is not necessary
	// 	 * in most scenarios.
	write_fn:                       proc "c" (pipeline: ^encode_pipeline_t) -> result_t,
	// Small stash of channel info values. This is faster than calling
	// 	 * malloc when the channel count in the part is small (RGBAZ),
	// 	 * which is super common, however if there are a large number of
	// 	 * channels, it will allocate space for that, so do not rely on
	// 	 * this being used.
	_quick_chan_store:              [5]coding_channel_info_t,
}

envmap_t :: enum i32 {
	LATLONG = 0, 
	CUBE    = 1, 
}

error_code_t :: result_t

error_handler_cb_t :: proc "c" (ctxt: context_t, code: result_t, msg: cstring)

lineorder_t :: enum i32 {
	INCREASING_Y = 0, 
	DECREASING_Y = 1, 
	RANDOM_Y     = 2, 
}

memory_allocation_func_t :: proc "c" (bytes: uint) -> rawptr

memory_free_func_t :: proc "c" (ptr: rawptr)

perceptual_treatment_t :: enum i32 {
	LOGARITHMIC = 0, 
	LINEAR      = 1, 
}

pixel_type_t :: enum i32 {
	UINT  = 0, 
	HALF  = 1, 
	FLOAT = 2, 
}

query_size_func_ptr_t :: proc "c" (ctxt: context_t, userdata: rawptr) -> i64

read_func_ptr_t :: proc "c" (ctxt: context_t, userdata: rawptr, buffer: rawptr, sz: u64, offset: u64, error_cb: stream_error_func_ptr_t) -> i64

result_t :: enum i32 {
	SUCCESS                 = 0, 
	OUT_OF_MEMORY, 
	MISSING_CONTEXT_ARG, 
	INVALID_ARGUMENT, 
	ARGUMENT_OUT_OF_RANGE, 
	FILE_ACCESS, 
	FILE_BAD_HEADER, 
	NOT_OPEN_READ, 
	NOT_OPEN_WRITE, 
	HEADER_NOT_WRITTEN, 
	READ_IO, 
	WRITE_IO, 
	NAME_TOO_LONG, 
	MISSING_REQ_ATTR, 
	INVALID_ATTR, 
	NO_ATTR_BY_NAME, 
	ATTR_TYPE_MISMATCH, 
	ATTR_SIZE_MISMATCH, 
	SCAN_TILE_MIXEDAPI, 
	TILE_SCAN_MIXEDAPI, 
	MODIFY_SIZE_CHANGE, 
	ALREADY_WROTE_ATTRS, 
	BAD_CHUNK_LEADER, 
	CORRUPT_CHUNK, 
	INCOMPLETE_CHUNK_TABLE, 
	INCORRECT_PART, 
	INCORRECT_CHUNK, 
	USE_SCAN_DEEP_WRITE, 
	USE_TILE_DEEP_WRITE, 
	USE_SCAN_NONDEEP_WRITE, 
	USE_TILE_NONDEEP_WRITE, 
	INVALID_SAMPLE_DATA, 
	FEATURE_NOT_IMPLEMENTED, 
	UNKNOWN, 
}

storage_t :: enum i32 {
	SCANLINE      = 0, // Corresponds to type of \c scanlineimage.
	TILED,             // Corresponds to type of \c tiledimage.
	DEEP_SCANLINE,     // Corresponds to type of \c deepscanline.
	DEEP_TILED,        // Corresponds to type of \c deeptile.
}

stream_error_func_ptr_t :: proc "c" (ctxt: context_t, code: result_t, fmt: cstring, args: ..any) -> result_t

tile_level_mode_t :: enum i32 {
	ONE_LEVEL     = 0, // Single level of image data.
	MIPMAP_LEVELS = 1, // Mipmapped image data.
	RIPMAP_LEVELS = 2, // Ripmapped image data.
}

tile_round_mode_t :: enum i32 {
	DOWN = 0, 
	UP   = 1, 
}

transcoding_pipeline_buffer_id_t :: enum i32 {
	PACKED, 
	UNPACKED, 
	COMPRESSED, 
	SCRATCH1, 
	SCRATCH2, 
	PACKED_SAMPLES, 
	SAMPLES, 
}

write_func_ptr_t :: proc "c" (ctxt: context_t, userdata: rawptr, buffer: rawptr, sz: u64, offset: u64, error_cb: stream_error_func_ptr_t) -> i64

CONTEXT_FLAG_DISABLE_CHUNK_RECONSTRUCTION :: 1 << 2

CONTEXT_FLAG_SILENT_HEADER_PARSE :: 1 << 1

CONTEXT_FLAG_STRICT_HEADER :: 1 << 0

DECODE_NON_IMAGE_DATA_AS_POINTERS :: u16(1 << 1)

DECODE_PIPELINE_INITIALIZER :: decode_pipeline_t{pipe_size = size_of(decode_pipeline_t)}

DECODE_SAMPLE_COUNTS_AS_INDIVIDUAL :: u16(1 << 0)

DECODE_SAMPLE_DATA_ONLY :: u16(1 << 2)

DEFAULT_CONTEXT_INITIALIZER :: context_initializer_t{zip_level = -2, dwa_quality = -1}

ENCODE_DATA_SAMPLE_COUNTS_ARE_INDIVIDUAL :: u16(1 << 0)

ENCODE_NON_IMAGE_DATA_AS_POINTERS :: u16(1 << 1)

ENCODE_PIPELINE_INITIALIZER :: encode_pipeline_t{pipe_size = size_of(encode_pipeline_t)}

OPENEXRCORE_SHARED :: #config(OPENEXRCORE_SHARED, false)

-define:OPENEXRCORE_SHARED=false

GET_TILE_LEVEL_MODE :: proc "c" (tiledesc: attr_tiledesc_t) -> tile_level_mode_t {…}

GET_TILE_ROUND_MODE :: proc "c" (tiledesc: attr_tiledesc_t) -> tile_round_mode_t {…}

PACK_TILE_LEVEL_ROUND :: proc "c" (lvl: tile_level_mode_t, mode: tile_round_mode_t) -> u8 {…}

add_channel :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	ptype:      pixel_type_t, 
	percept:    perceptual_treatment_t, 
	xsamp:      i32, 
	ysamp:      i32, 
) -> result_t ---

add_part :: proc "c" (
	ctxt:      context_t, 
	partname:  cstring, 
	type:      storage_t, 
	new_index: ^i32, 
) -> result_t ---

attr_declare :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	type:       attribute_type_t, 
	newattr:    ^^attribute_t, 
) -> result_t ---

attr_declare_by_type :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	type:       cstring, 
	newattr:    ^^attribute_t, 
) -> result_t ---

attr_get_box2f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	outval:     ^attr_box2f_t, 
) -> result_t ---

attr_get_box2i :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	outval:     ^attr_box2i_t, 
) -> result_t ---

attr_get_channels :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	chlist:     ^^attr_chlist_t, 
) -> result_t ---

attr_get_chromaticities :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	chroma:     ^attr_chromaticities_t, 
) -> result_t ---

attr_get_compression :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^compression_t, 
) -> result_t ---

attr_get_double :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^f64, 
) -> result_t ---

attr_get_envmap :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^envmap_t, 
) -> result_t ---

attr_get_float :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^f32, 
) -> result_t ---

attr_get_float_vector :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	sz:         ^i32, 
	out:        ^[^]f32, 
) -> result_t ---

attr_get_int :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^i32, 
) -> result_t ---

attr_get_keycode :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_keycode_t, 
) -> result_t ---

attr_get_lineorder :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^lineorder_t, 
) -> result_t ---

attr_get_m33d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_m33d_t, 
) -> result_t ---

attr_get_m33f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_m33f_t, 
) -> result_t ---

attr_get_m44d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_m44d_t, 
) -> result_t ---

attr_get_m44f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_m44f_t, 
) -> result_t ---

attr_get_preview :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_preview_t, 
) -> result_t ---

attr_get_rational :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_rational_t, 
) -> result_t ---

attr_get_string :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	length:     ^i32, 
	out:        ^cstring, 
) -> result_t ---

attr_get_string_vector :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	size:       ^i32, 
	out:        [^]cstring, 
) -> result_t ---

attr_get_tiledesc :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_tiledesc_t, 
) -> result_t ---

attr_get_timecode :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_timecode_t, 
) -> result_t ---

attr_get_user :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	type:       ^cstring, 
	size:       ^i32, 
	out:        ^rawptr, 
) -> result_t ---

attr_get_v2d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_v2d_t, 
) -> result_t ---

attr_get_v2f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_v2f_t, 
) -> result_t ---

attr_get_v2i :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_v2i_t, 
) -> result_t ---

attr_get_v3d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_v3d_t, 
) -> result_t ---

attr_get_v3f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_v3f_t, 
) -> result_t ---

attr_get_v3i :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	out:        ^attr_v3i_t, 
) -> result_t ---

attr_set_box2f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	val:        ^attr_box2f_t, 
) -> result_t ---

attr_set_box2i :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	val:        ^attr_box2i_t, 
) -> result_t ---

attr_set_channels :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	channels:   ^attr_chlist_t, 
) -> result_t ---

attr_set_chromaticities :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	chroma:     ^attr_chromaticities_t, 
) -> result_t ---

attr_set_compression :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	comp:       compression_t, 
) -> result_t ---

attr_set_double :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	val:        f64, 
) -> result_t ---

attr_set_envmap :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	emap:       envmap_t, 
) -> result_t ---

attr_set_float :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	val:        f32, 
) -> result_t ---

attr_set_float_vector :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	sz:         i32, 
	vals:       [^]f32, 
) -> result_t ---

attr_set_int :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	val:        i32, 
) -> result_t ---

attr_set_keycode :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	kc:         ^attr_keycode_t, 
) -> result_t ---

attr_set_lineorder :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	lo:         lineorder_t, 
) -> result_t ---

attr_set_m33d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	m:          ^attr_m33d_t, 
) -> result_t ---

attr_set_m33f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	m:          ^attr_m33f_t, 
) -> result_t ---

attr_set_m44d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	m:          ^attr_m44d_t, 
) -> result_t ---

attr_set_m44f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	m:          ^attr_m44f_t, 
) -> result_t ---

attr_set_preview :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	p:          ^attr_preview_t, 
) -> result_t ---

attr_set_rational :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	r:          ^attr_rational_t, 
) -> result_t ---

attr_set_string :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	s:          cstring, 
) -> result_t ---

attr_set_string_vector :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	size:       i32, 
	sv:         [^]cstring, 
) -> result_t ---

attr_set_tiledesc :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	td:         ^attr_tiledesc_t, 
) -> result_t ---

attr_set_timecode :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	tc:         ^attr_timecode_t, 
) -> result_t ---

attr_set_user :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	type:       cstring, 
	size:       i32, 
	out:        rawptr, 
) -> result_t ---

attr_set_v2d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	v:          ^attr_v2d_t, 
) -> result_t ---

attr_set_v2f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	v:          ^attr_v2f_t, 
) -> result_t ---

attr_set_v2i :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	v:          ^attr_v2i_t, 
) -> result_t ---

attr_set_v3d :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	v:          ^attr_v3d_t, 
) -> result_t ---

attr_set_v3f :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	v:          ^attr_v3f_t, 
) -> result_t ---

attr_set_v3i :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	v:          ^attr_v3i_t, 
) -> result_t ---

chunk_default_initialize :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	box:        ^attr_box2i_t, 
	levelx:     i32, 
	levely:     i32, 
	cinfo:      ^chunk_info_t, 
) -> result_t ---

compress_buffer :: proc "c" (
	ctxt:            context_t, 
	level:           i32, 
	in_:             rawptr, 
	in_bytes:        uint, 
	out:             rawptr, 
	out_bytes_avail: uint, 
	actual_out:      ^uint, 
) -> result_t ---

compress_chunk :: proc "c" (encode_state: ^encode_pipeline_t) -> result_t ---

compress_max_buffer_size :: proc "c" (in_bytes: uint) -> uint ---

compression_lines_per_chunk :: proc "c" (comptype: compression_t) -> i32 ---

copy_unset_attributes :: proc "c" (
	ctxt:           context_t, 
	part_index:     i32, 
	source:         context_t, 
	src_part_index: i32, 
) -> result_t ---

decoding_choose_default_routines :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	decode:     ^decode_pipeline_t, 
) -> result_t ---

decoding_destroy :: proc "c" (ctxt: context_t, decode: ^decode_pipeline_t) -> result_t ---

decoding_initialize :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	cinfo:      ^chunk_info_t, 
	decode:     ^decode_pipeline_t, 
) -> result_t ---

decoding_run :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	decode:     ^decode_pipeline_t, 
) -> result_t ---

decoding_update :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	cinfo:      ^chunk_info_t, 
	decode:     ^decode_pipeline_t, 
) -> result_t ---

encoding_choose_default_routines :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	encode_pipe: ^encode_pipeline_t, 
) -> result_t ---

encoding_destroy :: proc "c" (ctxt: context_t, encode_pipe: ^encode_pipeline_t) -> result_t ---

encoding_initialize :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	cinfo:       ^chunk_info_t, 
	encode_pipe: ^encode_pipeline_t, 
) -> result_t ---

encoding_run :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	encode_pipe: ^encode_pipeline_t, 
) -> result_t ---

encoding_update :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	cinfo:       ^chunk_info_t, 
	encode_pipe: ^encode_pipeline_t, 
) -> result_t ---

finish :: proc "c" (ctxt: ^context_t) -> result_t ---

get_attribute_by_index :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	mode:       attr_list_access_mode_t, 
	idx:        i32, 
	outattr:    ^^attribute_t, 
) -> result_t ---

get_attribute_by_name :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	name:       cstring, 
	outattr:    ^^attribute_t, 
) -> result_t ---

get_attribute_count :: proc "c" (ctxt: context_t, part_index: i32, count: ^i32) -> result_t ---

get_attribute_list :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	mode:       attr_list_access_mode_t, 
	count:      ^i32, 
	outlist:    [^]^attribute_t, 
) -> result_t ---

get_channels :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	chlist:     ^^attr_chlist_t, 
) -> result_t ---

get_chunk_count :: proc "c" (ctxt: context_t, part_index: i32, out: ^i32) -> result_t ---

get_chunk_table :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	table:      ^[^]u64, 
	count:      ^i32, 
) -> result_t ---

get_chunk_table_offset :: proc "c" (
	ctxt:             context_t, 
	part_index:       i32, 
	chunk_offset_out: ^u64, 
) -> result_t ---

get_chunk_unpacked_size :: proc "c" (ctxt: context_t, part_index: i32, out: ^u64) -> result_t ---

get_compression :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	compression: ^compression_t, 
) -> result_t ---

get_count :: proc "c" (ctxt: context_t, count: ^i32) -> result_t ---

get_data_window :: proc "c" (ctxt: context_t, part_index: i32, out: ^attr_box2i_t) -> result_t ---

get_default_dwa_compression_quality :: proc "c" (q: ^f32) ---

get_default_error_message :: proc "c" (code: result_t) -> cstring ---

get_default_maximum_image_size :: proc "c" (w, h: ^i32) ---

get_default_maximum_tile_size :: proc "c" (w, h: ^i32) ---

get_default_zip_compression_level :: proc "c" (l: ^i32) ---

get_display_window :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	out:        ^attr_box2i_t, 
) -> result_t ---

get_dwa_compression_level :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	level:      ^f32, 
) -> result_t ---

get_error_code_as_string :: proc "c" (code: result_t) -> cstring ---

get_file_name :: proc "c" (ctxt: context_t, name: ^cstring) -> result_t ---

get_file_version_and_flags :: proc "c" (ctxt: context_t, ver: ^u32) -> result_t ---

get_level_sizes :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	levelx:     i32, 
	levely:     i32, 
	levw:       ^i32, 
	levh:       ^i32, 
) -> result_t ---

get_library_version :: proc "c" (maj, min, patch: ^i32, extra: ^cstring) ---

get_lineorder :: proc "c" (ctxt: context_t, part_index: i32, out: ^lineorder_t) -> result_t ---

get_name :: proc "c" (ctxt: context_t, part_index: i32, out: ^cstring) -> result_t ---

get_pixel_aspect_ratio :: proc "c" (ctxt: context_t, part_index: i32, par: ^f32) -> result_t ---

get_scanlines_per_chunk :: proc "c" (ctxt: context_t, part_index: i32, out: ^i32) -> result_t ---

get_screen_window_center :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	wc:         ^attr_v2f_t, 
) -> result_t ---

get_screen_window_width :: proc "c" (ctxt: context_t, part_index: i32, out: ^f32) -> result_t ---

get_storage :: proc "c" (ctxt: context_t, part_index: i32, out: ^storage_t) -> result_t ---

get_tile_counts :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	levelx:     i32, 
	levely:     i32, 
	countx:     ^i32, 
	county:     ^i32, 
) -> result_t ---

get_tile_descriptor :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	xsize:      ^u32, 
	ysize:      ^u32, 
	level:      ^tile_level_mode_t, 
	round:      ^tile_round_mode_t, 
) -> result_t ---

get_tile_levels :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	levelsx:    ^i32, 
	levelsy:    ^i32, 
) -> result_t ---

get_tile_sizes :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	levelx:     i32, 
	levely:     i32, 
	tilew:      ^i32, 
	tileh:      ^i32, 
) -> result_t ---

get_user_data :: proc "c" (ctxt: context_t, userdata: ^rawptr) -> result_t ---

get_version :: proc "c" (ctxt: context_t, part_index: i32, out: ^i32) -> result_t ---

get_zip_compression_level :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	level:      ^i32, 
) -> result_t ---

initialize_required_attr :: proc "c" (
	ctxt:               context_t, 
	part_index:         i32, 
	displayWindow:      ^attr_box2i_t, 
	dataWindow:         ^attr_box2i_t, 
	pixelaspectratio:   f32, 
	screenWindowCenter: ^attr_v2f_t, 
	screenWindowWidth:  f32, 
	lineorder:          lineorder_t, 
	ctype:              compression_t, 
) -> result_t ---

initialize_required_attr_simple :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	width:      i32, 
	height:     i32, 
	ctype:      compression_t, 
) -> result_t ---

print_context_info :: proc "c" (c: context_t, verbose: b32) -> result_t ---

read_chunk :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	cinfo:       ^chunk_info_t, 
	packed_data: rawptr, 
) -> result_t ---

read_deep_chunk :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	cinfo:       ^chunk_info_t, 
	packed_data: rawptr, 
	sample_data: rawptr, 
) -> result_t ---

read_scanline_chunk_info :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	y:          i32, 
	cinfo:      ^chunk_info_t, 
) -> result_t ---

read_tile_chunk_info :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	tilex:      i32, 
	tiley:      i32, 
	levelx:     i32, 
	levely:     i32, 
	cinfo:      ^chunk_info_t, 
) -> result_t ---

register_attr_type_handler :: proc "c" (
	ctxt:                      context_t, 
	type:                      cstring, 
	unpack_func_ptr:           proc "c" (ctxt: context_t, data: rawptr, attrsize: i32, outsize: ^i32, outbuffer: ^rawptr) -> result_t, 
	pack_func_ptr:             proc "c" (ctxt: context_t, data: rawptr, datasize: i32, outsize: ^i32, outbuffer: rawptr) -> result_t, 
	destroy_unpacked_func_ptr: proc "c" (ctxt: context_t, data: rawptr, datasize: i32), 
) -> result_t ---

rle_compress_buffer :: proc "c" (
	in_bytes:        uint, 
	in_:             rawptr, 
	out:             rawptr, 
	out_bytes_avail: uint, 
) -> uint ---

rle_uncompress_buffer :: proc "c" (
	in_bytes: uint, 
	max_len:  uint, 
	in_:      rawptr, 
	out:      rawptr, 
) -> uint ---

set_channels :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	channels:   ^attr_chlist_t, 
) -> result_t ---

set_chunk_count :: proc "c" (ctxt: context_t, part_index: i32, val: i32) -> result_t ---

set_compression :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	ctype:      compression_t, 
) -> result_t ---

set_data_window :: proc "c" (ctxt: context_t, part_index: i32, dw: ^attr_box2i_t) -> i32 ---

set_default_dwa_compression_quality :: proc "c" (q: f32) ---

set_default_maximum_image_size :: proc "c" (w, h: i32) ---

set_default_maximum_tile_size :: proc "c" (w, h: i32) ---

set_default_memory_routines :: proc "c" (
	alloc_func: memory_allocation_func_t, 
	free_func:  memory_free_func_t, 
) ---

set_default_zip_compression_level :: proc "c" (l: i32) ---

set_display_window :: proc "c" (ctxt: context_t, part_index: i32, dw: ^attr_box2i_t) -> i32 ---

set_dwa_compression_level :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	level:      f32, 
) -> result_t ---

set_lineorder :: proc "c" (ctxt: context_t, part_index: i32, lo: lineorder_t) -> result_t ---

set_longname_support :: proc "c" (ctxt: context_t, onoff: b32) -> result_t ---

set_name :: proc "c" (ctxt: context_t, part_index: i32, val: cstring) -> result_t ---

set_pixel_aspect_ratio :: proc "c" (ctxt: context_t, part_index: i32, par: f32) -> result_t ---

set_screen_window_center :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	wc:         ^attr_v2f_t, 
) -> i32 ---

set_screen_window_width :: proc "c" (ctxt: context_t, part_index: i32, ssw: f32) -> result_t ---

set_tile_descriptor :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	x_size:     u32, 
	y_size:     u32, 
	level_mode: tile_level_mode_t, 
	round_mode: tile_round_mode_t, 
) -> result_t ---

set_version :: proc "c" (ctxt: context_t, part_index: i32, val: i32) -> result_t ---

set_zip_compression_level :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	level:      i32, 
) -> result_t ---

start_inplace_header_update :: proc "c" (
	ctxt:     ^context_t, 
	filename: cstring, 
	ctxtdata: ^context_initializer_t, 
) -> result_t ---

start_read :: proc "c" (
	ctxt:     ^context_t, 
	filename: cstring, 
	ctxtdata: ^context_initializer_t, 
) -> result_t ---

start_temporary_context :: proc "c" (
	ctxt:         ^context_t, 
	context_name: cstring, 
	ctxtdata:     ^context_initializer_t, 
) -> result_t ---

start_write :: proc "c" (
	ctxt:         ^context_t, 
	filename:     cstring, 
	default_mode: default_write_mode_t, 
	ctxtdata:     ^context_initializer_t, 
) -> result_t ---

test_file_header :: proc "c" (filename: cstring, ctxtdata: ^context_initializer_t) -> result_t ---

uncompress_buffer :: proc "c" (
	ctxt:            context_t, 
	in_:             rawptr, 
	in_bytes:        uint, 
	out:             rawptr, 
	out_bytes_avail: uint, 
	actual_out:      ^uint, 
) -> result_t ---

uncompress_chunk :: proc "c" (decode_state: ^decode_pipeline_t) -> result_t ---

validate_chunk_table :: proc "c" (ctxt: context_t, part_index: i32) -> result_t ---

write_deep_scanline_chunk :: proc "c" (
	ctxt:             context_t, 
	part_index:       i32, 
	y:                i32, 
	packed_data:      rawptr, 
	packed_size:      u64, 
	unpacked_size:    u64, 
	sample_data:      rawptr, 
	sample_data_size: u64, 
) -> result_t ---

write_deep_tile_chunk :: proc "c" (
	ctxt:             context_t, 
	part_index:       i32, 
	tilex:            i32, 
	tiley:            i32, 
	levelx:           i32, 
	levely:           i32, 
	packed_data:      rawptr, 
	packed_size:      u64, 
	unpacked_size:    u64, 
	sample_data:      rawptr, 
	sample_data_size: u64, 
) -> result_t ---

write_header :: proc "c" (ctxt: context_t) -> result_t ---

write_scanline_chunk :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	y:           i32, 
	packed_data: rawptr, 
	packed_size: u64, 
) -> result_t ---

write_scanline_chunk_info :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	y:          i32, 
	cinfo:      ^chunk_info_t, 
) -> result_t ---

write_tile_chunk :: proc "c" (
	ctxt:        context_t, 
	part_index:  i32, 
	tilex:       i32, 
	tiley:       i32, 
	levelx:      i32, 
	levely:      i32, 
	packed_data: rawptr, 
	packed_size: u64, 
) -> result_t ---

write_tile_chunk_info :: proc "c" (
	ctxt:       context_t, 
	part_index: i32, 
	tilex:      i32, 
	tiley:      i32, 
	levelx:     i32, 
	levely:     i32, 
	cinfo:      ^chunk_info_t, 
) -> result_t ---