pub const SPNG_VERSION_MAJOR: u32 = 0;
pub const SPNG_VERSION_MINOR: u32 = 7;
pub const SPNG_VERSION_PATCH: u32 = 0;
pub type FILE = u64;
pub const spng_errno_SPNG_IO_ERROR: spng_errno = -2;
pub const spng_errno_SPNG_IO_EOF: spng_errno = -1;
pub const spng_errno_SPNG_OK: spng_errno = 0;
pub const spng_errno_SPNG_EINVAL: spng_errno = 1;
pub const spng_errno_SPNG_EMEM: spng_errno = 2;
pub const spng_errno_SPNG_EOVERFLOW: spng_errno = 3;
pub const spng_errno_SPNG_ESIGNATURE: spng_errno = 4;
pub const spng_errno_SPNG_EWIDTH: spng_errno = 5;
pub const spng_errno_SPNG_EHEIGHT: spng_errno = 6;
pub const spng_errno_SPNG_EUSER_WIDTH: spng_errno = 7;
pub const spng_errno_SPNG_EUSER_HEIGHT: spng_errno = 8;
pub const spng_errno_SPNG_EBIT_DEPTH: spng_errno = 9;
pub const spng_errno_SPNG_ECOLOR_TYPE: spng_errno = 10;
pub const spng_errno_SPNG_ECOMPRESSION_METHOD: spng_errno = 11;
pub const spng_errno_SPNG_EFILTER_METHOD: spng_errno = 12;
pub const spng_errno_SPNG_EINTERLACE_METHOD: spng_errno = 13;
pub const spng_errno_SPNG_EIHDR_SIZE: spng_errno = 14;
pub const spng_errno_SPNG_ENOIHDR: spng_errno = 15;
pub const spng_errno_SPNG_ECHUNK_POS: spng_errno = 16;
pub const spng_errno_SPNG_ECHUNK_SIZE: spng_errno = 17;
pub const spng_errno_SPNG_ECHUNK_CRC: spng_errno = 18;
pub const spng_errno_SPNG_ECHUNK_TYPE: spng_errno = 19;
pub const spng_errno_SPNG_ECHUNK_UNKNOWN_CRITICAL: spng_errno = 20;
pub const spng_errno_SPNG_EDUP_PLTE: spng_errno = 21;
pub const spng_errno_SPNG_EDUP_CHRM: spng_errno = 22;
pub const spng_errno_SPNG_EDUP_GAMA: spng_errno = 23;
pub const spng_errno_SPNG_EDUP_ICCP: spng_errno = 24;
pub const spng_errno_SPNG_EDUP_SBIT: spng_errno = 25;
pub const spng_errno_SPNG_EDUP_SRGB: spng_errno = 26;
pub const spng_errno_SPNG_EDUP_BKGD: spng_errno = 27;
pub const spng_errno_SPNG_EDUP_HIST: spng_errno = 28;
pub const spng_errno_SPNG_EDUP_TRNS: spng_errno = 29;
pub const spng_errno_SPNG_EDUP_PHYS: spng_errno = 30;
pub const spng_errno_SPNG_EDUP_TIME: spng_errno = 31;
pub const spng_errno_SPNG_EDUP_OFFS: spng_errno = 32;
pub const spng_errno_SPNG_EDUP_EXIF: spng_errno = 33;
pub const spng_errno_SPNG_ECHRM: spng_errno = 34;
pub const spng_errno_SPNG_EPLTE_IDX: spng_errno = 35;
pub const spng_errno_SPNG_ETRNS_COLOR_TYPE: spng_errno = 36;
pub const spng_errno_SPNG_ETRNS_NO_PLTE: spng_errno = 37;
pub const spng_errno_SPNG_EGAMA: spng_errno = 38;
pub const spng_errno_SPNG_EICCP_NAME: spng_errno = 39;
pub const spng_errno_SPNG_EICCP_COMPRESSION_METHOD: spng_errno = 40;
pub const spng_errno_SPNG_ESBIT: spng_errno = 41;
pub const spng_errno_SPNG_ESRGB: spng_errno = 42;
pub const spng_errno_SPNG_ETEXT: spng_errno = 43;
pub const spng_errno_SPNG_ETEXT_KEYWORD: spng_errno = 44;
pub const spng_errno_SPNG_EZTXT: spng_errno = 45;
pub const spng_errno_SPNG_EZTXT_COMPRESSION_METHOD: spng_errno = 46;
pub const spng_errno_SPNG_EITXT: spng_errno = 47;
pub const spng_errno_SPNG_EITXT_COMPRESSION_FLAG: spng_errno = 48;
pub const spng_errno_SPNG_EITXT_COMPRESSION_METHOD: spng_errno = 49;
pub const spng_errno_SPNG_EITXT_LANG_TAG: spng_errno = 50;
pub const spng_errno_SPNG_EITXT_TRANSLATED_KEY: spng_errno = 51;
pub const spng_errno_SPNG_EBKGD_NO_PLTE: spng_errno = 52;
pub const spng_errno_SPNG_EBKGD_PLTE_IDX: spng_errno = 53;
pub const spng_errno_SPNG_EHIST_NO_PLTE: spng_errno = 54;
pub const spng_errno_SPNG_EPHYS: spng_errno = 55;
pub const spng_errno_SPNG_ESPLT_NAME: spng_errno = 56;
pub const spng_errno_SPNG_ESPLT_DUP_NAME: spng_errno = 57;
pub const spng_errno_SPNG_ESPLT_DEPTH: spng_errno = 58;
pub const spng_errno_SPNG_ETIME: spng_errno = 59;
pub const spng_errno_SPNG_EOFFS: spng_errno = 60;
pub const spng_errno_SPNG_EEXIF: spng_errno = 61;
pub const spng_errno_SPNG_EIDAT_TOO_SHORT: spng_errno = 62;
pub const spng_errno_SPNG_EIDAT_STREAM: spng_errno = 63;
pub const spng_errno_SPNG_EZLIB: spng_errno = 64;
pub const spng_errno_SPNG_EFILTER: spng_errno = 65;
pub const spng_errno_SPNG_EBUFSIZ: spng_errno = 66;
pub const spng_errno_SPNG_EIO: spng_errno = 67;
pub const spng_errno_SPNG_EOF: spng_errno = 68;
pub const spng_errno_SPNG_EBUF_SET: spng_errno = 69;
pub const spng_errno_SPNG_EBADSTATE: spng_errno = 70;
pub const spng_errno_SPNG_EFMT: spng_errno = 71;
pub const spng_errno_SPNG_EFLAGS: spng_errno = 72;
pub const spng_errno_SPNG_ECHUNKAVAIL: spng_errno = 73;
pub const spng_errno_SPNG_ENCODE_ONLY: spng_errno = 74;
pub const spng_errno_SPNG_EOI: spng_errno = 75;
pub const spng_errno_SPNG_ENOPLTE: spng_errno = 76;
pub const spng_errno_SPNG_ECHUNK_LIMITS: spng_errno = 77;
pub const spng_errno_SPNG_EZLIB_INIT: spng_errno = 78;
pub const spng_errno_SPNG_ECHUNK_STDLEN: spng_errno = 79;
pub const spng_errno_SPNG_EINTERNAL: spng_errno = 80;
pub type spng_errno = libc::c_int;
pub const spng_text_type_SPNG_TEXT: spng_text_type = 1;
pub const spng_text_type_SPNG_ZTXT: spng_text_type = 2;
pub const spng_text_type_SPNG_ITXT: spng_text_type = 3;
pub type spng_text_type = libc::c_int;
pub const spng_color_type_SPNG_COLOR_TYPE_GRAYSCALE: spng_color_type = 0;
pub const spng_color_type_SPNG_COLOR_TYPE_TRUECOLOR: spng_color_type = 2;
pub const spng_color_type_SPNG_COLOR_TYPE_INDEXED: spng_color_type = 3;
pub const spng_color_type_SPNG_COLOR_TYPE_GRAYSCALE_ALPHA: spng_color_type = 4;
pub const spng_color_type_SPNG_COLOR_TYPE_TRUECOLOR_ALPHA: spng_color_type = 6;
pub type spng_color_type = libc::c_int;
pub const spng_filter_SPNG_FILTER_NONE: spng_filter = 0;
pub const spng_filter_SPNG_FILTER_SUB: spng_filter = 1;
pub const spng_filter_SPNG_FILTER_UP: spng_filter = 2;
pub const spng_filter_SPNG_FILTER_AVERAGE: spng_filter = 3;
pub const spng_filter_SPNG_FILTER_PAETH: spng_filter = 4;
pub type spng_filter = libc::c_int;
pub const spng_interlace_method_SPNG_INTERLACE_NONE: spng_interlace_method = 0;
pub const spng_interlace_method_SPNG_INTERLACE_ADAM7: spng_interlace_method = 1;
pub type spng_interlace_method = libc::c_int;
pub const spng_format_SPNG_FMT_RGBA8: spng_format = 1;
pub const spng_format_SPNG_FMT_RGBA16: spng_format = 2;
pub const spng_format_SPNG_FMT_RGB8: spng_format = 4;
pub const spng_format_SPNG_FMT_GA8: spng_format = 16;
pub const spng_format_SPNG_FMT_GA16: spng_format = 32;
pub const spng_format_SPNG_FMT_G8: spng_format = 64;
pub const spng_format_SPNG_FMT_PNG: spng_format = 256;
pub const spng_format_SPNG_FMT_RAW: spng_format = 512;
pub type spng_format = libc::c_int;
pub const spng_ctx_flags_SPNG_CTX_IGNORE_ADLER32: spng_ctx_flags = 1;
pub type spng_ctx_flags = libc::c_int;
pub const spng_decode_flags_SPNG_DECODE_USE_TRNS: spng_decode_flags = 1;
pub const spng_decode_flags_SPNG_DECODE_USE_GAMA: spng_decode_flags = 2;
pub const spng_decode_flags_SPNG_DECODE_USE_SBIT: spng_decode_flags = 8;
pub const spng_decode_flags_SPNG_DECODE_TRNS: spng_decode_flags = 1;
pub const spng_decode_flags_SPNG_DECODE_GAMMA: spng_decode_flags = 2;
pub const spng_decode_flags_SPNG_DECODE_PROGRESSIVE: spng_decode_flags = 256;
pub type spng_decode_flags = libc::c_int;
pub const spng_crc_action_SPNG_CRC_ERROR: spng_crc_action = 0;
pub const spng_crc_action_SPNG_CRC_DISCARD: spng_crc_action = 1;
pub const spng_crc_action_SPNG_CRC_USE: spng_crc_action = 2;
pub type spng_crc_action = libc::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_ihdr {
pub width: u32,
pub height: u32,
pub bit_depth: u8,
pub color_type: u8,
pub compression_method: u8,
pub filter_method: u8,
pub interlace_method: u8,
}
#[test]
fn bindgen_test_layout_spng_ihdr() {
assert_eq!(
::core::mem::size_of::<spng_ihdr>(),
16usize,
concat!("Size of: ", stringify!(spng_ihdr))
);
assert_eq!(
::core::mem::align_of::<spng_ihdr>(),
4usize,
concat!("Alignment of ", stringify!(spng_ihdr))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_ihdr>())).width as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_ihdr),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_ihdr>())).height as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_ihdr),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_ihdr>())).bit_depth as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_ihdr),
"::",
stringify!(bit_depth)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_ihdr>())).color_type as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(spng_ihdr),
"::",
stringify!(color_type)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_ihdr>())).compression_method as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(spng_ihdr),
"::",
stringify!(compression_method)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_ihdr>())).filter_method as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(spng_ihdr),
"::",
stringify!(filter_method)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_ihdr>())).interlace_method as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spng_ihdr),
"::",
stringify!(interlace_method)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_plte_entry {
pub red: u8,
pub green: u8,
pub blue: u8,
pub alpha: u8,
}
#[test]
fn bindgen_test_layout_spng_plte_entry() {
assert_eq!(
::core::mem::size_of::<spng_plte_entry>(),
4usize,
concat!("Size of: ", stringify!(spng_plte_entry))
);
assert_eq!(
::core::mem::align_of::<spng_plte_entry>(),
1usize,
concat!("Alignment of ", stringify!(spng_plte_entry))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_plte_entry>())).red as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_plte_entry),
"::",
stringify!(red)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_plte_entry>())).green as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(spng_plte_entry),
"::",
stringify!(green)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_plte_entry>())).blue as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(spng_plte_entry),
"::",
stringify!(blue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_plte_entry>())).alpha as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(spng_plte_entry),
"::",
stringify!(alpha)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct spng_plte {
pub n_entries: u32,
pub entries: [spng_plte_entry; 256usize],
}
#[test]
fn bindgen_test_layout_spng_plte() {
assert_eq!(
::core::mem::size_of::<spng_plte>(),
1028usize,
concat!("Size of: ", stringify!(spng_plte))
);
assert_eq!(
::core::mem::align_of::<spng_plte>(),
4usize,
concat!("Alignment of ", stringify!(spng_plte))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_plte>())).n_entries as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_plte),
"::",
stringify!(n_entries)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_plte>())).entries as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_plte),
"::",
stringify!(entries)
)
);
}
impl ::core::fmt::Debug for spng_plte {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
write!(
f,
"spng_plte {{ n_entries: {:?}, entries: [...] }}",
self.n_entries
)
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct spng_trns {
pub gray: u16,
pub red: u16,
pub green: u16,
pub blue: u16,
pub n_type3_entries: u32,
pub type3_alpha: [u8; 256usize],
}
#[test]
fn bindgen_test_layout_spng_trns() {
assert_eq!(
::core::mem::size_of::<spng_trns>(),
268usize,
concat!("Size of: ", stringify!(spng_trns))
);
assert_eq!(
::core::mem::align_of::<spng_trns>(),
4usize,
concat!("Alignment of ", stringify!(spng_trns))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_trns>())).gray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_trns),
"::",
stringify!(gray)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_trns>())).red as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(spng_trns),
"::",
stringify!(red)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_trns>())).green as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_trns),
"::",
stringify!(green)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_trns>())).blue as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(spng_trns),
"::",
stringify!(blue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_trns>())).n_type3_entries as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_trns),
"::",
stringify!(n_type3_entries)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_trns>())).type3_alpha as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spng_trns),
"::",
stringify!(type3_alpha)
)
);
}
impl ::core::fmt::Debug for spng_trns {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
write ! (f , "spng_trns {{ gray: {:?}, red: {:?}, green: {:?}, blue: {:?}, n_type3_entries: {:?}, type3_alpha: [...] }}" , self . gray , self . red , self . green , self . blue , self . n_type3_entries)
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_chrm_int {
pub white_point_x: u32,
pub white_point_y: u32,
pub red_x: u32,
pub red_y: u32,
pub green_x: u32,
pub green_y: u32,
pub blue_x: u32,
pub blue_y: u32,
}
#[test]
fn bindgen_test_layout_spng_chrm_int() {
assert_eq!(
::core::mem::size_of::<spng_chrm_int>(),
32usize,
concat!("Size of: ", stringify!(spng_chrm_int))
);
assert_eq!(
::core::mem::align_of::<spng_chrm_int>(),
4usize,
concat!("Alignment of ", stringify!(spng_chrm_int))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).white_point_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(white_point_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).white_point_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(white_point_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).red_x as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(red_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).red_y as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(red_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).green_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(green_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).green_y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(green_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).blue_x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(blue_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm_int>())).blue_y as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm_int),
"::",
stringify!(blue_y)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_chrm {
pub white_point_x: f64,
pub white_point_y: f64,
pub red_x: f64,
pub red_y: f64,
pub green_x: f64,
pub green_y: f64,
pub blue_x: f64,
pub blue_y: f64,
}
#[test]
fn bindgen_test_layout_spng_chrm() {
assert_eq!(
::core::mem::size_of::<spng_chrm>(),
64usize,
concat!("Size of: ", stringify!(spng_chrm))
);
assert_eq!(
::core::mem::align_of::<spng_chrm>(),
8usize,
concat!("Alignment of ", stringify!(spng_chrm))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).white_point_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(white_point_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).white_point_y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(white_point_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).red_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(red_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).red_y as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(red_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).green_x as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(green_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).green_y as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(green_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).blue_x as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(blue_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chrm>())).blue_y as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(spng_chrm),
"::",
stringify!(blue_y)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct spng_iccp {
pub profile_name: [libc::c_char; 80usize],
pub profile_len: usize,
pub profile: *mut libc::c_char,
}
#[test]
fn bindgen_test_layout_spng_iccp() {
assert_eq!(
::core::mem::size_of::<spng_iccp>(),
96usize,
concat!("Size of: ", stringify!(spng_iccp))
);
assert_eq!(
::core::mem::align_of::<spng_iccp>(),
8usize,
concat!("Alignment of ", stringify!(spng_iccp))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_iccp>())).profile_name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_iccp),
"::",
stringify!(profile_name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_iccp>())).profile_len as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spng_iccp),
"::",
stringify!(profile_len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_iccp>())).profile as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spng_iccp),
"::",
stringify!(profile)
)
);
}
impl ::core::fmt::Debug for spng_iccp {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
write!(
f,
"spng_iccp {{ profile_name: [...], profile_len: {:?}, profile: {:?} }}",
self.profile_len, self.profile
)
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_sbit {
pub grayscale_bits: u8,
pub red_bits: u8,
pub green_bits: u8,
pub blue_bits: u8,
pub alpha_bits: u8,
}
#[test]
fn bindgen_test_layout_spng_sbit() {
assert_eq!(
::core::mem::size_of::<spng_sbit>(),
5usize,
concat!("Size of: ", stringify!(spng_sbit))
);
assert_eq!(
::core::mem::align_of::<spng_sbit>(),
1usize,
concat!("Alignment of ", stringify!(spng_sbit))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_sbit>())).grayscale_bits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_sbit),
"::",
stringify!(grayscale_bits)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_sbit>())).red_bits as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(spng_sbit),
"::",
stringify!(red_bits)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_sbit>())).green_bits as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(spng_sbit),
"::",
stringify!(green_bits)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_sbit>())).blue_bits as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(spng_sbit),
"::",
stringify!(blue_bits)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_sbit>())).alpha_bits as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_sbit),
"::",
stringify!(alpha_bits)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct spng_text {
pub keyword: [libc::c_char; 80usize],
pub type_: libc::c_int,
pub length: usize,
pub text: *mut libc::c_char,
pub compression_flag: u8,
pub compression_method: u8,
pub language_tag: *mut libc::c_char,
pub translated_keyword: *mut libc::c_char,
}
#[test]
fn bindgen_test_layout_spng_text() {
assert_eq!(
::core::mem::size_of::<spng_text>(),
128usize,
concat!("Size of: ", stringify!(spng_text))
);
assert_eq!(
::core::mem::align_of::<spng_text>(),
8usize,
concat!("Alignment of ", stringify!(spng_text))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).keyword as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(keyword)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).type_ as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).length as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).text as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).compression_flag as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(compression_flag)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).compression_method as *const _ as usize },
105usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(compression_method)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).language_tag as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(language_tag)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_text>())).translated_keyword as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(spng_text),
"::",
stringify!(translated_keyword)
)
);
}
impl ::core::fmt::Debug for spng_text {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
write ! (f , "spng_text {{ keyword: [...], type: {:?}, length: {:?}, text: {:?}, compression_flag: {:?}, compression_method: {:?}, language_tag: {:?}, translated_keyword: {:?} }}" , self . type_ , self . length , self . text , self . compression_flag , self . compression_method , self . language_tag , self . translated_keyword)
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_bkgd {
pub gray: u16,
pub red: u16,
pub green: u16,
pub blue: u16,
pub plte_index: u16,
}
#[test]
fn bindgen_test_layout_spng_bkgd() {
assert_eq!(
::core::mem::size_of::<spng_bkgd>(),
10usize,
concat!("Size of: ", stringify!(spng_bkgd))
);
assert_eq!(
::core::mem::align_of::<spng_bkgd>(),
2usize,
concat!("Alignment of ", stringify!(spng_bkgd))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_bkgd>())).gray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_bkgd),
"::",
stringify!(gray)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_bkgd>())).red as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(spng_bkgd),
"::",
stringify!(red)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_bkgd>())).green as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_bkgd),
"::",
stringify!(green)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_bkgd>())).blue as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(spng_bkgd),
"::",
stringify!(blue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_bkgd>())).plte_index as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_bkgd),
"::",
stringify!(plte_index)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct spng_hist {
pub frequency: [u16; 256usize],
}
#[test]
fn bindgen_test_layout_spng_hist() {
assert_eq!(
::core::mem::size_of::<spng_hist>(),
512usize,
concat!("Size of: ", stringify!(spng_hist))
);
assert_eq!(
::core::mem::align_of::<spng_hist>(),
2usize,
concat!("Alignment of ", stringify!(spng_hist))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_hist>())).frequency as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_hist),
"::",
stringify!(frequency)
)
);
}
impl ::core::fmt::Debug for spng_hist {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
write!(f, "spng_hist {{ frequency: [...] }}")
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_phys {
pub ppu_x: u32,
pub ppu_y: u32,
pub unit_specifier: u8,
}
#[test]
fn bindgen_test_layout_spng_phys() {
assert_eq!(
::core::mem::size_of::<spng_phys>(),
12usize,
concat!("Size of: ", stringify!(spng_phys))
);
assert_eq!(
::core::mem::align_of::<spng_phys>(),
4usize,
concat!("Alignment of ", stringify!(spng_phys))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_phys>())).ppu_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_phys),
"::",
stringify!(ppu_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_phys>())).ppu_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_phys),
"::",
stringify!(ppu_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_phys>())).unit_specifier as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_phys),
"::",
stringify!(unit_specifier)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_splt_entry {
pub red: u16,
pub green: u16,
pub blue: u16,
pub alpha: u16,
pub frequency: u16,
}
#[test]
fn bindgen_test_layout_spng_splt_entry() {
assert_eq!(
::core::mem::size_of::<spng_splt_entry>(),
10usize,
concat!("Size of: ", stringify!(spng_splt_entry))
);
assert_eq!(
::core::mem::align_of::<spng_splt_entry>(),
2usize,
concat!("Alignment of ", stringify!(spng_splt_entry))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt_entry>())).red as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_splt_entry),
"::",
stringify!(red)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt_entry>())).green as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(spng_splt_entry),
"::",
stringify!(green)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt_entry>())).blue as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_splt_entry),
"::",
stringify!(blue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt_entry>())).alpha as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(spng_splt_entry),
"::",
stringify!(alpha)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt_entry>())).frequency as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_splt_entry),
"::",
stringify!(frequency)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct spng_splt {
pub name: [libc::c_char; 80usize],
pub sample_depth: u8,
pub n_entries: u32,
pub entries: *mut spng_splt_entry,
}
#[test]
fn bindgen_test_layout_spng_splt() {
assert_eq!(
::core::mem::size_of::<spng_splt>(),
96usize,
concat!("Size of: ", stringify!(spng_splt))
);
assert_eq!(
::core::mem::align_of::<spng_splt>(),
8usize,
concat!("Alignment of ", stringify!(spng_splt))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_splt),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt>())).sample_depth as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(spng_splt),
"::",
stringify!(sample_depth)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt>())).n_entries as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(spng_splt),
"::",
stringify!(n_entries)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_splt>())).entries as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(spng_splt),
"::",
stringify!(entries)
)
);
}
impl ::core::fmt::Debug for spng_splt {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
write!(
f,
"spng_splt {{ name: [...], sample_depth: {:?}, n_entries: {:?}, entries: {:?} }}",
self.sample_depth, self.n_entries, self.entries
)
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_time {
pub year: u16,
pub month: u8,
pub day: u8,
pub hour: u8,
pub minute: u8,
pub second: u8,
}
#[test]
fn bindgen_test_layout_spng_time() {
assert_eq!(
::core::mem::size_of::<spng_time>(),
8usize,
concat!("Size of: ", stringify!(spng_time))
);
assert_eq!(
::core::mem::align_of::<spng_time>(),
2usize,
concat!("Alignment of ", stringify!(spng_time))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_time>())).year as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_time),
"::",
stringify!(year)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_time>())).month as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(spng_time),
"::",
stringify!(month)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_time>())).day as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(spng_time),
"::",
stringify!(day)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_time>())).hour as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_time),
"::",
stringify!(hour)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_time>())).minute as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(spng_time),
"::",
stringify!(minute)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_time>())).second as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(spng_time),
"::",
stringify!(second)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_offs {
pub x: i32,
pub y: i32,
pub unit_specifier: u8,
}
#[test]
fn bindgen_test_layout_spng_offs() {
assert_eq!(
::core::mem::size_of::<spng_offs>(),
12usize,
concat!("Size of: ", stringify!(spng_offs))
);
assert_eq!(
::core::mem::align_of::<spng_offs>(),
4usize,
concat!("Alignment of ", stringify!(spng_offs))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_offs>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_offs),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_offs>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_offs),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_offs>())).unit_specifier as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_offs),
"::",
stringify!(unit_specifier)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_exif {
pub length: usize,
pub data: *mut libc::c_char,
}
#[test]
fn bindgen_test_layout_spng_exif() {
assert_eq!(
::core::mem::size_of::<spng_exif>(),
16usize,
concat!("Size of: ", stringify!(spng_exif))
);
assert_eq!(
::core::mem::align_of::<spng_exif>(),
8usize,
concat!("Alignment of ", stringify!(spng_exif))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_exif>())).length as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_exif),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_exif>())).data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_exif),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_chunk {
pub offset: usize,
pub length: u32,
pub type_: [u8; 4usize],
pub crc: u32,
}
#[test]
fn bindgen_test_layout_spng_chunk() {
assert_eq!(
::core::mem::size_of::<spng_chunk>(),
24usize,
concat!("Size of: ", stringify!(spng_chunk))
);
assert_eq!(
::core::mem::align_of::<spng_chunk>(),
8usize,
concat!("Alignment of ", stringify!(spng_chunk))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chunk>())).offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_chunk),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chunk>())).length as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_chunk),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chunk>())).type_ as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spng_chunk),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_chunk>())).crc as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spng_chunk),
"::",
stringify!(crc)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_unknown_chunk {
pub type_: [u8; 4usize],
pub length: usize,
pub data: *mut libc::c_void,
}
#[test]
fn bindgen_test_layout_spng_unknown_chunk() {
assert_eq!(
::core::mem::size_of::<spng_unknown_chunk>(),
24usize,
concat!("Size of: ", stringify!(spng_unknown_chunk))
);
assert_eq!(
::core::mem::align_of::<spng_unknown_chunk>(),
8usize,
concat!("Alignment of ", stringify!(spng_unknown_chunk))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_unknown_chunk>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_unknown_chunk),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_unknown_chunk>())).length as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_unknown_chunk),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_unknown_chunk>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spng_unknown_chunk),
"::",
stringify!(data)
)
);
}
pub type spng_malloc_fn =
::core::option::Option<unsafe extern "C" fn(size: usize) -> *mut libc::c_void>;
pub type spng_realloc_fn = ::core::option::Option<
unsafe extern "C" fn(ptr: *mut libc::c_void, size: usize) -> *mut libc::c_void,
>;
pub type spng_calloc_fn =
::core::option::Option<unsafe extern "C" fn(count: usize, size: usize) -> *mut libc::c_void>;
pub type spng_free_fn = ::core::option::Option<unsafe extern "C" fn(ptr: *mut libc::c_void)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_alloc {
pub malloc_fn: spng_malloc_fn,
pub realloc_fn: spng_realloc_fn,
pub calloc_fn: spng_calloc_fn,
pub free_fn: spng_free_fn,
}
#[test]
fn bindgen_test_layout_spng_alloc() {
assert_eq!(
::core::mem::size_of::<spng_alloc>(),
32usize,
concat!("Size of: ", stringify!(spng_alloc))
);
assert_eq!(
::core::mem::align_of::<spng_alloc>(),
8usize,
concat!("Alignment of ", stringify!(spng_alloc))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_alloc>())).malloc_fn as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_alloc),
"::",
stringify!(malloc_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_alloc>())).realloc_fn as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_alloc),
"::",
stringify!(realloc_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_alloc>())).calloc_fn as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(spng_alloc),
"::",
stringify!(calloc_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_alloc>())).free_fn as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(spng_alloc),
"::",
stringify!(free_fn)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_row_info {
pub scanline_idx: u32,
pub row_num: u32,
pub pass: libc::c_int,
pub filter: u8,
}
#[test]
fn bindgen_test_layout_spng_row_info() {
assert_eq!(
::core::mem::size_of::<spng_row_info>(),
16usize,
concat!("Size of: ", stringify!(spng_row_info))
);
assert_eq!(
::core::mem::align_of::<spng_row_info>(),
4usize,
concat!("Alignment of ", stringify!(spng_row_info))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_row_info>())).scanline_idx as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(spng_row_info),
"::",
stringify!(scanline_idx)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_row_info>())).row_num as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(spng_row_info),
"::",
stringify!(row_num)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_row_info>())).pass as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(spng_row_info),
"::",
stringify!(pass)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<spng_row_info>())).filter as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(spng_row_info),
"::",
stringify!(filter)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spng_ctx {
_unused: [u8; 0],
}
pub type spng_read_fn = ::core::option::Option<
unsafe extern "C" fn(
ctx: *mut spng_ctx,
user: *mut libc::c_void,
dest: *mut libc::c_void,
length: usize,
) -> libc::c_int,
>;
extern "C" {
pub fn spng_ctx_new(flags: libc::c_int) -> *mut spng_ctx;
}
extern "C" {
pub fn spng_ctx_new2(alloc: *mut spng_alloc, flags: libc::c_int) -> *mut spng_ctx;
}
extern "C" {
pub fn spng_ctx_free(ctx: *mut spng_ctx);
}
extern "C" {
pub fn spng_set_png_buffer(
ctx: *mut spng_ctx,
buf: *const libc::c_void,
size: usize,
) -> libc::c_int;
}
extern "C" {
pub fn spng_set_png_stream(
ctx: *mut spng_ctx,
read_fn: spng_read_fn,
user: *mut libc::c_void,
) -> libc::c_int;
}
extern "C" {
pub fn spng_set_png_file(ctx: *mut spng_ctx, file: *mut FILE) -> libc::c_int;
}
extern "C" {
pub fn spng_set_image_limits(ctx: *mut spng_ctx, width: u32, height: u32) -> libc::c_int;
}
extern "C" {
pub fn spng_get_image_limits(
ctx: *mut spng_ctx,
width: *mut u32,
height: *mut u32,
) -> libc::c_int;
}
extern "C" {
pub fn spng_set_chunk_limits(
ctx: *mut spng_ctx,
chunk_size: usize,
cache_size: usize,
) -> libc::c_int;
}
extern "C" {
pub fn spng_get_chunk_limits(
ctx: *mut spng_ctx,
chunk_size: *mut usize,
cache_size: *mut usize,
) -> libc::c_int;
}
extern "C" {
pub fn spng_set_crc_action(
ctx: *mut spng_ctx,
critical: libc::c_int,
ancillary: libc::c_int,
) -> libc::c_int;
}
extern "C" {
pub fn spng_decoded_image_size(
ctx: *mut spng_ctx,
fmt: libc::c_int,
len: *mut usize,
) -> libc::c_int;
}
extern "C" {
pub fn spng_decode_image(
ctx: *mut spng_ctx,
out: *mut libc::c_void,
len: usize,
fmt: libc::c_int,
flags: libc::c_int,
) -> libc::c_int;
}
extern "C" {
pub fn spng_decode_scanline(
ctx: *mut spng_ctx,
out: *mut libc::c_void,
len: usize,
) -> libc::c_int;
}
extern "C" {
pub fn spng_decode_row(ctx: *mut spng_ctx, out: *mut libc::c_void, len: usize) -> libc::c_int;
}
extern "C" {
pub fn spng_get_row_info(ctx: *mut spng_ctx, row_info: *mut spng_row_info) -> libc::c_int;
}
extern "C" {
pub fn spng_get_ihdr(ctx: *mut spng_ctx, ihdr: *mut spng_ihdr) -> libc::c_int;
}
extern "C" {
pub fn spng_get_plte(ctx: *mut spng_ctx, plte: *mut spng_plte) -> libc::c_int;
}
extern "C" {
pub fn spng_get_trns(ctx: *mut spng_ctx, trns: *mut spng_trns) -> libc::c_int;
}
extern "C" {
pub fn spng_get_chrm(ctx: *mut spng_ctx, chrm: *mut spng_chrm) -> libc::c_int;
}
extern "C" {
pub fn spng_get_chrm_int(ctx: *mut spng_ctx, chrm_int: *mut spng_chrm_int) -> libc::c_int;
}
extern "C" {
pub fn spng_get_gama(ctx: *mut spng_ctx, gamma: *mut f64) -> libc::c_int;
}
extern "C" {
pub fn spng_get_iccp(ctx: *mut spng_ctx, iccp: *mut spng_iccp) -> libc::c_int;
}
extern "C" {
pub fn spng_get_sbit(ctx: *mut spng_ctx, sbit: *mut spng_sbit) -> libc::c_int;
}
extern "C" {
pub fn spng_get_srgb(ctx: *mut spng_ctx, rendering_intent: *mut u8) -> libc::c_int;
}
extern "C" {
pub fn spng_get_text(ctx: *mut spng_ctx, text: *mut spng_text, n_text: *mut u32)
-> libc::c_int;
}
extern "C" {
pub fn spng_get_bkgd(ctx: *mut spng_ctx, bkgd: *mut spng_bkgd) -> libc::c_int;
}
extern "C" {
pub fn spng_get_hist(ctx: *mut spng_ctx, hist: *mut spng_hist) -> libc::c_int;
}
extern "C" {
pub fn spng_get_phys(ctx: *mut spng_ctx, phys: *mut spng_phys) -> libc::c_int;
}
extern "C" {
pub fn spng_get_splt(ctx: *mut spng_ctx, splt: *mut spng_splt, n_splt: *mut u32)
-> libc::c_int;
}
extern "C" {
pub fn spng_get_time(ctx: *mut spng_ctx, time: *mut spng_time) -> libc::c_int;
}
extern "C" {
pub fn spng_get_offs(ctx: *mut spng_ctx, offs: *mut spng_offs) -> libc::c_int;
}
extern "C" {
pub fn spng_get_exif(ctx: *mut spng_ctx, exif: *mut spng_exif) -> libc::c_int;
}
extern "C" {
pub fn spng_set_ihdr(ctx: *mut spng_ctx, ihdr: *mut spng_ihdr) -> libc::c_int;
}
extern "C" {
pub fn spng_set_plte(ctx: *mut spng_ctx, plte: *mut spng_plte) -> libc::c_int;
}
extern "C" {
pub fn spng_set_trns(ctx: *mut spng_ctx, trns: *mut spng_trns) -> libc::c_int;
}
extern "C" {
pub fn spng_set_chrm(ctx: *mut spng_ctx, chrm: *mut spng_chrm) -> libc::c_int;
}
extern "C" {
pub fn spng_set_chrm_int(ctx: *mut spng_ctx, chrm_int: *mut spng_chrm_int) -> libc::c_int;
}
extern "C" {
pub fn spng_set_gama(ctx: *mut spng_ctx, gamma: f64) -> libc::c_int;
}
extern "C" {
pub fn spng_set_iccp(ctx: *mut spng_ctx, iccp: *mut spng_iccp) -> libc::c_int;
}
extern "C" {
pub fn spng_set_sbit(ctx: *mut spng_ctx, sbit: *mut spng_sbit) -> libc::c_int;
}
extern "C" {
pub fn spng_set_srgb(ctx: *mut spng_ctx, rendering_intent: u8) -> libc::c_int;
}
extern "C" {
pub fn spng_set_text(ctx: *mut spng_ctx, text: *mut spng_text, n_text: u32) -> libc::c_int;
}
extern "C" {
pub fn spng_set_bkgd(ctx: *mut spng_ctx, bkgd: *mut spng_bkgd) -> libc::c_int;
}
extern "C" {
pub fn spng_set_hist(ctx: *mut spng_ctx, hist: *mut spng_hist) -> libc::c_int;
}
extern "C" {
pub fn spng_set_phys(ctx: *mut spng_ctx, phys: *mut spng_phys) -> libc::c_int;
}
extern "C" {
pub fn spng_set_splt(ctx: *mut spng_ctx, splt: *mut spng_splt, n_splt: u32) -> libc::c_int;
}
extern "C" {
pub fn spng_set_time(ctx: *mut spng_ctx, time: *mut spng_time) -> libc::c_int;
}
extern "C" {
pub fn spng_set_offs(ctx: *mut spng_ctx, offs: *mut spng_offs) -> libc::c_int;
}
extern "C" {
pub fn spng_set_exif(ctx: *mut spng_ctx, exif: *mut spng_exif) -> libc::c_int;
}
extern "C" {
pub fn spng_get_unknown_chunks(
ctx: *mut spng_ctx,
chunks: *mut spng_unknown_chunk,
n_chunks: *mut u32,
) -> libc::c_int;
}
extern "C" {
pub fn spng_strerror(err: libc::c_int) -> *const libc::c_char;
}
extern "C" {
pub fn spng_version_string() -> *const libc::c_char;
}